summaryrefslogtreecommitdiffstats
path: root/gst/mxf/mxfdms1.c
diff options
context:
space:
mode:
Diffstat (limited to 'gst/mxf/mxfdms1.c')
-rw-r--r--gst/mxf/mxfdms1.c6088
1 files changed, 6088 insertions, 0 deletions
diff --git a/gst/mxf/mxfdms1.c b/gst/mxf/mxfdms1.c
index 89ef14a9..a0ffe11d 100644
--- a/gst/mxf/mxfdms1.c
+++ b/gst/mxf/mxfdms1.c
@@ -19,6 +19,11 @@
/* Implementation of SMPTE S380M - Descriptive Metadata Scheme-1 */
+/* TODO:
+ * - What are the "locators"?
+ * - Create sensible tags from this
+ */
+
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
@@ -27,3 +32,6086 @@
#include <string.h>
#include "mxfdms1.h"
+#include "mxfparse.h"
+
+GST_DEBUG_CATEGORY_EXTERN (mxf_debug);
+#define GST_CAT_DEFAULT mxf_debug
+
+G_DEFINE_TYPE (MXFDMS1, mxf_dms1, MXF_TYPE_DESCRIPTIVE_METADATA);
+
+static gboolean
+mxf_dms1_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1 *self = MXF_DMS1 (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 instance_uid_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 generation_uid_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 0x05,
+ 0x20, 0x07, 0x01, 0x08, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &instance_uid_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+ memcpy (&MXF_METADATA_BASE (self)->instance_uid, tag_data, 16);
+ GST_DEBUG (" instance uid = %s",
+ mxf_ul_to_string (&MXF_METADATA_BASE (self)->instance_uid, str));
+ } else if (memcmp (tag_ul, &generation_uid_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+ memcpy (&MXF_METADATA_BASE (self)->generation_uid, tag_data, 16);
+ GST_DEBUG (" generation uid = %s",
+ mxf_ul_to_string (&MXF_METADATA_BASE (self)->generation_uid, str));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_init (MXFDMS1 * self)
+{
+}
+
+static void
+mxf_dms1_class_init (MXFDMS1Class * klass)
+{
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ metadatabase_class->handle_tag = mxf_dms1_handle_tag;
+}
+
+G_DEFINE_ABSTRACT_TYPE (MXFDMS1TextLanguage, mxf_dms1_text_language,
+ MXF_TYPE_DMS1);
+
+static gboolean
+mxf_dms1_text_language_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1TextLanguage *self = MXF_DMS1_TEXT_LANGUAGE (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 extended_text_language_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x01, 0x01, 0x02, 0x02, 0x11, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &extended_text_language_code_ul, 16) == 0) {
+ if (tag_size > 12)
+ goto error;
+
+ memcpy (self->extended_text_language_code, tag_data, tag_size);
+ GST_DEBUG (" extended text language code = %s",
+ self->extended_text_language_code);
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_text_language_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 text language local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_text_language_init (MXFDMS1TextLanguage * self)
+{
+}
+
+static void
+mxf_dms1_text_language_class_init (MXFDMS1TextLanguageClass * klass)
+{
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ metadatabase_class->handle_tag = mxf_dms1_text_language_handle_tag;
+}
+
+G_DEFINE_ABSTRACT_TYPE (MXFDMS1Thesaurus, mxf_dms1_thesaurus,
+ MXF_TYPE_DMS1_TEXT_LANGUAGE);
+
+static void
+mxf_dms1_thesaurus_finalize (GstMiniObject * object)
+{
+ MXFDMS1Thesaurus *self = MXF_DMS1_THESAURUS (object);
+
+ g_free (self->thesaurus_name);
+ self->thesaurus_name = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_thesaurus_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_thesaurus_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Thesaurus *self = MXF_DMS1_THESAURUS (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 thesaurus_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &thesaurus_name_ul, 16) == 0) {
+ self->thesaurus_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" thesaurus name = %s", GST_STR_NULL (self->thesaurus_name));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_thesaurus_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_thesaurus_init (MXFDMS1Thesaurus * self)
+{
+}
+
+static void
+mxf_dms1_thesaurus_class_init (MXFDMS1ThesaurusClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_thesaurus_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_thesaurus_handle_tag;
+}
+
+static void
+mxf_dms1_framework_interface_init (gpointer g_iface, gpointer iface_data)
+{
+}
+
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MXFDMS1Framework, mxf_dms1_framework,
+ MXF_TYPE_DMS1,
+ G_IMPLEMENT_INTERFACE (MXF_TYPE_DESCRIPTIVE_METADATA_FRAMEWORK,
+ mxf_dms1_framework_interface_init));
+
+static void
+mxf_dms1_framework_finalize (GstMiniObject * object)
+{
+ MXFDMS1Framework *self = MXF_DMS1_FRAMEWORK (object);
+
+ g_free (self->framework_thesaurus_name);
+ self->framework_thesaurus_name = NULL;
+
+ g_free (self->framework_title);
+ self->framework_title = NULL;
+
+ g_free (self->metadata_server_locators_uids);
+ self->metadata_server_locators_uids = NULL;
+
+ g_free (self->titles_sets_uids);
+ self->titles_sets_uids = NULL;
+
+ g_free (self->titles_sets);
+ self->titles_sets = NULL;
+
+ g_free (self->annotations_sets_uids);
+ self->annotations_sets_uids = NULL;
+
+ g_free (self->annotations_sets);
+ self->annotations_sets = NULL;
+
+ g_free (self->participant_sets_uids);
+ self->participant_sets_uids = NULL;
+
+ g_free (self->participant_sets);
+ self->participant_sets = NULL;
+
+ g_free (self->location_sets_uids);
+ self->location_sets_uids = NULL;
+
+ g_free (self->location_sets);
+ self->location_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_framework_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_framework_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Framework *self = MXF_DMS1_FRAMEWORK (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->titles_sets = g_new0 (MXFDMS1Titles *, self->n_titles_sets);
+ self->annotations_sets =
+ g_new0 (MXFDMS1Annotation *, self->n_annotations_sets);
+ self->participant_sets =
+ g_new0 (MXFDMS1Participant *, self->n_participant_sets);
+ self->location_sets = g_new0 (MXFDMS1Location *, self->n_location_sets);
+ while (*p != NULL) {
+ current = *p;
+
+ if (MXF_IS_DMS1_TITLES (current)) {
+ for (i = 0; i < self->n_titles_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->titles_sets_uids[i])) {
+ self->titles_sets[i] = MXF_DMS1_TITLES (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_ANNOTATION (current)) {
+ for (i = 0; i < self->n_annotations_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->annotations_sets_uids[i])) {
+ self->annotations_sets[i] = MXF_DMS1_ANNOTATION (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_PARTICIPANT (current)) {
+ for (i = 0; i < self->n_participant_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->participant_sets_uids[i])) {
+ self->participant_sets[i] = MXF_DMS1_PARTICIPANT (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_CONTACTS_LIST (current)) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->contacts_list_set_uid)) {
+ self->contacts_list_set = MXF_DMS1_CONTACTS_LIST (current);
+ }
+ }
+
+ if (MXF_IS_DMS1_LOCATION (current)) {
+ for (i = 0; i < self->n_location_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->location_sets_uids[i])) {
+ self->location_sets[i] = MXF_DMS1_LOCATION (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_framework_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_framework_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Framework *self = MXF_DMS1_FRAMEWORK (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 framework_extended_text_language_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x01, 0x01, 0x02, 0x02, 0x13, 0x00, 0x00
+ };
+ static const guint8 framework_thesaurus_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x02, 0x15, 0x01, 0x00, 0x00
+ };
+ static const guint8 framework_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x05, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 primary_extended_spoken_language_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x01, 0x01, 0x02, 0x03, 0x11, 0x00, 0x00
+ };
+ static const guint8 secondary_extended_spoken_language_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x01, 0x01, 0x02, 0x03, 0x12, 0x00, 0x00
+ };
+ static const guint8 original_extended_spoken_language_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x01, 0x01, 0x02, 0x03, 0x13, 0x00, 0x00
+ };
+ static const guint8 metadata_server_locators_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x06, 0x0C, 0x00, 0x00
+ };
+ static const guint8 titles_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x04, 0x00
+ };
+ static const guint8 annotation_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0d, 0x00
+ };
+ static const guint8 participant_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x13, 0x00
+ };
+ static const guint8 contacts_list_set_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x02, 0x40, 0x22, 0x00
+ };
+ static const guint8 location_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x16, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &framework_extended_text_language_code_ul, 16) == 0) {
+ if (tag_size > 12)
+ goto error;
+ memcpy (&self->framework_extended_text_language_code, tag_data, tag_size);
+ GST_DEBUG (" framework extended text language code = %s",
+ self->framework_extended_text_language_code);
+ } else if (memcmp (tag_ul, &framework_thesaurus_name_ul, 16) == 0) {
+ self->framework_thesaurus_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" framework thesaurus name = %s",
+ GST_STR_NULL (self->framework_thesaurus_name));
+ } else if (memcmp (tag_ul, &framework_title_ul, 16) == 0) {
+ self->framework_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" framework title = %s", GST_STR_NULL (self->framework_title));
+ } else if (memcmp (tag_ul, &primary_extended_spoken_language_code_ul,
+ 16) == 0) {
+ if (tag_size > 12)
+ goto error;
+ memcpy (&self->primary_extended_spoken_language_code, tag_data, tag_size);
+ GST_DEBUG (" primary extended spoken language code = %s",
+ self->primary_extended_spoken_language_code);
+ } else if (memcmp (tag_ul, &secondary_extended_spoken_language_code_ul,
+ 16) == 0) {
+ if (tag_size > 12)
+ goto error;
+ memcpy (&self->secondary_extended_spoken_language_code, tag_data, tag_size);
+ GST_DEBUG (" secondary extended spoken language code = %s",
+ self->secondary_extended_spoken_language_code);
+ } else if (memcmp (tag_ul, &original_extended_spoken_language_code_ul,
+ 16) == 0) {
+ if (tag_size > 12)
+ goto error;
+ memcpy (&self->original_extended_spoken_language_code, tag_data, tag_size);
+ GST_DEBUG (" original extended spoken language code = %s",
+ self->original_extended_spoken_language_code);
+ } else if (memcmp (tag_ul, &metadata_server_locators_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of metadata server locators = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_metadata_server_locators = len;
+ self->metadata_server_locators_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->metadata_server_locators_uids[i], tag_data, 16);
+ GST_DEBUG (" metadata server locator %u = %s", i,
+ mxf_ul_to_string (&self->metadata_server_locators_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &titles_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of titles sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_titles_sets = len;
+ self->titles_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->titles_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" titles sets %u = %s", i,
+ mxf_ul_to_string (&self->titles_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &annotation_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of annotation sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_annotations_sets = len;
+ self->annotations_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->annotations_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" annotation sets %u = %s", i,
+ mxf_ul_to_string (&self->annotations_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &participant_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of participant sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_participant_sets = len;
+ self->participant_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->participant_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" participant sets %u = %s", i,
+ mxf_ul_to_string (&self->participant_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &contacts_list_set_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->contacts_list_set_uid, tag_data, 16);
+ GST_DEBUG (" contacts list = %s",
+ mxf_ul_to_string (&self->contacts_list_set_uid, str));
+ } else if (memcmp (tag_ul, &location_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of location sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_location_sets = len;
+ self->location_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->location_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" location sets %u = %s", i,
+ mxf_ul_to_string (&self->location_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_framework_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 framework local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_framework_init (MXFDMS1Framework * self)
+{
+}
+
+static void
+mxf_dms1_framework_class_init (MXFDMS1FrameworkClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_framework_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_framework_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_framework_resolve;
+}
+
+G_DEFINE_ABSTRACT_TYPE (MXFDMS1ProductionClipFramework,
+ mxf_dms1_production_clip_framework, MXF_TYPE_DMS1_FRAMEWORK);
+
+static void
+mxf_dms1_production_clip_framework_finalize (GstMiniObject * object)
+{
+ MXFDMS1ProductionClipFramework *self =
+ MXF_DMS1_PRODUCTION_CLIP_FRAMEWORK (object);
+
+ g_free (self->captions_description_sets_uids);
+ self->captions_description_sets_uids = NULL;
+
+ g_free (self->captions_description_sets);
+ self->captions_description_sets = NULL;
+
+ g_free (self->contract_sets_uids);
+ self->contract_sets_uids = NULL;
+
+ g_free (self->contract_sets);
+ self->contract_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS
+ (mxf_dms1_production_clip_framework_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_production_clip_framework_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1ProductionClipFramework *self = MXF_DMS1_PRODUCTION_CLIP_FRAMEWORK (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->captions_description_sets =
+ g_new0 (MXFDMS1CaptionsDescription *, self->n_captions_description_sets);
+ self->contract_sets = g_new0 (MXFDMS1Contract *, self->n_contract_sets);
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_PICTURE_FORMAT (current)) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->picture_format_set_uid)) {
+ self->picture_format = MXF_DMS1_PICTURE_FORMAT (current);
+ }
+ }
+
+ if (MXF_IS_DMS1_CAPTIONS_DESCRIPTION (current)) {
+ for (i = 0; i < self->n_captions_description_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->captions_description_sets_uids[i])) {
+ self->captions_description_sets[i] =
+ MXF_DMS1_CAPTIONS_DESCRIPTION (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_CONTRACT (current)) {
+ for (i = 0; i < self->n_contract_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->contract_sets_uids[i])) {
+ self->contract_sets[i] = MXF_DMS1_CONTRACT (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_PROJECT (current)) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->project_set_uid)) {
+ self->project_set = MXF_DMS1_PROJECT (current);
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_production_clip_framework_parent_class)->resolve (m, metadata);
+}
+
+static gboolean
+mxf_dms1_production_clip_framework_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1ProductionClipFramework *self =
+ MXF_DMS1_PRODUCTION_CLIP_FRAMEWORK (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 picture_format_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x02, 0x40, 0x1d, 0x00
+ };
+ static const guint8 captions_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0c, 0x00
+ };
+ static const guint8 contract_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x19, 0x00
+ };
+ static const guint8 project_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x02, 0x40, 0x21, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &picture_format_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->picture_format_set_uid, tag_data, 16);
+ GST_DEBUG (" picture format set = %s",
+ mxf_ul_to_string (&self->picture_format_set_uid, str));
+ } else if (memcmp (tag_ul, &captions_description_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of captions description sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_captions_description_sets = len;
+ self->captions_description_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->captions_description_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" captions description sets %u = %s", i,
+ mxf_ul_to_string (&self->captions_description_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &contract_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of contract sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_contract_sets = len;
+ self->contract_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->contract_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" contract sets %u = %s", i,
+ mxf_ul_to_string (&self->contract_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &project_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->project_set_uid, tag_data, 16);
+ GST_DEBUG (" project set = %s", mxf_ul_to_string (&self->project_set_uid,
+ str));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_production_clip_framework_parent_class)->handle_tag (metadata,
+ primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR
+ ("Invalid DMS1 production-clip framework local tag 0x%04x of size %u",
+ tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_production_clip_framework_init (MXFDMS1ProductionClipFramework * self)
+{
+}
+
+static void
+ mxf_dms1_production_clip_framework_class_init
+ (MXFDMS1ProductionClipFrameworkClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_production_clip_framework_finalize;
+ metadatabase_class->handle_tag =
+ mxf_dms1_production_clip_framework_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_production_clip_framework_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1ProductionFramework, mxf_dms1_production_framework,
+ MXF_TYPE_DMS1_PRODUCTION_CLIP_FRAMEWORK);
+
+static void
+mxf_dms1_production_framework_finalize (GstMiniObject * object)
+{
+ MXFDMS1ProductionFramework *self = MXF_DMS1_PRODUCTION_FRAMEWORK (object);
+
+ g_free (self->integration_indication);
+ self->integration_indication = NULL;
+
+ g_free (self->identification_sets_uids);
+ self->identification_sets_uids = NULL;
+
+ g_free (self->identification_sets);
+ self->identification_sets = NULL;
+
+ g_free (self->group_relationship_sets_uids);
+ self->group_relationship_sets_uids = NULL;
+
+ g_free (self->group_relationship_sets);
+ self->group_relationship_sets = NULL;
+
+ g_free (self->branding_sets_uids);
+ self->branding_sets_uids = NULL;
+
+ g_free (self->branding_sets);
+ self->branding_sets = NULL;
+
+ g_free (self->event_sets_uids);
+ self->event_sets_uids = NULL;
+
+ g_free (self->event_sets);
+ self->event_sets = NULL;
+
+ g_free (self->award_sets_uids);
+ self->award_sets_uids = NULL;
+
+ g_free (self->award_sets);
+ self->award_sets = NULL;
+
+ g_free (self->setting_period_sets_uids);
+ self->setting_period_sets_uids = NULL;
+
+ g_free (self->setting_period_sets);
+ self->setting_period_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_production_framework_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_production_framework_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1ProductionFramework *self = MXF_DMS1_PRODUCTION_FRAMEWORK (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->identification_sets =
+ g_new0 (MXFDMS1Identification *, self->n_identification_sets);
+ self->group_relationship_sets =
+ g_new0 (MXFDMS1GroupRelationship *, self->n_group_relationship_sets);
+ self->branding_sets = g_new0 (MXFDMS1Branding *, self->n_branding_sets);
+ self->event_sets = g_new0 (MXFDMS1Event *, self->n_event_sets);
+ self->award_sets = g_new0 (MXFDMS1Award *, self->n_award_sets);
+ self->setting_period_sets =
+ g_new0 (MXFDMS1SettingPeriod *, self->n_setting_period_sets);
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_IDENTIFICATION (current)) {
+ for (i = 0; i < self->n_identification_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->identification_sets_uids[i])) {
+ self->identification_sets[i] = MXF_DMS1_IDENTIFICATION (current);
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_GROUP_RELATIONSHIP (current)) {
+ for (i = 0; i < self->n_group_relationship_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->group_relationship_sets_uids[i])) {
+ self->group_relationship_sets[i] =
+ MXF_DMS1_GROUP_RELATIONSHIP (current);
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_BRANDING (current)) {
+ for (i = 0; i < self->n_branding_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->branding_sets_uids[i])) {
+ self->branding_sets[i] = MXF_DMS1_BRANDING (current);
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_EVENT (current)) {
+ for (i = 0; i < self->n_event_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->event_sets_uids[i])) {
+ self->event_sets[i] = MXF_DMS1_EVENT (current);
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_AWARD (current)) {
+ for (i = 0; i < self->n_award_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->award_sets_uids[i])) {
+ self->award_sets[i] = MXF_DMS1_AWARD (current);
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_SETTING_PERIOD (current)) {
+ for (i = 0; i < self->n_setting_period_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->setting_period_sets_uids[i])) {
+ self->setting_period_sets[i] = MXF_DMS1_SETTING_PERIOD (current);
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_production_framework_parent_class)->resolve (m, metadata);
+}
+
+static gboolean
+mxf_dms1_production_framework_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1ProductionFramework *self = MXF_DMS1_PRODUCTION_FRAMEWORK (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 integration_indication_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x05,
+ 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 identification_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x06, 0x00
+ };
+ static const guint8 group_relationship_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x05, 0x00
+ };
+ static const guint8 branding_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x08, 0x00
+ };
+ static const guint8 event_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x09, 0x00
+ };
+ static const guint8 award_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0b, 0x00
+ };
+ static const guint8 setting_period_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0e, 0x01
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &integration_indication_ul, 16) == 0) {
+ self->integration_indication = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" integration indication = %s",
+ GST_STR_NULL (self->integration_indication));
+ } else if (memcmp (tag_ul, &identification_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of identification sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_identification_sets = len;
+ self->identification_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->identification_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" identification sets %u = %s", i,
+ mxf_ul_to_string (&self->identification_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &group_relationship_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of group relationship sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_group_relationship_sets = len;
+ self->group_relationship_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->group_relationship_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" group relationship sets %u = %s", i,
+ mxf_ul_to_string (&self->group_relationship_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &branding_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of branding sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_branding_sets = len;
+ self->branding_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->branding_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" branding sets %u = %s", i,
+ mxf_ul_to_string (&self->branding_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &event_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of event sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_event_sets = len;
+ self->event_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->event_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" event sets %u = %s", i,
+ mxf_ul_to_string (&self->event_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &award_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of award sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_award_sets = len;
+ self->award_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->award_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" award sets %u = %s", i,
+ mxf_ul_to_string (&self->award_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &setting_period_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of setting period sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_setting_period_sets = len;
+ self->setting_period_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->setting_period_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" setting period sets %u = %s", i,
+ mxf_ul_to_string (&self->setting_period_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_production_framework_parent_class)->handle_tag (metadata,
+ primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 production framework local tag 0x%04x of size %u",
+ tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_production_framework_init (MXFDMS1ProductionFramework * self)
+{
+}
+
+static void
+mxf_dms1_production_framework_class_init (MXFDMS1ProductionFrameworkClass *
+ klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_production_framework_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_production_framework_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_production_framework_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1ClipFramework, mxf_dms1_clip_framework,
+ MXF_TYPE_DMS1_PRODUCTION_CLIP_FRAMEWORK);
+
+static void
+mxf_dms1_clip_framework_finalize (GstMiniObject * object)
+{
+ MXFDMS1ClipFramework *self = MXF_DMS1_CLIP_FRAMEWORK (object);
+
+ g_free (self->clip_kind);
+ self->clip_kind = NULL;
+
+ g_free (self->slate_information);
+ self->slate_information = NULL;
+
+ g_free (self->scripting_sets_uids);
+ self->scripting_sets_uids = NULL;
+
+ g_free (self->scripting_sets);
+ self->scripting_sets = NULL;
+
+ g_free (self->shot_sets_uids);
+ self->shot_sets_uids = NULL;
+
+ g_free (self->shot_sets);
+ self->shot_sets = NULL;
+
+ g_free (self->device_parameters_sets_uids);
+ self->device_parameters_sets_uids = NULL;
+
+ g_free (self->device_parameters_sets);
+ self->device_parameters_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_clip_framework_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_clip_framework_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1ClipFramework *self = MXF_DMS1_CLIP_FRAMEWORK (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->scripting_sets = g_new0 (MXFDMS1Scripting *, self->n_scripting_sets);
+ self->shot_sets = g_new0 (MXFDMS1Shot *, self->n_shot_sets);
+ self->device_parameters_sets =
+ g_new0 (MXFDMS1DeviceParameters *, self->n_device_parameters_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_SCRIPTING (current)) {
+ for (i = 0; i < self->n_scripting_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->scripting_sets_uids[i])) {
+ self->scripting_sets[i] = MXF_DMS1_SCRIPTING (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_SHOT (current)) {
+ for (i = 0; i < self->n_shot_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->shot_sets_uids[i])) {
+ self->shot_sets[i] = MXF_DMS1_SHOT (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_DEVICE_PARAMETERS (current)) {
+ for (i = 0; i < self->n_device_parameters_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->device_parameters_sets_uids[i])) {
+ self->device_parameters_sets[i] =
+ MXF_DMS1_DEVICE_PARAMETERS (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_PROCESSING (current)) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->processing_set_uid)) {
+ self->processing_set = MXF_DMS1_PROCESSING (current);
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS (mxf_dms1_clip_framework_parent_class)->resolve
+ (m, metadata);
+}
+
+static gboolean
+mxf_dms1_clip_framework_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1ClipFramework *self = MXF_DMS1_CLIP_FRAMEWORK (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[96];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 clip_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x05, 0x04, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 clip_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x05, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 extended_clip_id_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x01,
+ 0x01, 0x15, 0x09, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 clip_creation_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07,
+ 0x02, 0x01, 0x10, 0x01, 0x04, 0x00, 0x00
+ };
+ static const guint8 take_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x05, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 slate_information_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x05, 0x03, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 scripting_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0f, 0x00
+ };
+ static const guint8 shot_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x11, 0x02
+ };
+ static const guint8 device_parameters_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x1e, 0x00
+ };
+ static const guint8 processing_set_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x02, 0x40, 0x20, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &clip_kind_ul, 16) == 0) {
+ self->clip_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" clip kind = %s", GST_STR_NULL (self->clip_kind));
+ } else if (memcmp (tag_ul, &clip_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->clip_number, tag_data, tag_size);
+ GST_DEBUG (" clip number = %s", self->clip_number);
+ } else if (memcmp (tag_ul, &extended_clip_id_ul, 16) == 0) {
+ if (tag_size != 32 && tag_size != 64)
+ goto error;
+
+ memcpy (self->extended_clip_id, tag_data, tag_size);
+ self->extended_clip_id_full = (tag_size == 64);
+
+ GST_DEBUG (" extended clip id (1) = %s",
+ mxf_umid_to_string ((MXFUMID *) & self->extended_clip_id, str));
+ if (tag_size == 64)
+ GST_DEBUG (" extended clip id (2) = %s",
+ mxf_umid_to_string ((MXFUMID *) & self->extended_clip_id[32], str));
+ } else if (memcmp (tag_ul, &clip_creation_date_and_time_ul, 16) == 0) {
+ if (!mxf_timestamp_parse (&self->clip_creation_date_and_time, tag_data,
+ tag_size))
+ goto error;
+ GST_DEBUG (" clip creation date and time = %d/%u/%u %u:%u:%u.%u",
+ self->clip_creation_date_and_time.year,
+ self->clip_creation_date_and_time.month,
+ self->clip_creation_date_and_time.day,
+ self->clip_creation_date_and_time.hour,
+ self->clip_creation_date_and_time.minute,
+ self->clip_creation_date_and_time.second,
+ (self->clip_creation_date_and_time.quarter_msecond * 1000) / 256);
+ } else if (memcmp (tag_ul, &take_number_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->take_number = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" take number = %u", self->take_number);
+ } else if (memcmp (tag_ul, &slate_information_ul, 16) == 0) {
+ self->slate_information = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" slate information = %s",
+ GST_STR_NULL (self->slate_information));
+ } else if (memcmp (tag_ul, &scripting_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of scripting sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_scripting_sets = len;
+ self->scripting_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->scripting_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" scripting sets %u = %s", i,
+ mxf_ul_to_string (&self->scripting_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &shot_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of shot sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_shot_sets = len;
+ self->shot_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->shot_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" shot sets %u = %s", i,
+ mxf_ul_to_string (&self->shot_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &device_parameters_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of device parameters sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_device_parameters_sets = len;
+ self->device_parameters_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->device_parameters_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" device parameters sets %u = %s", i,
+ mxf_ul_to_string (&self->device_parameters_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &processing_set_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->processing_set_uid, tag_data, 16);
+ GST_DEBUG (" processing set = %s",
+ mxf_ul_to_string (&self->processing_set_uid, str));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_clip_framework_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 clip framework local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_clip_framework_init (MXFDMS1ClipFramework * self)
+{
+}
+
+static void
+mxf_dms1_clip_framework_class_init (MXFDMS1ClipFrameworkClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_clip_framework_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_clip_framework_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_clip_framework_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1SceneFramework, mxf_dms1_scene_framework,
+ MXF_TYPE_DMS1_FRAMEWORK);
+
+static void
+mxf_dms1_scene_framework_finalize (GstMiniObject * object)
+{
+ MXFDMS1SceneFramework *self = MXF_DMS1_SCENE_FRAMEWORK (object);
+
+ g_free (self->setting_period_sets_uids);
+ self->setting_period_sets_uids = NULL;
+
+ g_free (self->setting_period_sets);
+ self->setting_period_sets = NULL;
+
+ g_free (self->shot_scene_sets_uids);
+ self->shot_scene_sets_uids = NULL;
+
+ g_free (self->shot_scene_sets);
+ self->shot_scene_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_scene_framework_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_scene_framework_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1SceneFramework *self = MXF_DMS1_SCENE_FRAMEWORK (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->setting_period_sets =
+ g_new0 (MXFDMS1SettingPeriod *, self->n_setting_period_sets);
+ self->shot_scene_sets = g_new0 (MXFDMS1Shot *, self->n_shot_scene_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_SETTING_PERIOD (current)) {
+ for (i = 0; i < self->n_setting_period_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->setting_period_sets_uids[i])) {
+ self->setting_period_sets[i] = MXF_DMS1_SETTING_PERIOD (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_SHOT (current)) {
+ for (i = 0; i < self->n_shot_scene_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->shot_scene_sets_uids[i])) {
+ self->shot_scene_sets[i] = MXF_DMS1_SHOT (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS (mxf_dms1_scene_framework_parent_class)->resolve
+ (m, metadata);
+}
+
+static gboolean
+mxf_dms1_scene_framework_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1SceneFramework *self = MXF_DMS1_SCENE_FRAMEWORK (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 scene_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 setting_period_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0e, 0x02
+ };
+ static const guint8 shot_scene_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x11, 0x01
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &scene_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->scene_number, tag_data, tag_size);
+ GST_DEBUG (" scene number = %s", self->scene_number);
+ } else if (memcmp (tag_ul, &setting_period_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of setting period sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_setting_period_sets = len;
+ self->setting_period_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->setting_period_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" setting period sets %u = %s", i,
+ mxf_ul_to_string (&self->setting_period_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &shot_scene_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of shot sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_shot_scene_sets = len;
+ self->shot_scene_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->shot_scene_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" shot sets %u = %s", i,
+ mxf_ul_to_string (&self->shot_scene_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_scene_framework_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 scene framework local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_scene_framework_init (MXFDMS1SceneFramework * self)
+{
+}
+
+static void
+mxf_dms1_scene_framework_class_init (MXFDMS1SceneFrameworkClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_scene_framework_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_scene_framework_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_scene_framework_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Titles, mxf_dms1_titles, MXF_TYPE_DMS1_TEXT_LANGUAGE);
+
+static void
+mxf_dms1_titles_finalize (GstMiniObject * object)
+{
+ MXFDMS1Titles *self = MXF_DMS1_TITLES (object);
+
+ g_free (self->main_title);
+ self->main_title = NULL;
+
+ g_free (self->secondary_title);
+ self->secondary_title = NULL;
+
+ g_free (self->working_title);
+ self->working_title = NULL;
+
+ g_free (self->original_title);
+ self->original_title = NULL;
+
+ g_free (self->version_title);
+ self->version_title = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_titles_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_titles_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Titles *self = MXF_DMS1_TITLES (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 main_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x01,
+ 0x05, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 secondary_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x01,
+ 0x05, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 working_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x05, 0x0a, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 original_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x05, 0x0b, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 version_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x01,
+ 0x05, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &main_title_ul, 16) == 0) {
+ self->main_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" main title = %s", GST_STR_NULL (self->main_title));
+ } else if (memcmp (tag_ul, &secondary_title_ul, 16) == 0) {
+ self->secondary_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" secondary title = %s", GST_STR_NULL (self->secondary_title));
+ } else if (memcmp (tag_ul, &working_title_ul, 16) == 0) {
+ self->working_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" working title = %s", GST_STR_NULL (self->working_title));
+ } else if (memcmp (tag_ul, &original_title_ul, 16) == 0) {
+ self->original_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" original title = %s", GST_STR_NULL (self->original_title));
+ } else if (memcmp (tag_ul, &version_title_ul, 16) == 0) {
+ self->version_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" version title = %s", GST_STR_NULL (self->version_title));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_titles_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_titles_init (MXFDMS1Titles * self)
+{
+}
+
+static void
+mxf_dms1_titles_class_init (MXFDMS1TitlesClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_titles_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_titles_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Identification, mxf_dms1_identification,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_identification_finalize (GstMiniObject * object)
+{
+ MXFDMS1Identification *self = MXF_DMS1_IDENTIFICATION (object);
+
+ g_free (self->identifier_value);
+ self->identifier_value = NULL;
+
+ g_free (self->identification_issuing_authority);
+ self->identification_issuing_authority = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_identification_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_identification_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Identification *self = MXF_DMS1_IDENTIFICATION (metadata);
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 identifier_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 identifier_value_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 identification_locator_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 identification_issuing_authority_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x0a, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &identifier_kind_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->identifier_kind, tag_data, tag_size);
+ GST_DEBUG (" identifier kind = %s", self->identifier_kind);
+ } else if (memcmp (tag_ul, &identifier_value_ul, 16) == 0) {
+ self->identifier_value = g_memdup (tag_data, tag_size);
+ self->identifier_value_length = tag_size;
+ GST_DEBUG (" identifier value length = %u", tag_size);
+ } else if (memcmp (tag_ul, &identification_locator_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->identification_locator, tag_data, 16);
+
+ GST_DEBUG (" identification locator = %s",
+ mxf_ul_to_string (&self->identification_locator, str));
+ } else if (memcmp (tag_ul, &identification_issuing_authority_ul, 16) == 0) {
+ self->identification_issuing_authority =
+ mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" identification issuing authority = %s",
+ GST_STR_NULL (self->identification_issuing_authority));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_identification_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 identification local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_identification_init (MXFDMS1Identification * self)
+{
+}
+
+static void
+mxf_dms1_identification_class_init (MXFDMS1IdentificationClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_identification_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_identification_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1GroupRelationship, mxf_dms1_group_relationship,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_group_relationship_finalize (GstMiniObject * object)
+{
+ MXFDMS1GroupRelationship *self = MXF_DMS1_GROUP_RELATIONSHIP (object);
+
+ g_free (self->programming_group_kind);
+ self->programming_group_kind = NULL;
+
+ g_free (self->programming_group_title);
+ self->programming_group_title = NULL;
+
+ g_free (self->group_synopsis);
+ self->group_synopsis = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_group_relationship_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_group_relationship_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1GroupRelationship *self = MXF_DMS1_GROUP_RELATIONSHIP (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 programming_group_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x02, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 programming_group_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x02, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 group_synopsis_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x08, 0x01, 0x00, 0x00
+ };
+ static const guint8 numerical_position_in_sequence_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x06,
+ 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 total_number_in_the_sequence_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 episodic_start_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 episodic_end_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x02, 0x05, 0x02, 0x03, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &programming_group_kind_ul, 16) == 0) {
+ self->programming_group_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" programming group kind = %s",
+ GST_STR_NULL (self->programming_group_kind));
+ } else if (memcmp (tag_ul, &programming_group_title_ul, 16) == 0) {
+ self->programming_group_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" programming group title = %s",
+ GST_STR_NULL (self->programming_group_title));
+ } else if (memcmp (tag_ul, &group_synopsis_ul, 16) == 0) {
+ self->group_synopsis = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" group synopsis = %s", GST_STR_NULL (self->group_synopsis));
+ } else if (memcmp (tag_ul, &numerical_position_in_sequence_ul, 16) == 0) {
+ if (tag_size != 4)
+ goto error;
+
+ self->numerical_position_in_sequence = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" numerical position in sequence = %u",
+ self->numerical_position_in_sequence);
+ } else if (memcmp (tag_ul, &total_number_in_the_sequence_ul, 16) == 0) {
+ if (tag_size != 4)
+ goto error;
+
+ self->total_number_in_the_sequence = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" total number in the sequence = %u",
+ self->total_number_in_the_sequence);
+ } else if (memcmp (tag_ul, &episodic_start_number_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->episodic_start_number = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" episodic start number = %u", self->episodic_start_number);
+ } else if (memcmp (tag_ul, &episodic_end_number_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->episodic_end_number = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" episodic end number = %u", self->episodic_end_number);
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_group_relationship_parent_class)->handle_tag (metadata,
+ primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 group relationship local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_group_relationship_init (MXFDMS1GroupRelationship * self)
+{
+}
+
+static void
+mxf_dms1_group_relationship_class_init (MXFDMS1GroupRelationshipClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_group_relationship_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_group_relationship_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Branding, mxf_dms1_branding, MXF_TYPE_DMS1_TEXT_LANGUAGE);
+
+static void
+mxf_dms1_branding_finalize (GstMiniObject * object)
+{
+ MXFDMS1Branding *self = MXF_DMS1_BRANDING (object);
+
+ g_free (self->brand_main_title);
+ self->brand_main_title = NULL;
+
+ g_free (self->brand_original_title);
+ self->brand_original_title = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_branding_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_branding_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Branding *self = MXF_DMS1_BRANDING (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 brand_main_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x05, 0x0D, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 brand_original_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x05, 0x0E, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &brand_main_title_ul, 16) == 0) {
+ self->brand_main_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" brand main title = %s",
+ GST_STR_NULL (self->brand_main_title));
+ } else if (memcmp (tag_ul, &brand_original_title_ul, 16) == 0) {
+ self->brand_original_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" brand original title = %s",
+ GST_STR_NULL (self->brand_original_title));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_branding_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_branding_init (MXFDMS1Branding * self)
+{
+}
+
+static void
+mxf_dms1_branding_class_init (MXFDMS1BrandingClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_branding_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_branding_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Event, mxf_dms1_event, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_event_finalize (GstMiniObject * object)
+{
+ MXFDMS1Event *self = MXF_DMS1_EVENT (object);
+
+ g_free (self->event_indication);
+ self->event_indication = NULL;
+
+ g_free (self->publication_sets_uids);
+ self->publication_sets_uids = NULL;
+
+ g_free (self->publication_sets);
+ self->publication_sets = NULL;
+
+ g_free (self->annotation_sets_uids);
+ self->annotation_sets_uids = NULL;
+
+ g_free (self->annotation_sets);
+ self->annotation_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_event_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_event_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Event *self = MXF_DMS1_EVENT (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->publication_sets =
+ g_new0 (MXFDMS1Publication *, self->n_publication_sets);
+ self->annotation_sets = g_new0 (MXFDMS1Annotation *, self->n_annotation_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_PUBLICATION (current)) {
+ for (i = 0; i < self->n_publication_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->publication_sets_uids[i])) {
+ self->publication_sets[i] = MXF_DMS1_PUBLICATION (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_ANNOTATION (current)) {
+ for (i = 0; i < self->n_annotation_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->annotation_sets_uids[i])) {
+ self->annotation_sets[i] = MXF_DMS1_ANNOTATION (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_event_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_event_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Event *self = MXF_DMS1_EVENT (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 event_indication_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x05,
+ 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 event_start_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07,
+ 0x02, 0x01, 0x02, 0x07, 0x02, 0x00, 0x00
+ };
+ static const guint8 event_end_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07,
+ 0x02, 0x01, 0x02, 0x09, 0x02, 0x00, 0x00
+ };
+ static const guint8 publication_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0a, 0x00
+ };
+ static const guint8 annotation_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x08, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x0d, 0x01
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &event_indication_ul, 16) == 0) {
+ self->event_indication = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" event indication = %s",
+ GST_STR_NULL (self->event_indication));
+ } else if (memcmp (tag_ul, &event_start_date_and_time_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->event_start_date_and_time, tag_data, tag_size);
+ GST_DEBUG (" event start date and time = %s",
+ self->event_start_date_and_time);
+ } else if (memcmp (tag_ul, &event_end_date_and_time_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->event_end_date_and_time, tag_data, tag_size);
+ GST_DEBUG (" event end date and time = %s", self->event_end_date_and_time);
+ } else if (memcmp (tag_ul, &publication_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of publication sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_publication_sets = len;
+ self->publication_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->publication_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" publication sets %u = %s", i,
+ mxf_ul_to_string (&self->publication_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &annotation_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of annotation sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_annotation_sets = len;
+ self->annotation_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->annotation_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" annotation sets %u = %s", i,
+ mxf_ul_to_string (&self->annotation_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_event_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 event local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_event_init (MXFDMS1Event * self)
+{
+}
+
+static void
+mxf_dms1_event_class_init (MXFDMS1EventClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_event_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_event_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_event_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Publication, mxf_dms1_publication, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_publication_finalize (GstMiniObject * object)
+{
+ MXFDMS1Publication *self = MXF_DMS1_PUBLICATION (object);
+
+ g_free (self->publication_organisation_name);
+ self->publication_organisation_name = NULL;
+
+ g_free (self->publication_service_name);
+ self->publication_service_name = NULL;
+
+ g_free (self->publication_medium);
+ self->publication_medium = NULL;
+
+ g_free (self->publication_region);
+ self->publication_region = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_publication_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_publication_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Publication *self = MXF_DMS1_PUBLICATION (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 publication_organisation_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x10, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00
+ };
+ static const guint8 publication_service_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x10, 0x02, 0x01, 0x02, 0x01, 0x00, 0x00
+ };
+ static const guint8 publication_medium_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x10, 0x02, 0x01, 0x03, 0x01, 0x00, 0x00
+ };
+ static const guint8 publication_region_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x10, 0x02, 0x01, 0x04, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &publication_organisation_name_ul, 16) == 0) {
+ self->publication_organisation_name =
+ mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" publication organisation name = %s",
+ GST_STR_NULL (self->publication_organisation_name));
+ } else if (memcmp (tag_ul, &publication_service_name_ul, 16) == 0) {
+ self->publication_service_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" publication service name = %s",
+ GST_STR_NULL (self->publication_service_name));
+ } else if (memcmp (tag_ul, &publication_medium_ul, 16) == 0) {
+ self->publication_medium = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" publication medium = %s",
+ GST_STR_NULL (self->publication_medium));
+ } else if (memcmp (tag_ul, &publication_region_ul, 16) == 0) {
+ self->publication_region = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" publication region = %s",
+ GST_STR_NULL (self->publication_region));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_publication_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_publication_init (MXFDMS1Publication * self)
+{
+}
+
+static void
+mxf_dms1_publication_class_init (MXFDMS1PublicationClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_publication_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_publication_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Award, mxf_dms1_award, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_award_finalize (GstMiniObject * object)
+{
+ MXFDMS1Award *self = MXF_DMS1_AWARD (object);
+
+ g_free (self->festival);
+ self->festival = NULL;
+
+ g_free (self->award_name);
+ self->award_name = NULL;
+
+ g_free (self->award_classification);
+ self->award_classification = NULL;
+
+ g_free (self->nomination_category);
+ self->nomination_category = NULL;
+
+ g_free (self->participant_sets_uids);
+ self->participant_sets_uids = NULL;
+
+ g_free (self->participant_sets);
+ self->participant_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_award_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_award_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Award *self = MXF_DMS1_AWARD (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->participant_sets =
+ g_new0 (MXFDMS1Participant *, self->n_participant_sets);
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_PARTICIPANT (current)) {
+ for (i = 0; i < self->n_participant_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->participant_sets_uids[i])) {
+ self->participant_sets[i] = MXF_DMS1_PARTICIPANT (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_award_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_award_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Award *self = MXF_DMS1_AWARD (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 festival_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x02, 0x01, 0x03, 0x01, 0x00, 0x00
+ };
+ static const guint8 festival_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x07,
+ 0x02, 0x01, 0x02, 0x07, 0x10, 0x01, 0x00
+ };
+ static const guint8 award_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x02, 0x01, 0x04, 0x01, 0x00, 0x00
+ };
+ static const guint8 award_classification_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x02, 0x01, 0x05, 0x01, 0x00, 0x00
+ };
+ static const guint8 nomination_category_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x02, 0x01, 0x06, 0x01, 0x00, 0x00
+ };
+ static const guint8 participant_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x13, 0x01
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &festival_ul, 16) == 0) {
+ self->festival = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" festival = %s", GST_STR_NULL (self->festival));
+ } else if (memcmp (tag_ul, &festival_date_and_time_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->festival_date_and_time, tag_data, tag_size);
+ GST_DEBUG (" festival date and time = %s",
+ GST_STR_NULL (self->festival_date_and_time));
+ } else if (memcmp (tag_ul, &award_name_ul, 16) == 0) {
+ self->award_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" award name = %s", GST_STR_NULL (self->award_name));
+ } else if (memcmp (tag_ul, &award_classification_ul, 16) == 0) {
+ self->award_classification = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" award classification = %s",
+ GST_STR_NULL (self->award_classification));
+ } else if (memcmp (tag_ul, &nomination_category_ul, 16) == 0) {
+ self->nomination_category = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" nomination category = %s",
+ GST_STR_NULL (self->nomination_category));
+ } else if (memcmp (tag_ul, &participant_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of participant sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_participant_sets = len;
+ self->participant_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->participant_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" participant sets %u = %s", i,
+ mxf_ul_to_string (&self->participant_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_award_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 award local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_award_init (MXFDMS1Award * self)
+{
+}
+
+static void
+mxf_dms1_award_class_init (MXFDMS1AwardClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_award_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_award_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_award_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1CaptionsDescription, mxf_dms1_captions_description,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_captions_description_finalize (GstMiniObject * object)
+{
+ MXFDMS1CaptionsDescription *self = MXF_DMS1_CAPTIONS_DESCRIPTION (object);
+
+ g_free (self->caption_kind);
+ self->caption_kind = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_captions_description_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_captions_description_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1CaptionsDescription *self = MXF_DMS1_CAPTIONS_DESCRIPTION (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 extended_captions_language_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x01, 0x01, 0x02, 0x02, 0x12, 0x00, 0x00
+ };
+ static const guint8 caption_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x04,
+ 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &extended_captions_language_code_ul, 16) == 0) {
+ if (tag_size > 12)
+ goto error;
+
+ memcpy (self->extended_captions_language_code, tag_data, tag_size);
+ GST_DEBUG (" extended captions language code = %s",
+ self->extended_captions_language_code);
+ } else if (memcmp (tag_ul, &caption_kind_ul, 16) == 0) {
+ self->caption_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" caption kind = %s", GST_STR_NULL (self->caption_kind));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_captions_description_parent_class)->handle_tag (metadata,
+ primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 captions description local tag 0x%04x of size %u",
+ tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_captions_description_init (MXFDMS1CaptionsDescription * self)
+{
+}
+
+static void
+mxf_dms1_captions_description_class_init (MXFDMS1CaptionsDescriptionClass *
+ klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_captions_description_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_captions_description_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Annotation, mxf_dms1_annotation, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_annotation_finalize (GstMiniObject * object)
+{
+ MXFDMS1Annotation *self = MXF_DMS1_ANNOTATION (object);
+
+ g_free (self->annotation_kind);
+ self->annotation_kind = NULL;
+
+ g_free (self->annotation_synopsis);
+ self->annotation_synopsis = NULL;
+
+ g_free (self->annotation_description);
+ self->annotation_description = NULL;
+
+ g_free (self->related_material_description);
+ self->related_material_description = NULL;
+
+ g_free (self->classification_sets_uids);
+ self->classification_sets_uids = NULL;
+
+ g_free (self->classification_sets);
+ self->classification_sets = NULL;
+
+ g_free (self->related_material_locators);
+ self->related_material_locators = NULL;
+
+ g_free (self->participant_sets_uids);
+ self->participant_sets_uids = NULL;
+
+ g_free (self->participant_sets);
+ self->participant_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_annotation_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_annotation_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Annotation *self = MXF_DMS1_ANNOTATION (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->classification_sets =
+ g_new0 (MXFDMS1Classification *, self->n_classification_sets);
+ self->participant_sets =
+ g_new0 (MXFDMS1Participant *, self->n_participant_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_CLASSIFICATION (current)) {
+ for (i = 0; i < self->n_classification_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->classification_sets_uids[i])) {
+ self->classification_sets[i] = MXF_DMS1_CLASSIFICATION (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_CUE_WORDS (current)) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->cue_words_set_uid)) {
+ self->cue_words_set = MXF_DMS1_CUE_WORDS (current);
+ }
+ }
+
+ if (MXF_IS_DMS1_PARTICIPANT (current)) {
+ for (i = 0; i < self->n_participant_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->participant_sets_uids[i])) {
+ self->participant_sets[i] = MXF_DMS1_PARTICIPANT (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_annotation_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_annotation_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Annotation *self = MXF_DMS1_ANNOTATION (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 annotation_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x0e, 0x01, 0x00, 0x00
+ };
+ static const guint8 annotation_synopsis_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x09, 0x01, 0x00, 0x00
+ };
+ static const guint8 annotation_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x0a, 0x01, 0x00, 0x00
+ };
+ static const guint8 related_material_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x0f, 0x01, 0x00, 0x00
+ };
+ static const guint8 classification_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x10, 0x00
+ };
+ static const guint8 cue_words_set_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x02, 0x40, 0x23, 0x01
+ };
+ static const guint8 related_material_locators_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x06, 0x0d, 0x00, 0x00
+ };
+ static const guint8 participant_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x13, 0x03
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &annotation_kind_ul, 16) == 0) {
+ self->annotation_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" annotation kind = %s", GST_STR_NULL (self->annotation_kind));
+ } else if (memcmp (tag_ul, &annotation_synopsis_ul, 16) == 0) {
+ self->annotation_synopsis = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" annotation synopsis = %s",
+ GST_STR_NULL (self->annotation_synopsis));
+ } else if (memcmp (tag_ul, &annotation_description_ul, 16) == 0) {
+ self->annotation_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" annotation description = %s",
+ GST_STR_NULL (self->annotation_description));
+ } else if (memcmp (tag_ul, &related_material_description_ul, 16) == 0) {
+ self->related_material_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" related material description = %s",
+ GST_STR_NULL (self->related_material_description));
+ } else if (memcmp (tag_ul, &classification_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of classification sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_classification_sets = len;
+ self->classification_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->classification_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" classification sets %u = %s", i,
+ mxf_ul_to_string (&self->classification_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &cue_words_set_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->cue_words_set_uid, tag_data, 16);
+ GST_DEBUG (" cue words set = %s",
+ mxf_ul_to_string (&self->cue_words_set_uid, str));
+ } else if (memcmp (tag_ul, &related_material_locators_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of related material locators = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_related_material_locators = len;
+ self->related_material_locators = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->related_material_locators[i], tag_data, 16);
+ GST_DEBUG (" related material locators %u = %s", i,
+ mxf_ul_to_string (&self->related_material_locators[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &participant_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of participant sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_participant_sets = len;
+ self->participant_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->participant_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" participant sets %u = %s", i,
+ mxf_ul_to_string (&self->participant_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_annotation_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 annotation local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_annotation_init (MXFDMS1Annotation * self)
+{
+}
+
+static void
+mxf_dms1_annotation_class_init (MXFDMS1AnnotationClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_annotation_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_annotation_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_annotation_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1SettingPeriod, mxf_dms1_setting_period,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_setting_period_finalize (GstMiniObject * object)
+{
+ MXFDMS1SettingPeriod *self = MXF_DMS1_SETTING_PERIOD (object);
+
+ g_free (self->time_period_keyword);
+ self->time_period_keyword = NULL;
+
+ g_free (self->setting_period_description);
+ self->setting_period_description = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_setting_period_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_setting_period_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1SettingPeriod *self = MXF_DMS1_SETTING_PERIOD (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 setting_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x02, 0x01, 0x08, 0x02, 0x00, 0x00, 0x00
+ };
+ static const guint8 time_period_keyword_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x02, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00
+ };
+ static const guint8 setting_period_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x02, 0x01, 0x08, 0x03, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &setting_date_and_time_ul, 16) == 0) {
+ if (!mxf_timestamp_parse (&self->setting_date_and_time, tag_data, tag_size))
+ goto error;
+
+ GST_DEBUG (" last modified date = %d/%u/%u %u:%u:%u.%u",
+ self->setting_date_and_time.year, self->setting_date_and_time.month,
+ self->setting_date_and_time.day, self->setting_date_and_time.hour,
+ self->setting_date_and_time.minute,
+ self->setting_date_and_time.second,
+ (self->setting_date_and_time.quarter_msecond * 1000) / 256);
+ } else if (memcmp (tag_ul, &time_period_keyword_ul, 16) == 0) {
+ self->time_period_keyword = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" time period keyword = %s",
+ GST_STR_NULL (self->time_period_keyword));
+ } else if (memcmp (tag_ul, &setting_period_description_ul, 16) == 0) {
+ self->setting_period_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" setting period description = %s",
+ GST_STR_NULL (self->setting_period_description));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_setting_period_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 setting period local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_setting_period_init (MXFDMS1SettingPeriod * self)
+{
+}
+
+static void
+mxf_dms1_setting_period_class_init (MXFDMS1SettingPeriodClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_setting_period_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_setting_period_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Scripting, mxf_dms1_scripting, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_scripting_finalize (GstMiniObject * object)
+{
+ MXFDMS1Scripting *self = MXF_DMS1_SCRIPTING (object);
+
+ g_free (self->scripting_kind);
+ self->scripting_kind = NULL;
+
+ g_free (self->scripting_text);
+ self->scripting_text = NULL;
+
+ g_free (self->scripting_locators);
+ self->scripting_locators = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_scripting_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_scripting_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Scripting *self = MXF_DMS1_SCRIPTING (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 scripting_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x0b, 0x01, 0x00, 0x00
+ };
+ static const guint8 scripting_text_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x0c, 0x01, 0x00, 0x00
+ };
+ static const guint8 scripting_locators_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x08, 0x06,
+ 0x01, 0x01, 0x04, 0x06, 0x0e, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &scripting_kind_ul, 16) == 0) {
+ self->scripting_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" scripting kind = %s", GST_STR_NULL (self->scripting_kind));
+ } else if (memcmp (tag_ul, &scripting_text_ul, 16) == 0) {
+ self->scripting_text = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" scripting description = %s",
+ GST_STR_NULL (self->scripting_text));
+ } else if (memcmp (tag_ul, &scripting_locators_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of scripting locators = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_scripting_locators = len;
+ self->scripting_locators = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->scripting_locators[i], tag_data, 16);
+ GST_DEBUG (" scripting locators %u = %s", i,
+ mxf_ul_to_string (&self->scripting_locators[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_scripting_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 scripting local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_scripting_init (MXFDMS1Scripting * self)
+{
+}
+
+static void
+mxf_dms1_scripting_class_init (MXFDMS1ScriptingClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_scripting_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_scripting_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Classification, mxf_dms1_classification,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_classification_finalize (GstMiniObject * object)
+{
+ MXFDMS1Classification *self = MXF_DMS1_CLASSIFICATION (object);
+
+ g_free (self->name_value_sets_uids);
+ self->name_value_sets_uids = NULL;
+
+ g_free (self->name_value_sets);
+ self->name_value_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_classification_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_classification_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1Classification *self = MXF_DMS1_CLASSIFICATION (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->name_value_sets = g_new0 (MXFDMS1NameValue *, self->n_name_value_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_NAME_VALUE (current)) {
+ for (i = 0; i < self->n_name_value_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->name_value_sets_uids[i])) {
+ self->name_value_sets[i] = MXF_DMS1_NAME_VALUE (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS (mxf_dms1_classification_parent_class)->resolve
+ (m, metadata);
+}
+
+static gboolean
+mxf_dms1_classification_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Classification *self = MXF_DMS1_CLASSIFICATION (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 content_classification_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x03,
+ 0x02, 0x01, 0x03, 0x04, 0x00, 0x00, 0x00
+ };
+ static const guint8 name_value_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x1f, 0x01
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &content_classification_ul, 16) == 0) {
+ if (tag_size > 127)
+ goto error;
+
+ memcpy (self->content_classification, tag_data, tag_size);
+ GST_DEBUG (" content classification = %s", self->content_classification);
+ } else if (memcmp (tag_ul, &name_value_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of name-value sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_name_value_sets = len;
+ self->name_value_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->name_value_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" name-value sets %u = %s", i,
+ mxf_ul_to_string (&self->name_value_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_classification_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 classification local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_classification_init (MXFDMS1Classification * self)
+{
+}
+
+static void
+mxf_dms1_classification_class_init (MXFDMS1ClassificationClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_classification_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_classification_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_classification_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Shot, mxf_dms1_shot, MXF_TYPE_DMS1_TEXT_LANGUAGE);
+
+static void
+mxf_dms1_shot_finalize (GstMiniObject * object)
+{
+ MXFDMS1Shot *self = MXF_DMS1_SHOT (object);
+
+ g_free (self->shot_track_ids);
+ self->shot_track_ids = NULL;
+
+ g_free (self->shot_description);
+ self->shot_description = NULL;
+
+ g_free (self->shot_comment_kind);
+ self->shot_comment_kind = NULL;
+
+ g_free (self->shot_comment);
+ self->shot_comment = NULL;
+
+ g_free (self->key_point_sets_uids);
+ self->key_point_sets_uids = NULL;
+
+ g_free (self->key_point_sets);
+ self->key_point_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_shot_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_shot_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Shot *self = MXF_DMS1_SHOT (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->key_point_sets = g_new0 (MXFDMS1KeyPoint *, self->n_key_point_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_CUE_WORDS (current)) {
+ if (mxf_ul_is_equal (&current->instance_uid, &self->cue_words_set_uid)) {
+ self->cue_words_set = MXF_DMS1_CUE_WORDS (current);
+ }
+ }
+
+ if (MXF_IS_DMS1_KEY_POINT (current)) {
+ for (i = 0; i < self->n_key_point_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->key_point_sets_uids[i])) {
+ self->key_point_sets[i] = MXF_DMS1_KEY_POINT (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_shot_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_shot_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Shot *self = MXF_DMS1_SHOT (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 shot_start_position_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x07,
+ 0x02, 0x01, 0x03, 0x01, 0x09, 0x00, 0x00
+ };
+ static const guint8 shot_duration_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x07,
+ 0x02, 0x02, 0x01, 0x02, 0x04, 0x00, 0x00
+ };
+ static const guint8 shot_track_ids_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x07, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 shot_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x02, 0x01, 0x06, 0x0d, 0x01, 0x00, 0x00
+ };
+ static const guint8 shot_comment_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x02, 0x05, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 shot_comment_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x03,
+ 0x02, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 cue_words_set_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x02, 0x40, 0x23, 0x01
+ };
+ static const guint8 key_point_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x12, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &shot_start_position_ul, 16) == 0) {
+ if (tag_size != 8)
+ goto error;
+
+ self->shot_start_position = GST_READ_UINT64_BE (tag_data);
+ GST_DEBUG (" shot start position = %" G_GINT64_FORMAT,
+ self->shot_start_position);
+ } else if (memcmp (tag_ul, &shot_duration_ul, 16) == 0) {
+ if (tag_size != 8)
+ goto error;
+
+ self->shot_duration = GST_READ_UINT64_BE (tag_data);
+ GST_DEBUG (" shot duration = %" G_GINT64_FORMAT, self->shot_duration);
+ } else if (memcmp (tag_ul, &shot_track_ids_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of shot track ids = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 4)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 4 * len)
+ goto error;
+
+ self->n_shot_track_ids = len;
+ self->shot_track_ids = g_new0 (guint32, len);
+
+ for (i = 0; i < len; i++) {
+ self->shot_track_ids[i] = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" shot track ids %u = %u", i, self->shot_track_ids[i]);
+ tag_data += 4;
+ tag_size -= 4;
+ }
+ } else if (memcmp (tag_ul, &shot_description_ul, 16) == 0) {
+ self->shot_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" shot description = %s",
+ GST_STR_NULL (self->shot_description));
+ } else if (memcmp (tag_ul, &shot_comment_kind_ul, 16) == 0) {
+ self->shot_comment_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" shot comment kind = %s",
+ GST_STR_NULL (self->shot_comment_kind));
+ } else if (memcmp (tag_ul, &shot_comment_ul, 16) == 0) {
+ self->shot_comment = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" shot comment = %s", GST_STR_NULL (self->shot_comment));
+ } else if (memcmp (tag_ul, &cue_words_set_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->cue_words_set_uid, tag_data, 16);
+ GST_DEBUG (" cue words set = %s",
+ mxf_ul_to_string (&self->cue_words_set_uid, str));
+ } else if (memcmp (tag_ul, &key_point_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of key point sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_key_point_sets = len;
+ self->key_point_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->key_point_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" key point sets %u = %s", i,
+ mxf_ul_to_string (&self->key_point_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_shot_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 shot local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_shot_init (MXFDMS1Shot * self)
+{
+}
+
+static void
+mxf_dms1_shot_class_init (MXFDMS1ShotClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_shot_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_shot_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_shot_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1KeyPoint, mxf_dms1_key_point, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_key_point_finalize (GstMiniObject * object)
+{
+ MXFDMS1KeyPoint *self = MXF_DMS1_KEY_POINT (object);
+
+ g_free (self->keypoint_kind);
+ self->keypoint_kind = NULL;
+
+ g_free (self->keypoint_value);
+ self->keypoint_value = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_key_point_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_key_point_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1KeyPoint *self = MXF_DMS1_KEY_POINT (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 keypoint_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x01, 0x02, 0x10, 0x01, 0x00, 0x00
+ };
+ static const guint8 keypoint_value_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x01, 0x02, 0x11, 0x01, 0x00, 0x00
+ };
+ static const guint8 keypoint_position_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x02, 0x01, 0x03, 0x01, 0x07, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &keypoint_kind_ul, 16) == 0) {
+ self->keypoint_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" keypoint kind = %s", GST_STR_NULL (self->keypoint_kind));
+ } else if (memcmp (tag_ul, &keypoint_value_ul, 16) == 0) {
+ self->keypoint_value = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" keypoint value = %s", GST_STR_NULL (self->keypoint_value));
+ } else if (memcmp (tag_ul, &keypoint_position_ul, 16) == 0) {
+ if (tag_size != 8)
+ goto error;
+
+ self->keypoint_position = GST_READ_UINT64_BE (tag_data);
+ GST_DEBUG (" keypoint position = %" G_GINT64_FORMAT,
+ self->keypoint_position);
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_key_point_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 key point local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_key_point_init (MXFDMS1KeyPoint * self)
+{
+}
+
+static void
+mxf_dms1_key_point_class_init (MXFDMS1KeyPointClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_key_point_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_key_point_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Participant, mxf_dms1_participant,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_participant_finalize (GstMiniObject * object)
+{
+ MXFDMS1Participant *self = MXF_DMS1_PARTICIPANT (object);
+
+ g_free (self->contribution_status);
+ self->contribution_status = NULL;
+
+ g_free (self->job_function);
+ self->job_function = NULL;
+
+ g_free (self->role_or_identity_name);
+ self->role_or_identity_name = NULL;
+
+ g_free (self->person_sets_uids);
+ self->person_sets_uids = NULL;
+
+ g_free (self->person_sets);
+ self->person_sets = NULL;
+
+ g_free (self->organisation_sets_uids);
+ self->organisation_sets_uids = NULL;
+
+ g_free (self->organisation_sets);
+ self->organisation_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_participant_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_participant_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Participant *self = MXF_DMS1_PARTICIPANT (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->person_sets = g_new0 (MXFDMS1Person *, self->n_person_sets);
+ self->organisation_sets =
+ g_new0 (MXFDMS1Organisation *, self->n_organisation_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_PERSON (current)) {
+ for (i = 0; i < self->n_person_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->person_sets_uids[i])) {
+ self->person_sets[i] = MXF_DMS1_PERSON (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_ORGANISATION (current)) {
+ for (i = 0; i < self->n_organisation_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->organisation_sets_uids[i])) {
+ self->organisation_sets[i] = MXF_DMS1_ORGANISATION (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS (mxf_dms1_participant_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_participant_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Participant *self = MXF_DMS1_PARTICIPANT (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 participant_uid_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x08, 0x01,
+ 0x01, 0x15, 0x40, 0x01, 0x01, 0x00, 0x00
+ };
+ static const guint8 contribution_status_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00
+ };
+ static const guint8 job_function_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x05, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 job_function_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x05, 0x01, 0x02, 0x00, 0x00, 0x00
+ };
+ static const guint8 role_or_identity_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 person_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x14, 0x00
+ };
+ static const guint8 organisation_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x15, 0x02
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &participant_uid_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->participant_uid, tag_data, 16);
+ GST_DEBUG (" participant uid = %s",
+ mxf_ul_to_string (&self->participant_uid, str));
+ } else if (memcmp (tag_ul, &contribution_status_ul, 16) == 0) {
+ self->contribution_status = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" contribution status = %s",
+ GST_STR_NULL (self->contribution_status));
+ } else if (memcmp (tag_ul, &job_function_ul, 16) == 0) {
+ self->job_function = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" job function = %s", GST_STR_NULL (self->job_function));
+ } else if (memcmp (tag_ul, &job_function_code_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->job_function_code, tag_data, tag_size);
+ GST_DEBUG (" job function code = %s", self->job_function_code);
+ } else if (memcmp (tag_ul, &role_or_identity_name_ul, 16) == 0) {
+ self->role_or_identity_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" role or identity name = %s",
+ GST_STR_NULL (self->role_or_identity_name));
+ } else if (memcmp (tag_ul, &person_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of person sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_person_sets = len;
+ self->person_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->person_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" person sets %u = %s", i,
+ mxf_ul_to_string (&self->person_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &organisation_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of organisation sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_organisation_sets = len;
+ self->organisation_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->organisation_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" organisation sets %u = %s", i,
+ mxf_ul_to_string (&self->organisation_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_participant_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 participant local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_participant_init (MXFDMS1Participant * self)
+{
+}
+
+static void
+mxf_dms1_participant_class_init (MXFDMS1ParticipantClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_participant_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_participant_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_participant_resolve;
+}
+
+G_DEFINE_ABSTRACT_TYPE (MXFDMS1Contact, mxf_dms1_contact,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_contact_finalize (GstMiniObject * object)
+{
+ MXFDMS1Contact *self = MXF_DMS1_CONTACT (object);
+
+ g_free (self->name_value_sets_uids);
+ self->name_value_sets_uids = NULL;
+
+ g_free (self->name_value_sets);
+ self->name_value_sets = NULL;
+
+ g_free (self->address_sets_uids);
+ self->address_sets_uids = NULL;
+
+ g_free (self->address_sets);
+ self->address_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_contact_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_contact_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Contact *self = MXF_DMS1_CONTACT (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->name_value_sets = g_new0 (MXFDMS1NameValue *, self->n_name_value_sets);
+ self->address_sets = g_new0 (MXFDMS1Address *, self->n_address_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_NAME_VALUE (current)) {
+ for (i = 0; i < self->n_name_value_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->name_value_sets_uids[i])) {
+ self->name_value_sets[i] = MXF_DMS1_NAME_VALUE (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_ADDRESS (current)) {
+ for (i = 0; i < self->n_address_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->address_sets_uids[i])) {
+ self->address_sets[i] = MXF_DMS1_ADDRESS (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_contact_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_contact_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Contact *self = MXF_DMS1_CONTACT (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 contact_uid_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x08, 0x01,
+ 0x01, 0x15, 0x40, 0x01, 0x02, 0x00, 0x00
+ };
+ static const guint8 name_value_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x1f, 0x02
+ };
+ static const guint8 address_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x17, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &contact_uid_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->contact_uid, tag_data, 16);
+ GST_DEBUG (" contact uid = %s", mxf_ul_to_string (&self->contact_uid,
+ str));
+ } else if (memcmp (tag_ul, &name_value_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of name-value sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_name_value_sets = len;
+ self->name_value_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->name_value_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" name-value sets %u = %s", i,
+ mxf_ul_to_string (&self->name_value_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &address_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of address sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_address_sets = len;
+ self->address_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->address_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" address sets %u = %s", i,
+ mxf_ul_to_string (&self->address_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_contact_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 contact local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_contact_init (MXFDMS1Contact * self)
+{
+}
+
+static void
+mxf_dms1_contact_class_init (MXFDMS1ContactClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_contact_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_contact_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_contact_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Person, mxf_dms1_person, MXF_TYPE_DMS1_CONTACT);
+
+static void
+mxf_dms1_person_finalize (GstMiniObject * object)
+{
+ MXFDMS1Person *self = MXF_DMS1_PERSON (object);
+
+ g_free (self->family_name);
+ self->family_name = NULL;
+
+ g_free (self->first_given_name);
+ self->first_given_name = NULL;
+
+ g_free (self->other_given_names);
+ self->other_given_names = NULL;
+
+ g_free (self->linking_name);
+ self->linking_name = NULL;
+
+ g_free (self->salutation);
+ self->salutation = NULL;
+
+ g_free (self->name_suffix);
+ self->name_suffix = NULL;
+
+ g_free (self->honours_qualifications);
+ self->honours_qualifications = NULL;
+
+ g_free (self->former_family_name);
+ self->former_family_name = NULL;
+
+ g_free (self->person_description);
+ self->person_description = NULL;
+
+ g_free (self->alternate_name);
+ self->alternate_name = NULL;
+
+ g_free (self->nationality);
+ self->nationality = NULL;
+
+ g_free (self->citizenship);
+ self->citizenship = NULL;
+
+ g_free (self->organisation_sets_uids);
+ self->organisation_sets_uids = NULL;
+
+ g_free (self->organisation_sets);
+ self->organisation_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_person_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_person_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Person *self = MXF_DMS1_PERSON (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->organisation_sets =
+ g_new0 (MXFDMS1Organisation *, self->n_organisation_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_ORGANISATION (current)) {
+ for (i = 0; i < self->n_organisation_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->organisation_sets_uids[i])) {
+ self->organisation_sets[i] = MXF_DMS1_ORGANISATION (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_person_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_person_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Person *self = MXF_DMS1_PERSON (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 family_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x01, 0x01, 0x00
+ };
+ static const guint8 first_given_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x02, 0x01, 0x00
+ };
+ static const guint8 other_given_names_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x08, 0x01, 0x00
+ };
+ static const guint8 linking_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x0a, 0x01, 0x00
+ };
+ static const guint8 salutation_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x05, 0x01, 0x00
+ };
+ static const guint8 name_suffix_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x0b, 0x01, 0x00
+ };
+ static const guint8 honours_qualifications_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x06, 0x01, 0x00
+ };
+ static const guint8 former_family_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x0c, 0x01, 0x00
+ };
+ static const guint8 person_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x07, 0x01, 0x00
+ };
+ static const guint8 alternate_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x09, 0x01, 0x00
+ };
+ static const guint8 nationality_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x0d, 0x01, 0x00
+ };
+ static const guint8 citizenship_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x02,
+ 0x30, 0x06, 0x03, 0x01, 0x0e, 0x01, 0x00
+ };
+ static const guint8 organisation_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x15, 0x02
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &family_name_ul, 16) == 0) {
+ self->family_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" family name = %s", GST_STR_NULL (self->family_name));
+ } else if (memcmp (tag_ul, &first_given_name_ul, 16) == 0) {
+ self->first_given_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" first given name = %s",
+ GST_STR_NULL (self->first_given_name));
+ } else if (memcmp (tag_ul, &other_given_names_ul, 16) == 0) {
+ self->other_given_names = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" other given names = %s",
+ GST_STR_NULL (self->other_given_names));
+ } else if (memcmp (tag_ul, &linking_name_ul, 16) == 0) {
+ self->linking_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" linking name = %s", GST_STR_NULL (self->linking_name));
+ } else if (memcmp (tag_ul, &salutation_ul, 16) == 0) {
+ self->salutation = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" salutation = %s", GST_STR_NULL (self->salutation));
+ } else if (memcmp (tag_ul, &name_suffix_ul, 16) == 0) {
+ self->name_suffix = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" name suffix = %s", GST_STR_NULL (self->name_suffix));
+ } else if (memcmp (tag_ul, &honours_qualifications_ul, 16) == 0) {
+ self->honours_qualifications = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" honours & qualifications = %s",
+ GST_STR_NULL (self->honours_qualifications));
+ } else if (memcmp (tag_ul, &former_family_name_ul, 16) == 0) {
+ self->former_family_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" former family name = %s",
+ GST_STR_NULL (self->former_family_name));
+ } else if (memcmp (tag_ul, &person_description_ul, 16) == 0) {
+ self->person_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" person description = %s",
+ GST_STR_NULL (self->person_description));
+ } else if (memcmp (tag_ul, &alternate_name_ul, 16) == 0) {
+ self->alternate_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" alternate name = %s", GST_STR_NULL (self->alternate_name));
+ } else if (memcmp (tag_ul, &nationality_ul, 16) == 0) {
+ self->nationality = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" nationality = %s", GST_STR_NULL (self->nationality));
+ } else if (memcmp (tag_ul, &citizenship_ul, 16) == 0) {
+ self->citizenship = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" citizenship = %s", GST_STR_NULL (self->citizenship));
+ } else if (memcmp (tag_ul, &organisation_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of organisation sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_organisation_sets = len;
+ self->organisation_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->organisation_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" organisation sets %u = %s", i,
+ mxf_ul_to_string (&self->organisation_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_person_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 person local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_person_init (MXFDMS1Person * self)
+{
+}
+
+static void
+mxf_dms1_person_class_init (MXFDMS1PersonClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_person_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_person_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_person_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Organisation, mxf_dms1_organisation,
+ MXF_TYPE_DMS1_CONTACT);
+
+static void
+mxf_dms1_organisation_finalize (GstMiniObject * object)
+{
+ MXFDMS1Organisation *self = MXF_DMS1_ORGANISATION (object);
+
+ g_free (self->nature_of_organisation);
+ self->nature_of_organisation = NULL;
+
+ g_free (self->organisation_main_name);
+ self->organisation_main_name = NULL;
+
+ g_free (self->organisation_code);
+ self->organisation_code = NULL;
+
+ g_free (self->contact_department);
+ self->contact_department = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_organisation_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_organisation_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Organisation *self = MXF_DMS1_ORGANISATION (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 nature_of_organisation_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 organisation_main_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x06, 0x03, 0x03, 0x01, 0x01, 0x00
+ };
+ static const guint8 organisation_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x0a, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 contact_department_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x30, 0x06, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &nature_of_organisation_ul, 16) == 0) {
+ self->nature_of_organisation = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" nature of organisation = %s",
+ GST_STR_NULL (self->nature_of_organisation));
+ } else if (memcmp (tag_ul, &organisation_main_name_ul, 16) == 0) {
+ self->organisation_main_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" organisation main name = %s",
+ GST_STR_NULL (self->organisation_main_name));
+ } else if (memcmp (tag_ul, &organisation_code_ul, 16) == 0) {
+ self->organisation_code = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" organisation code = %s",
+ GST_STR_NULL (self->organisation_code));
+ } else if (memcmp (tag_ul, &contact_department_ul, 16) == 0) {
+ self->contact_department = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" contact department = %s",
+ GST_STR_NULL (self->contact_department));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_organisation_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_organisation_init (MXFDMS1Organisation * self)
+{
+}
+
+static void
+mxf_dms1_organisation_class_init (MXFDMS1OrganisationClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_organisation_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_organisation_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Location, mxf_dms1_location, MXF_TYPE_DMS1_CONTACT);
+
+static void
+mxf_dms1_location_finalize (GstMiniObject * object)
+{
+ MXFDMS1Location *self = MXF_DMS1_LOCATION (object);
+
+ g_free (self->location_kind);
+ self->location_kind = NULL;
+
+ g_free (self->location_description);
+ self->location_description = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_location_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_location_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Location *self = MXF_DMS1_LOCATION (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 location_kind_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x01, 0x20, 0x02, 0x03, 0x01, 0x00, 0x00
+ };
+ static const guint8 location_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x01, 0x20, 0x02, 0x02, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &location_kind_ul, 16) == 0) {
+ self->location_kind = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" location kind = %s", GST_STR_NULL (self->location_kind));
+ } else if (memcmp (tag_ul, &location_description_ul, 16) == 0) {
+ self->location_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" location description = %s",
+ GST_STR_NULL (self->location_description));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_location_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_location_init (MXFDMS1Location * self)
+{
+}
+
+static void
+mxf_dms1_location_class_init (MXFDMS1LocationClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_location_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_location_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Address, mxf_dms1_address, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_address_finalize (GstMiniObject * object)
+{
+ MXFDMS1Address *self = MXF_DMS1_ADDRESS (object);
+
+ g_free (self->room_or_suite_number);
+ self->room_or_suite_number = NULL;
+
+ g_free (self->room_or_suite_name);
+ self->room_or_suite_name = NULL;
+
+ g_free (self->building_name);
+ self->building_name = NULL;
+
+ g_free (self->street_number);
+ self->street_number = NULL;
+
+ g_free (self->street_name);
+ self->street_name = NULL;
+
+ g_free (self->postal_town);
+ self->postal_town = NULL;
+
+ g_free (self->city);
+ self->city = NULL;
+
+ g_free (self->state_or_province_or_country);
+ self->state_or_province_or_country = NULL;
+
+ g_free (self->postal_code);
+ self->postal_code = NULL;
+
+ g_free (self->country);
+ self->country = NULL;
+
+ g_free (self->astronomical_body_name);
+ self->astronomical_body_name = NULL;
+
+ g_free (self->communications_sets_uids);
+ self->communications_sets_uids = NULL;
+
+ g_free (self->communications_sets);
+ self->communications_sets = NULL;
+
+ g_free (self->name_value_sets_uids);
+ self->name_value_sets_uids = NULL;
+
+ g_free (self->name_value_sets);
+ self->name_value_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_address_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_address_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Address *self = MXF_DMS1_ADDRESS (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->communications_sets =
+ g_new0 (MXFDMS1Communications *, self->n_communications_sets);
+ self->name_value_sets = g_new0 (MXFDMS1NameValue *, self->n_name_value_sets);
+ while (*p != NULL) {
+ current = *p;
+
+ if (MXF_IS_DMS1_COMMUNICATIONS (current)) {
+ for (i = 0; i < self->n_communications_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->communications_sets_uids[i])) {
+ self->communications_sets[i] = MXF_DMS1_COMMUNICATIONS (self);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_NAME_VALUE (current)) {
+ for (i = 0; i < self->n_name_value_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->name_value_sets_uids[i])) {
+ self->name_value_sets[i] = MXF_DMS1_NAME_VALUE (self);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_address_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_address_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Address *self = MXF_DMS1_ADDRESS (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 room_or_suite_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x01, 0x01
+ };
+ static const guint8 room_or_suite_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x11, 0x01
+ };
+ static const guint8 building_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x12, 0x01
+ };
+ static const guint8 place_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x14, 0x01
+ };
+ static const guint8 street_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x02, 0x01
+ };
+ static const guint8 street_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x03, 0x01
+ };
+ static const guint8 postal_town_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x04, 0x01
+ };
+ static const guint8 city_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x05, 0x01
+ };
+ static const guint8 state_or_province_or_country_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x06, 0x01
+ };
+ static const guint8 postal_code_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x07, 0x01
+ };
+ static const guint8 country_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x08, 0x01
+ };
+ static const guint8 geographical_coordinate_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x15, 0x01
+ };
+ static const guint8 astronomical_body_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07,
+ 0x01, 0x20, 0x01, 0x04, 0x01, 0x16, 0x01
+ };
+ static const guint8 communications_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x19, 0x00
+ };
+ static const guint8 name_value_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x07, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x1f, 0x04
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &room_or_suite_name_ul, 16) == 0) {
+ self->room_or_suite_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" room or suite name = %s",
+ GST_STR_NULL (self->room_or_suite_name));
+ } else if (memcmp (tag_ul, &room_or_suite_number_ul, 16) == 0) {
+ self->room_or_suite_number = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" room or suite number = %s",
+ GST_STR_NULL (self->room_or_suite_number));
+ } else if (memcmp (tag_ul, &building_name_ul, 16) == 0) {
+ self->building_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" building name = %s", GST_STR_NULL (self->building_name));
+ } else if (memcmp (tag_ul, &place_name_ul, 16) == 0) {
+ self->place_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" place name = %s", GST_STR_NULL (self->place_name));
+ } else if (memcmp (tag_ul, &street_number_ul, 16) == 0) {
+ self->street_number = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" street number = %s", GST_STR_NULL (self->street_number));
+ } else if (memcmp (tag_ul, &street_name_ul, 16) == 0) {
+ self->street_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" street name = %s", GST_STR_NULL (self->street_name));
+ } else if (memcmp (tag_ul, &postal_town_ul, 16) == 0) {
+ self->postal_town = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" postal town = %s", GST_STR_NULL (self->postal_town));
+ } else if (memcmp (tag_ul, &city_ul, 16) == 0) {
+ self->city = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" city = %s", GST_STR_NULL (self->city));
+ } else if (memcmp (tag_ul, &state_or_province_or_country_ul, 16) == 0) {
+ self->state_or_province_or_country = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" state or province or country = %s",
+ GST_STR_NULL (self->state_or_province_or_country));
+ } else if (memcmp (tag_ul, &postal_code_ul, 16) == 0) {
+ self->postal_code = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" postal code = %s", GST_STR_NULL (self->postal_code));
+ } else if (memcmp (tag_ul, &country_ul, 16) == 0) {
+ self->country = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" country = %s", GST_STR_NULL (self->country));
+ } else if (memcmp (tag_ul, &geographical_coordinate_ul, 16) == 0) {
+ if (tag_size != 12)
+ goto error;
+
+ memcpy (&self->geographical_coordinate, tag_data, 12);
+ /* TODO implement */
+ } else if (memcmp (tag_ul, &astronomical_body_name_ul, 16) == 0) {
+ self->astronomical_body_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" astronomical body name = %s",
+ GST_STR_NULL (self->astronomical_body_name));
+ } else if (memcmp (tag_ul, &communications_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of communications sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_communications_sets = len;
+ self->communications_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->communications_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" communications sets %u = %s", i,
+ mxf_ul_to_string (&self->communications_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &name_value_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of name-value sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_name_value_sets = len;
+ self->name_value_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->name_value_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" name-value sets %u = %s", i,
+ mxf_ul_to_string (&self->name_value_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_address_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 address local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_address_init (MXFDMS1Address * self)
+{
+}
+
+static void
+mxf_dms1_address_class_init (MXFDMS1AddressClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_address_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_address_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_address_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Communications, mxf_dms1_communications, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_communications_finalize (GstMiniObject * object)
+{
+ MXFDMS1Communications *self = MXF_DMS1_COMMUNICATIONS (object);
+
+ g_free (self->email_address);
+ self->email_address = NULL;
+
+ g_free (self->web_page);
+ self->web_page = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_communications_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_communications_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Communications *self = MXF_DMS1_COMMUNICATIONS (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 central_telephone_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x01, 0x20, 0x01, 0x10, 0x03, 0x04, 0x00
+ };
+ static const guint8 telephone_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07,
+ 0x01, 0x20, 0x01, 0x10, 0x03, 0x01, 0x00
+ };
+ static const guint8 mobile_telephone_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x01, 0x20, 0x01, 0x10, 0x03, 0x05, 0x00
+ };
+ static const guint8 fax_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07,
+ 0x01, 0x20, 0x01, 0x10, 0x03, 0x02, 0x00
+ };
+ static const guint8 email_address_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x10, 0x03, 0x03, 0x01
+ };
+ static const guint8 web_page_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x07,
+ 0x01, 0x20, 0x01, 0x10, 0x03, 0x06, 0x01
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &central_telephone_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+ memcpy (self->central_telephone_number, tag_data, tag_size);
+
+ GST_DEBUG (" central telephone number = %s",
+ self->central_telephone_number);
+ } else if (memcmp (tag_ul, &telephone_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+ memcpy (self->telephone_number, tag_data, tag_size);
+
+ GST_DEBUG (" telephone number = %s", self->telephone_number);
+ } else if (memcmp (tag_ul, &mobile_telephone_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+ memcpy (self->mobile_telephone_number, tag_data, tag_size);
+
+ GST_DEBUG (" mobile telephone number = %s", self->mobile_telephone_number);
+ } else if (memcmp (tag_ul, &fax_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+ memcpy (self->fax_number, tag_data, tag_size);
+
+ GST_DEBUG (" fax number = %s", self->fax_number);
+ } else if (memcmp (tag_ul, &email_address_ul, 16) == 0) {
+ self->email_address = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" email address = %s", GST_STR_NULL (self->email_address));
+ } else if (memcmp (tag_ul, &web_page_ul, 16) == 0) {
+ self->web_page = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" web page = %s", GST_STR_NULL (self->web_page));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_communications_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 communications local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_communications_init (MXFDMS1Communications * self)
+{
+}
+
+static void
+mxf_dms1_communications_class_init (MXFDMS1CommunicationsClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_communications_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_communications_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Contract, mxf_dms1_contract, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_contract_finalize (GstMiniObject * object)
+{
+ MXFDMS1Contract *self = MXF_DMS1_CONTRACT (object);
+
+ g_free (self->rights_sets_uids);
+ self->rights_sets_uids = NULL;
+
+ g_free (self->rights_sets);
+ self->rights_sets = NULL;
+
+ g_free (self->participant_sets_uids);
+ self->participant_sets_uids = NULL;
+
+ g_free (self->participant_sets);
+ self->participant_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_contract_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_contract_resolve (MXFMetadataBase * m, MXFMetadataBase ** metadata)
+{
+ MXFDMS1Contract *self = MXF_DMS1_CONTRACT (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->rights_sets = g_new0 (MXFDMS1Rights *, self->n_rights_sets);
+ self->participant_sets =
+ g_new0 (MXFDMS1Participant *, self->n_participant_sets);
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_RIGHTS (current)) {
+ for (i = 0; i < self->n_rights_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->rights_sets_uids[i])) {
+ self->rights_sets[i] = MXF_DMS1_RIGHTS (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_PARTICIPANT (current)) {
+ for (i = 0; i < self->n_participant_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->participant_sets_uids[i])) {
+ self->participant_sets[i] = MXF_DMS1_PARTICIPANT (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return MXF_METADATA_BASE_CLASS (mxf_dms1_contract_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_contract_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Contract *self = MXF_DMS1_CONTRACT (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 supply_contract_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x02,
+ 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 rights_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x1a, 0x00
+ };
+ static const guint8 participant_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x13, 0x02
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &supply_contract_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->supply_contract_number, tag_data, tag_size);
+ GST_DEBUG (" supply contract number = %s", self->supply_contract_number);
+ } else if (memcmp (tag_ul, &rights_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of rights sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_rights_sets = len;
+ self->rights_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->rights_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" rights sets %u = %s", i,
+ mxf_ul_to_string (&self->rights_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &participant_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of participant sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_participant_sets = len;
+ self->participant_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->participant_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" participant sets %u = %s", i,
+ mxf_ul_to_string (&self->participant_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_contract_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 contract local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_contract_init (MXFDMS1Contract * self)
+{
+}
+
+static void
+mxf_dms1_contract_class_init (MXFDMS1ContractClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_contract_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_contract_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_contract_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1Rights, mxf_dms1_rights, MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_rights_finalize (GstMiniObject * object)
+{
+ MXFDMS1Rights *self = MXF_DMS1_RIGHTS (object);
+
+ g_free (self->copyright_owner);
+ self->copyright_owner = NULL;
+
+ g_free (self->rights_holder);
+ self->rights_holder = NULL;
+
+ g_free (self->rights_managment_authority);
+ self->rights_managment_authority = NULL;
+
+ g_free (self->region_or_area_of_ip_license);
+ self->region_or_area_of_ip_license = NULL;
+
+ g_free (self->intellectual_property_type);
+ self->intellectual_property_type = NULL;
+
+ g_free (self->right_condition);
+ self->right_condition = NULL;
+
+ g_free (self->right_remarks);
+ self->right_remarks = NULL;
+
+ g_free (self->intellectual_property_right);
+ self->intellectual_property_right = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_rights_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_rights_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Rights *self = MXF_DMS1_RIGHTS (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 copyright_owner_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x05, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 rights_holder_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x05, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 rights_managment_authority_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x05, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 region_or_area_of_ip_license_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07,
+ 0x01, 0x20, 0x01, 0x03, 0x05, 0x01, 0x00
+ };
+ static const guint8 intellectual_property_type_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x05, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 right_condition_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x05, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 right_remarks_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x08, 0x02,
+ 0x05, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 intellectual_property_right_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02,
+ 0x05, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 rights_start_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x02, 0x01, 0x20, 0x02, 0x00, 0x00, 0x00
+ };
+ static const guint8 rights_stop_date_and_time_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07,
+ 0x02, 0x01, 0x20, 0x03, 0x00, 0x00, 0x00
+ };
+ static const guint8 maximum_number_of_usages_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x02,
+ 0x05, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &copyright_owner_ul, 16) == 0) {
+ self->copyright_owner = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" copyright owner = %s", GST_STR_NULL (self->copyright_owner));
+ } else if (memcmp (tag_ul, &rights_holder_ul, 16) == 0) {
+ self->rights_holder = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" rights holder = %s", GST_STR_NULL (self->rights_holder));
+ } else if (memcmp (tag_ul, &rights_managment_authority_ul, 16) == 0) {
+ self->rights_managment_authority = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" rights managment authority = %s",
+ GST_STR_NULL (self->rights_managment_authority));
+ } else if (memcmp (tag_ul, &region_or_area_of_ip_license_ul, 16) == 0) {
+ self->region_or_area_of_ip_license = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" region or area of ip license = %s",
+ GST_STR_NULL (self->region_or_area_of_ip_license));
+ } else if (memcmp (tag_ul, &intellectual_property_type_ul, 16) == 0) {
+ self->intellectual_property_type = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" intellectual property type = %s",
+ GST_STR_NULL (self->intellectual_property_type));
+ } else if (memcmp (tag_ul, &right_condition_ul, 16) == 0) {
+ self->right_condition = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" right condition = %s", GST_STR_NULL (self->right_condition));
+ } else if (memcmp (tag_ul, &right_remarks_ul, 16) == 0) {
+ self->right_remarks = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" right remarks = %s", GST_STR_NULL (self->right_remarks));
+ } else if (memcmp (tag_ul, &intellectual_property_right_ul, 16) == 0) {
+ self->intellectual_property_right = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" intellectual property right = %s",
+ GST_STR_NULL (self->intellectual_property_right));
+ } else if (memcmp (tag_ul, &rights_start_date_and_time_ul, 16) == 0) {
+ if (!mxf_timestamp_parse (&self->rights_start_date_and_time, tag_data,
+ tag_size))
+ goto error;
+
+ GST_DEBUG (" rights start date and time = %d/%u/%u %u:%u:%u.%u",
+ self->rights_start_date_and_time.year,
+ self->rights_start_date_and_time.month,
+ self->rights_start_date_and_time.day,
+ self->rights_start_date_and_time.hour,
+ self->rights_start_date_and_time.minute,
+ self->rights_start_date_and_time.second,
+ (self->rights_start_date_and_time.quarter_msecond * 1000) / 256);
+ } else if (memcmp (tag_ul, &rights_stop_date_and_time_ul, 16) == 0) {
+ if (!mxf_timestamp_parse (&self->rights_start_date_and_time, tag_data,
+ tag_size))
+ goto error;
+
+ GST_DEBUG (" rights stop date and time = %d/%u/%u %u:%u:%u.%u",
+ self->rights_stop_date_and_time.year,
+ self->rights_stop_date_and_time.month,
+ self->rights_stop_date_and_time.day,
+ self->rights_stop_date_and_time.hour,
+ self->rights_stop_date_and_time.minute,
+ self->rights_stop_date_and_time.second,
+ (self->rights_stop_date_and_time.quarter_msecond * 1000) / 256);
+ } else if (memcmp (tag_ul, &maximum_number_of_usages_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->maximum_number_of_usages = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" maximum number of usages = %u",
+ self->maximum_number_of_usages);
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_rights_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 rights local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_rights_init (MXFDMS1Rights * self)
+{
+}
+
+static void
+mxf_dms1_rights_class_init (MXFDMS1RightsClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_rights_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_rights_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1PictureFormat, mxf_dms1_picture_format, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_picture_format_finalize (GstMiniObject * object)
+{
+ MXFDMS1PictureFormat *self = MXF_DMS1_PICTURE_FORMAT (object);
+
+ g_free (self->colour_descriptor);
+ self->colour_descriptor = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_picture_format_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_picture_format_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1PictureFormat *self = MXF_DMS1_PICTURE_FORMAT (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 viewport_aspect_ratio_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 0x04,
+ 0x01, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00
+ };
+ static const guint8 perceived_display_format_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x04,
+ 0x01, 0x01, 0x01, 0x08, 0x00, 0x00, 0x00
+ };
+ static const guint8 colour_descriptor_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x03,
+ 0x02, 0x01, 0x06, 0x04, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &viewport_aspect_ratio_ul, 16) == 0) {
+ if (!mxf_fraction_parse (&self->viewport_aspect_ratio, tag_data, tag_size))
+ goto error;
+
+ GST_DEBUG (" viewport aspect ratio = %u/%u", self->viewport_aspect_ratio.n,
+ self->viewport_aspect_ratio.d);
+ } else if (memcmp (tag_ul, &perceived_display_format_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->perceived_display_format, tag_data, tag_size);
+ GST_DEBUG (" perceived display format = %s",
+ self->perceived_display_format);
+ } else if (memcmp (tag_ul, &colour_descriptor_ul, 16) == 0) {
+ self->colour_descriptor = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" colour descriptor = %s",
+ GST_STR_NULL (self->colour_descriptor));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_picture_format_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 picture format local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_picture_format_init (MXFDMS1PictureFormat * self)
+{
+}
+
+static void
+mxf_dms1_picture_format_class_init (MXFDMS1PictureFormatClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_picture_format_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_picture_format_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1DeviceParameters, mxf_dms1_device_parameters,
+ MXF_TYPE_DMS1_THESAURUS);
+
+static void
+mxf_dms1_device_parameters_finalize (GstMiniObject * object)
+{
+ MXFDMS1DeviceParameters *self = MXF_DMS1_DEVICE_PARAMETERS (object);
+
+ g_free (self->device_type);
+ self->device_type = NULL;
+
+ g_free (self->manufacturer);
+ self->manufacturer = NULL;
+
+ g_free (self->device_model);
+ self->device_model = NULL;
+
+ g_free (self->device_serial_number);
+ self->device_serial_number = NULL;
+
+ g_free (self->device_usage_description);
+ self->device_usage_description = NULL;
+
+ g_free (self->name_value_sets_uids);
+ self->name_value_sets_uids = NULL;
+
+ g_free (self->name_value_sets);
+ self->name_value_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_device_parameters_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_device_parameters_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1DeviceParameters *self = MXF_DMS1_DEVICE_PARAMETERS (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->name_value_sets = g_new0 (MXFDMS1NameValue *, self->n_name_value_sets);
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_NAME_VALUE (current)) {
+ for (i = 0; i < self->n_name_value_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->name_value_sets_uids[i])) {
+ self->name_value_sets[i] = MXF_DMS1_NAME_VALUE (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS (mxf_dms1_device_parameters_parent_class)->resolve
+ (m, metadata);
+}
+
+static gboolean
+mxf_dms1_device_parameters_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1DeviceParameters *self = MXF_DMS1_DEVICE_PARAMETERS (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 device_type_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x01, 0x20, 0x08, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 device_designation_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x20, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 device_asset_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x01, 0x20, 0x0c, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 ieee_device_identifier_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 0x01,
+ 0x01, 0x20, 0x05, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 manufacturer_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 0x01,
+ 0x0a, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 device_model_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x20, 0x03, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 device_serial_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 device_usage_description_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x03, 0x03, 0x10, 0x01, 0x01, 0x00, 0x00
+ };
+ static const guint8 name_value_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x05, 0x40, 0x1f, 0x03
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &device_type_ul, 16) == 0) {
+ self->device_type = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" device type = %s", GST_STR_NULL (self->device_type));
+ } else if (memcmp (tag_ul, &device_designation_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->device_designation, tag_data, tag_size);
+ GST_DEBUG (" device designation = %s", self->device_designation);
+ } else if (memcmp (tag_ul, &device_asset_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->device_asset_number, tag_data, tag_size);
+ GST_DEBUG (" device asset number = %s", self->device_asset_number);
+ } else if (memcmp (tag_ul, &ieee_device_identifier_ul, 16) == 0) {
+ if (tag_size != 6)
+ goto error;
+
+ memcpy (self->ieee_device_identifier, tag_data, 6);
+ GST_DEBUG
+ (" IEEE device identifier = 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x",
+ self->ieee_device_identifier[0], self->ieee_device_identifier[1],
+ self->ieee_device_identifier[2], self->ieee_device_identifier[3],
+ self->ieee_device_identifier[4], self->ieee_device_identifier[5]);
+ } else if (memcmp (tag_ul, &manufacturer_ul, 16) == 0) {
+ self->manufacturer = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" manufacturer = %s", GST_STR_NULL (self->manufacturer));
+ } else if (memcmp (tag_ul, &device_model_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->device_model, tag_data, tag_size);
+ GST_DEBUG (" device model = %s", self->device_model);
+ } else if (memcmp (tag_ul, &device_serial_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->device_serial_number, tag_data, tag_size);
+ GST_DEBUG (" device serial number = %s", self->device_serial_number);
+ } else if (memcmp (tag_ul, &device_usage_description_ul, 16) == 0) {
+ self->device_usage_description = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" device usage description = %s",
+ GST_STR_NULL (self->device_usage_description));
+ } else if (memcmp (tag_ul, &name_value_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of name-value sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_name_value_sets = len;
+ self->name_value_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->name_value_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" name-value sets %u = %s", i,
+ mxf_ul_to_string (&self->name_value_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_device_parameters_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 device parameters local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_device_parameters_init (MXFDMS1DeviceParameters * self)
+{
+}
+
+static void
+mxf_dms1_device_parameters_class_init (MXFDMS1DeviceParametersClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_device_parameters_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_device_parameters_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_device_parameters_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1NameValue, mxf_dms1_name_value, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_name_value_finalize (GstMiniObject * object)
+{
+ MXFDMS1NameValue *self = MXF_DMS1_NAME_VALUE (object);
+
+ g_free (self->item_name);
+ self->item_name = NULL;
+
+ g_free (self->item_value);
+ self->item_value = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_name_value_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_name_value_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1NameValue *self = MXF_DMS1_NAME_VALUE (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 item_name_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x01, 0x02, 0x0a, 0x01, 0x01, 0x00, 0x00
+ };
+ static const guint8 item_value_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x03,
+ 0x01, 0x02, 0x0a, 0x02, 0x01, 0x00, 0x00
+ };
+ static const guint8 smpte_universal_label_locator_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x01,
+ 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &item_name_ul, 16) == 0) {
+ self->item_name = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" item name = %s", GST_STR_NULL (self->item_name));
+ } else if (memcmp (tag_ul, &item_value_ul, 16) == 0) {
+ self->item_value = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" item value = %s", GST_STR_NULL (self->item_value));
+ } else if (memcmp (tag_ul, &smpte_universal_label_locator_ul, 16) == 0) {
+ if (tag_size != 16)
+ goto error;
+
+ memcpy (&self->smpte_universal_label_locator, tag_data, 16);
+ GST_DEBUG (" SMPTE universal label locator = %s",
+ mxf_ul_to_string (&self->smpte_universal_label_locator, str));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_name_value_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 name-value local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_name_value_init (MXFDMS1NameValue * self)
+{
+}
+
+static void
+mxf_dms1_name_value_class_init (MXFDMS1NameValueClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_name_value_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_name_value_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Processing, mxf_dms1_processing, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_processing_finalize (GstMiniObject * object)
+{
+ MXFDMS1Processing *self = MXF_DMS1_PROCESSING (object);
+
+ g_free (self->descriptive_comment);
+ self->descriptive_comment = NULL;
+
+ g_free (self->graphic_usage_type);
+ self->graphic_usage_type = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_processing_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_processing_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1Processing *self = MXF_DMS1_PROCESSING (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 quality_flag_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x05,
+ 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 descriptive_comment_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x03,
+ 0x02, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00
+ };
+ static const guint8 logo_flag_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x03, 0x05,
+ 0x01, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 graphic_usage_type_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x05,
+ 0x01, 0x01, 0x07, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 process_steps_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x05,
+ 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 generation_copy_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x05,
+ 0x01, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00
+ };
+ static const guint8 generation_clone_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x05,
+ 0x01, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &quality_flag_ul, 16) == 0) {
+ if (tag_size != 1)
+ goto error;
+
+ self->quality_flag = GST_READ_UINT8 (tag_data);
+ GST_DEBUG (" quality flag = %u", self->quality_flag);
+ } else if (memcmp (tag_ul, &descriptive_comment_ul, 16) == 0) {
+ self->descriptive_comment = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" descriptive comment = %s",
+ GST_STR_NULL (self->descriptive_comment));
+ } else if (memcmp (tag_ul, &logo_flag_ul, 16) == 0) {
+ if (tag_size != 1)
+ goto error;
+
+ self->logo_flag = GST_READ_UINT8 (tag_data);
+ GST_DEBUG (" logo flag = %u", self->logo_flag);
+ } else if (memcmp (tag_ul, &graphic_usage_type_ul, 16) == 0) {
+ self->graphic_usage_type = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" graphic usage type = %s",
+ GST_STR_NULL (self->graphic_usage_type));
+ } else if (memcmp (tag_ul, &process_steps_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->process_steps = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" process steps = %u", self->process_steps);
+ } else if (memcmp (tag_ul, &generation_copy_number_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->generation_copy_number = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" generation copy number = %u", self->generation_copy_number);
+ } else if (memcmp (tag_ul, &generation_clone_number_ul, 16) == 0) {
+ if (tag_size != 2)
+ goto error;
+
+ self->generation_clone_number = GST_READ_UINT16_BE (tag_data);
+ GST_DEBUG (" generation clone number = %u", self->generation_clone_number);
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_processing_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 processing local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_processing_init (MXFDMS1Processing * self)
+{
+}
+
+static void
+mxf_dms1_processing_class_init (MXFDMS1ProcessingClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_processing_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_processing_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1Project, mxf_dms1_project, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_project_finalize (GstMiniObject * object)
+{
+ MXFDMS1Project *self = MXF_DMS1_PROJECT (object);
+
+ g_free (self->project_name_or_title);
+ self->project_name_or_title = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_project_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_project_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
+ guint16 tag, const guint8 * tag_data, guint tag_size)
+{
+ MXFDMS1Project *self = MXF_DMS1_PROJECT (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 project_number_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x02, 0x01,
+ 0x03, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00
+ };
+ static const guint8 project_name_or_title_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01,
+ 0x03, 0x01, 0x08, 0x01, 0x00, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &project_number_ul, 16) == 0) {
+ if (tag_size > 32)
+ goto error;
+
+ memcpy (self->project_number, tag_data, tag_size);
+
+ GST_DEBUG (" project number = %s", self->project_number);
+ } else if (memcmp (tag_ul, &project_name_or_title_ul, 16) == 0) {
+ self->project_name_or_title = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" project name or title = %s",
+ GST_STR_NULL (self->project_name_or_title));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_project_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 project local tag 0x%04x of size %u", tag, tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_project_init (MXFDMS1Project * self)
+{
+}
+
+static void
+mxf_dms1_project_class_init (MXFDMS1ProjectClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_project_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_project_handle_tag;
+}
+
+G_DEFINE_TYPE (MXFDMS1ContactsList, mxf_dms1_contacts_list, MXF_TYPE_DMS1);
+
+static void
+mxf_dms1_contacts_list_finalize (GstMiniObject * object)
+{
+ MXFDMS1ContactsList *self = MXF_DMS1_CONTACTS_LIST (object);
+
+ g_free (self->person_sets_uids);
+ self->person_sets_uids = NULL;
+
+ g_free (self->person_sets);
+ self->person_sets = NULL;
+
+ g_free (self->organisation_sets_uids);
+ self->organisation_sets_uids = NULL;
+
+ g_free (self->organisation_sets);
+ self->organisation_sets = NULL;
+
+ g_free (self->location_sets_uids);
+ self->location_sets_uids = NULL;
+
+ g_free (self->location_sets);
+ self->location_sets = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_contacts_list_parent_class)->finalize
+ (object);
+}
+
+static gboolean
+mxf_dms1_contacts_list_resolve (MXFMetadataBase * m,
+ MXFMetadataBase ** metadata)
+{
+ MXFDMS1ContactsList *self = MXF_DMS1_CONTACTS_LIST (m);
+ MXFMetadataBase **p = metadata, *current = NULL;
+ guint i;
+
+ self->person_sets = g_new0 (MXFDMS1Person *, self->n_person_sets);
+ self->organisation_sets =
+ g_new0 (MXFDMS1Organisation *, self->n_organisation_sets);
+ self->location_sets = g_new0 (MXFDMS1Location *, self->n_location_sets);
+
+ while (*p) {
+ current = *p;
+
+ if (MXF_IS_DMS1_PERSON (current)) {
+ for (i = 0; i < self->n_person_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->person_sets_uids[i])) {
+ self->person_sets[i] = MXF_DMS1_PERSON (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_ORGANISATION (current)) {
+ for (i = 0; i < self->n_organisation_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->organisation_sets_uids[i])) {
+ self->organisation_sets[i] = MXF_DMS1_ORGANISATION (current);
+ break;
+ }
+ }
+ }
+
+ if (MXF_IS_DMS1_LOCATION (current)) {
+ for (i = 0; i < self->n_location_sets; i++) {
+ if (mxf_ul_is_equal (&current->instance_uid,
+ &self->location_sets_uids[i])) {
+ self->location_sets[i] = MXF_DMS1_LOCATION (current);
+ break;
+ }
+ }
+ }
+
+ p++;
+ }
+
+ return
+ MXF_METADATA_BASE_CLASS (mxf_dms1_contacts_list_parent_class)->resolve (m,
+ metadata);
+}
+
+static gboolean
+mxf_dms1_contacts_list_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1ContactsList *self = MXF_DMS1_CONTACTS_LIST (metadata);
+ gboolean ret = TRUE;
+#ifndef GST_DISABLE_GST_DEBUG
+ gchar str[48];
+#endif
+ MXFUL *tag_ul = NULL;
+ static const guint8 person_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x14, 0x00
+ };
+ static const guint8 organisation_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x15, 0x00
+ };
+ static const guint8 location_sets_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x06,
+ 0x01, 0x01, 0x04, 0x03, 0x40, 0x16, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &person_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of person sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_person_sets = len;
+ self->person_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->person_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" person sets %u = %s", i,
+ mxf_ul_to_string (&self->person_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &organisation_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of organisation sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_organisation_sets = len;
+ self->organisation_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->organisation_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" organisation sets %u = %s", i,
+ mxf_ul_to_string (&self->organisation_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else if (memcmp (tag_ul, &location_sets_ul, 16) == 0) {
+ guint32 len, i;
+
+ len = GST_READ_UINT32_BE (tag_data);
+ GST_DEBUG (" number of location sets = %u", len);
+ if (len == 0)
+ return ret;
+
+ if (GST_READ_UINT32_BE (tag_data + 4) != 16)
+ goto error;
+ tag_data += 8;
+ tag_size -= 8;
+
+ if (tag_size < 16 * len)
+ goto error;
+
+ self->n_location_sets = len;
+ self->location_sets_uids = g_new0 (MXFUL, len);
+
+ for (i = 0; i < len; i++) {
+ memcpy (&self->location_sets_uids[i], tag_data, 16);
+ GST_DEBUG (" location sets %u = %s", i,
+ mxf_ul_to_string (&self->location_sets_uids[i], str));
+ tag_data += 16;
+ tag_size -= 16;
+ }
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_dms1_contacts_list_parent_class)->handle_tag (metadata, primer,
+ tag, tag_data, tag_size);
+ }
+
+ return ret;
+
+error:
+
+ GST_ERROR ("Invalid DMS1 contacts list local tag 0x%04x of size %u", tag,
+ tag_size);
+
+ return FALSE;
+}
+
+static void
+mxf_dms1_contacts_list_init (MXFDMS1ContactsList * self)
+{
+}
+
+static void
+mxf_dms1_contacts_list_class_init (MXFDMS1ContactsListClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_contacts_list_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_contacts_list_handle_tag;
+ metadatabase_class->resolve = mxf_dms1_contacts_list_resolve;
+}
+
+G_DEFINE_TYPE (MXFDMS1CueWords, mxf_dms1_cue_words,
+ MXF_TYPE_DMS1_TEXT_LANGUAGE);
+
+static void
+mxf_dms1_cue_words_finalize (GstMiniObject * object)
+{
+ MXFDMS1CueWords *self = MXF_DMS1_CUE_WORDS (object);
+
+ g_free (self->in_cue_words);
+ self->in_cue_words = NULL;
+
+ g_free (self->out_cue_words);
+ self->out_cue_words = NULL;
+
+ GST_MINI_OBJECT_CLASS (mxf_dms1_cue_words_parent_class)->finalize (object);
+}
+
+static gboolean
+mxf_dms1_cue_words_handle_tag (MXFMetadataBase * metadata,
+ MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
+ guint tag_size)
+{
+ MXFDMS1CueWords *self = MXF_DMS1_CUE_WORDS (metadata);
+ gboolean ret = TRUE;
+ MXFUL *tag_ul = NULL;
+ static const guint8 in_cue_words_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x01, 0x02, 0x0d, 0x01, 0x00, 0x00
+ };
+ static const guint8 out_cue_words_ul[] = {
+ 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x04, 0x03,
+ 0x02, 0x01, 0x02, 0x0e, 0x01, 0x00, 0x00
+ };
+
+ if (!(tag_ul =
+ (MXFUL *) g_hash_table_lookup (primer->mappings,
+ GUINT_TO_POINTER (((guint) tag)))))
+ return FALSE;
+
+ if (memcmp (tag_ul, &in_cue_words_ul, 16) == 0) {
+ self->in_cue_words = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" in cue words = %s", GST_STR_NULL (self->in_cue_words));
+ } else if (memcmp (tag_ul, &out_cue_words_ul, 16) == 0) {
+ self->out_cue_words = mxf_utf16_to_utf8 (tag_data, tag_size);
+ GST_DEBUG (" out cue words = %s", GST_STR_NULL (self->out_cue_words));
+ } else {
+ ret =
+ MXF_METADATA_BASE_CLASS (mxf_dms1_cue_words_parent_class)->handle_tag
+ (metadata, primer, tag, tag_data, tag_size);
+ }
+
+ return ret;
+}
+
+static void
+mxf_dms1_cue_words_init (MXFDMS1CueWords * self)
+{
+}
+
+static void
+mxf_dms1_cue_words_class_init (MXFDMS1CueWordsClass * klass)
+{
+ GstMiniObjectClass *miniobject_class = (GstMiniObjectClass *) klass;
+ MXFMetadataBaseClass *metadatabase_class = (MXFMetadataBaseClass *) klass;
+
+ miniobject_class->finalize = mxf_dms1_cue_words_finalize;
+ metadatabase_class->handle_tag = mxf_dms1_cue_words_handle_tag;
+}
+
+#define ADD_SET(ID, TYPE) \
+ set = g_slice_new (MXFDescriptiveMetadataSet); \
+ set->id = ID; \
+ set->type = TYPE; \
+ dms1_sets = g_slist_prepend (dms1_sets, set);
+
+void
+mxf_dms1_initialize (void)
+{
+ GSList *dms1_sets = NULL;
+ MXFDescriptiveMetadataSet *set;
+
+ ADD_SET (0x000000, MXF_TYPE_DMS1);
+ /* SMPTE S380M Table 3 */
+ ADD_SET (0x010100, MXF_TYPE_DMS1_PRODUCTION_FRAMEWORK);
+ ADD_SET (0x010200, MXF_TYPE_DMS1_CLIP_FRAMEWORK);
+ ADD_SET (0x010300, MXF_TYPE_DMS1_SCENE_FRAMEWORK);
+ ADD_SET (0x100100, MXF_TYPE_DMS1_TITLES);
+ ADD_SET (0x110100, MXF_TYPE_DMS1_IDENTIFICATION);
+ ADD_SET (0x120100, MXF_TYPE_DMS1_GROUP_RELATIONSHIP);
+ ADD_SET (0x130100, MXF_TYPE_DMS1_BRANDING);
+ ADD_SET (0x140100, MXF_TYPE_DMS1_EVENT);
+ ADD_SET (0x140200, MXF_TYPE_DMS1_PUBLICATION);
+ ADD_SET (0x150100, MXF_TYPE_DMS1_AWARD);
+ ADD_SET (0x160100, MXF_TYPE_DMS1_CAPTIONS_DESCRIPTION);
+ ADD_SET (0x170100, MXF_TYPE_DMS1_ANNOTATION);
+ ADD_SET (0x170200, MXF_TYPE_DMS1_SETTING_PERIOD);
+ ADD_SET (0x170300, MXF_TYPE_DMS1_SCRIPTING);
+ ADD_SET (0x170400, MXF_TYPE_DMS1_CLASSIFICATION);
+ ADD_SET (0x170500, MXF_TYPE_DMS1_SHOT);
+ ADD_SET (0x170600, MXF_TYPE_DMS1_KEY_POINT);
+ ADD_SET (0x180100, MXF_TYPE_DMS1_PARTICIPANT);
+ ADD_SET (0x1a0200, MXF_TYPE_DMS1_PERSON);
+ ADD_SET (0x1a0300, MXF_TYPE_DMS1_ORGANISATION);
+ ADD_SET (0x1a0400, MXF_TYPE_DMS1_LOCATION);
+ ADD_SET (0x1b0100, MXF_TYPE_DMS1_ADDRESS);
+ ADD_SET (0x1b0200, MXF_TYPE_DMS1_COMMUNICATIONS);
+ ADD_SET (0x1c0100, MXF_TYPE_DMS1_CONTRACT);
+ ADD_SET (0x1c0200, MXF_TYPE_DMS1_RIGHTS);
+ ADD_SET (0x1d0100, MXF_TYPE_DMS1_PICTURE_FORMAT);
+ ADD_SET (0x1e0100, MXF_TYPE_DMS1_DEVICE_PARAMETERS);
+ ADD_SET (0x1f0100, MXF_TYPE_DMS1_NAME_VALUE);
+ ADD_SET (0x200100, MXF_TYPE_DMS1_PROCESSING);
+ ADD_SET (0x200200, MXF_TYPE_DMS1_PROJECT);
+ ADD_SET (0x190100, MXF_TYPE_DMS1_CONTACTS_LIST);
+ ADD_SET (0x170800, MXF_TYPE_DMS1_CUE_WORDS);
+
+ mxf_descriptive_metadata_register (0x01, dms1_sets);
+}
+
+#undef ADD_SET
generated by cgit v1.2.1 (git 2.18.0) at 2024-08-12 15:55:53 +0000