Implement parsing of DMS1 (SMPTE S380M)

12 files changed, 7261 insertions, 187 deletions

diff --git a/gst/mxf/mxf.c b/gst/mxf/mxf.c
index 655faf3a..236e8358 100644
--- a/gst/mxf/mxf.c
+++ b/gst/mxf/mxf.c
@@ -31,6 +31,7 @@
 #include "mxfd10.h"
 #include "mxfup.h"
 #include "mxfvc3.h"
+#include "mxfdms1.h"
 
 GST_DEBUG_CATEGORY (mxf_debug);
 #define GST_CAT_DEFAULT mxf_debug
@@ -47,6 +48,7 @@ plugin_init (GstPlugin * plugin)
   mxf_d10_init ();
   mxf_up_init ();
   mxf_vc3_init ();
+  mxf_dms1_initialize ();
 
   if (!gst_element_register (plugin, "mxfdemux", GST_RANK_PRIMARY,
           GST_TYPE_MXF_DEMUX))
diff --git a/gst/mxf/mxfalaw.c b/gst/mxf/mxfalaw.c
index a5ba98fb..18903770 100644
--- a/gst/mxf/mxfalaw.c
+++ b/gst/mxf/mxfalaw.c
@@ -100,10 +100,10 @@ mxf_alaw_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
     if (!track->parent.descriptor[i])
       continue;
 
-    if (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (track->parent.
-            descriptor[i])) {
-      s = (MXFMetadataGenericSoundEssenceDescriptor *) track->parent.
-          descriptor[i];
+    if (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
+      s = (MXFMetadataGenericSoundEssenceDescriptor *) track->
+          parent.descriptor[i];
       break;
     }
   }
diff --git a/gst/mxf/mxfd10.c b/gst/mxf/mxfd10.c
index 6af96006..43d68d0e 100644
--- a/gst/mxf/mxfd10.c
+++ b/gst/mxf/mxfd10.c
@@ -173,15 +173,15 @@ mxf_d10_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
     if (!track->parent.descriptor[i])
       continue;
 
-    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
-            descriptor[i])) {
-      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
+    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
+      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
       break;
-    } else if (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (track->parent.
-            descriptor[i])) {
-      s = (MXFMetadataGenericSoundEssenceDescriptor *) track->
-          parent.descriptor[i];
+    } else if (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
+      s = (MXFMetadataGenericSoundEssenceDescriptor *) track->parent.
+          descriptor[i];
       break;
     }
   }
diff --git a/gst/mxf/mxfdemux.c b/gst/mxf/mxfdemux.c
index 2ddc9d3e..8d3505e1 100644
--- a/gst/mxf/mxfdemux.c
+++ b/gst/mxf/mxfdemux.c
@@ -558,11 +558,11 @@ gst_mxf_demux_choose_package (GstMXFDemux * demux)
 
   for (i = 0; i < demux->preface->content_storage->n_packages; i++) {
     if (demux->preface->content_storage->packages[i] &&
-        MXF_IS_METADATA_MATERIAL_PACKAGE (demux->preface->content_storage->
-            packages[i])) {
+        MXF_IS_METADATA_MATERIAL_PACKAGE (demux->preface->
+            content_storage->packages[i])) {
       ret =
-          MXF_METADATA_GENERIC_PACKAGE (demux->preface->content_storage->
-          packages[i]);
+          MXF_METADATA_GENERIC_PACKAGE (demux->preface->
+          content_storage->packages[i]);
       break;
     }
   }
@@ -908,6 +908,7 @@ gst_mxf_demux_handle_descriptive_metadata (GstMXFDemux * demux,
   guint32 type;
   guint8 scheme;
   GstFlowReturn ret = GST_FLOW_OK;
+  MXFDescriptiveMetadata *m = NULL;
 
   scheme = GST_READ_UINT8 (key->u + 12);
   type = GST_READ_UINT24_BE (key->u + 13);
@@ -933,14 +934,23 @@ gst_mxf_demux_handle_descriptive_metadata (GstMXFDemux * demux,
     return GST_FLOW_OK;
   }
 
-  switch (type) {
-    default:
-      GST_WARNING_OBJECT (demux,
-          "Unknown or unhandled descriptive metadata of scheme 0x%02x and type 0x%06x",
-          scheme, type);
-      break;
+
+  m = mxf_descriptive_metadata_new (scheme, type, &demux->primer,
+      GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer));
+
+  if (!m) {
+    GST_WARNING_OBJECT (demux,
+        "Unknown or unhandled descriptive metadata of scheme 0x%02x and type 0x%06x",
+        scheme, type);
+    return GST_FLOW_OK;
   }
 
+  if (!demux->metadata)
+    demux->metadata = g_ptr_array_new ();
+
+  g_ptr_array_add (demux->metadata, m);
+
+
   return ret;
 }
 
@@ -975,8 +985,8 @@ gst_mxf_demux_pad_next_component (GstMXFDemux * demux, GstMXFDemuxPad * pad)
   GST_DEBUG_OBJECT (demux, "Switching to component %u", pad->current_component);
 
   pad->component =
-      MXF_METADATA_SOURCE_CLIP (sequence->structural_components[pad->
-          current_component]);
+      MXF_METADATA_SOURCE_CLIP (sequence->
+      structural_components[pad->current_component]);
   if (pad->component == NULL) {
     GST_ERROR_OBJECT (demux, "No such structural component");
     return GST_FLOW_ERROR;
@@ -984,8 +994,8 @@ gst_mxf_demux_pad_next_component (GstMXFDemux * demux, GstMXFDemuxPad * pad)
 
   if (!pad->component->source_package
       || !pad->component->source_package->top_level
-      || !MXF_METADATA_GENERIC_PACKAGE (pad->component->
-          source_package)->tracks) {
+      || !MXF_METADATA_GENERIC_PACKAGE (pad->component->source_package)->
+      tracks) {
     GST_ERROR_OBJECT (demux, "Invalid component");
     return GST_FLOW_ERROR;
   }
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
diff --git a/gst/mxf/mxfdms1.h b/gst/mxf/mxfdms1.h
index d4f1fb0d..a3be035c 100644
--- a/gst/mxf/mxfdms1.h
+++ b/gst/mxf/mxfdms1.h
@@ -17,11 +17,917 @@
  * Boston, MA 02111-1307, USA.
  */
 
-/* Implementation of SMPTE S380M - Descriptive Metadata Scheme-1 */
+/* Implementation of SMPTE S380M - Descriptive  Scheme-1 */
 
-#ifndef __MXF_DMS1_H__
-#define __MXF_DMS1_H__
+#ifndef _MXF_DMS1_H_
+#define _MXF_DMS1_H_
 
+#include <gst/gst.h>
+#include "mxfmetadata.h"
 
+#define MXF_TYPE_DMS1 \
+  (mxf_dms1_get_type())
+#define MXF_DMS1(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1, MXFDMS1))
+#define MXF_IS_DMS1(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1))
+typedef struct _MXFDMS1 MXFDMS1;
+typedef MXFDescriptiveMetadataClass MXFDMS1Class;
+GType mxf_dms1_get_type (void);
 
-#endif /* __MXF_DMS1_H__ */
+#define MXF_TYPE_DMS1_TEXT_LANGUAGE \
+  (mxf_dms1_text_language_get_type())
+#define MXF_DMS1_TEXT_LANGUAGE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_TEXT_LANGUAGE, MXFDMS1TextLanguage))
+#define MXF_IS_DMS1_TEXT_LANGUAGE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_TEXT_LANGUAGE))
+typedef struct _MXFDMS1TextLanguage MXFDMS1TextLanguage;
+typedef MXFDescriptiveMetadataClass MXFDMS1TextLanguageClass;
+GType mxf_dms1_text_language_get_type (void);
+
+#define MXF_TYPE_DMS1_THESAURUS \
+  (mxf_dms1_thesaurus_get_type())
+#define MXF_DMS1_THESAURUS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_THESAURUS, MXFDMS1Thesaurus))
+#define MXF_IS_DMS1_THESAURUS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_THESAURUS))
+typedef struct _MXFDMS1Thesaurus MXFDMS1Thesaurus;
+typedef MXFDescriptiveMetadataClass MXFDMS1ThesaurusClass;
+GType mxf_dms1_thesaurus_get_type (void);
+
+#define MXF_TYPE_DMS1_FRAMEWORK \
+  (mxf_dms1_framework_get_type())
+#define MXF_DMS1_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_FRAMEWORK, MXFDMS1Framework))
+#define MXF_IS_DMS1_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_FRAMEWORK))
+typedef struct _MXFDMS1Framework MXFDMS1Framework;
+typedef MXFDescriptiveMetadataClass MXFDMS1FrameworkClass;
+GType mxf_dms1_framework_get_type (void);
+
+#define MXF_TYPE_DMS1_PRODUCTION_CLIP_FRAMEWORK \
+  (mxf_dms1_production_clip_framework_get_type())
+#define MXF_DMS1_PRODUCTION_CLIP_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PRODUCTION_CLIP_FRAMEWORK, MXFDMS1ProductionClipFramework))
+#define MXF_IS_DMS1_PRODUCTION_CLIP_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PRODUCTION_CLIP_FRAMEWORK))
+typedef struct _MXFDMS1ProductionClipFramework MXFDMS1ProductionClipFramework;
+typedef MXFDescriptiveMetadataClass MXFDMS1ProductionClipFrameworkClass;
+GType mxf_dms1_production_clip_framework_get_type (void);
+
+#define MXF_TYPE_DMS1_PRODUCTION_FRAMEWORK \
+  (mxf_dms1_production_framework_get_type())
+#define MXF_DMS1_PRODUCTION_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PRODUCTION_FRAMEWORK, MXFDMS1ProductionFramework))
+#define MXF_IS_DMS1_PRODUCTION_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PRODUCTION_FRAMEWORK))
+typedef struct _MXFDMS1ProductionFramework MXFDMS1ProductionFramework;
+typedef MXFDescriptiveMetadataClass MXFDMS1ProductionFrameworkClass;
+GType mxf_dms1_production_framework_get_type (void);
+
+#define MXF_TYPE_DMS1_CLIP_FRAMEWORK \
+  (mxf_dms1_clip_framework_get_type())
+#define MXF_DMS1_CLIP_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CLIP_FRAMEWORK, MXFDMS1ClipFramework))
+#define MXF_IS_DMS1_CLIP_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CLIP_FRAMEWORK))
+typedef struct _MXFDMS1ClipFramework MXFDMS1ClipFramework;
+typedef MXFDescriptiveMetadataClass MXFDMS1ClipFrameworkClass;
+GType mxf_dms1_clip_framework_get_type (void);
+
+#define MXF_TYPE_DMS1_SCENE_FRAMEWORK \
+  (mxf_dms1_scene_framework_get_type())
+#define MXF_DMS1_SCENE_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_SCENE_FRAMEWORK, MXFDMS1SceneFramework))
+#define MXF_IS_DMS1_SCENE_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_SCENE_FRAMEWORK))
+typedef struct _MXFDMS1SceneFramework MXFDMS1SceneFramework;
+typedef MXFDescriptiveMetadataClass MXFDMS1SceneFrameworkClass;
+GType mxf_dms1_scene_framework_get_type (void);
+
+#define MXF_TYPE_DMS1_TITLES \
+  (mxf_dms1_titles_get_type())
+#define MXF_DMS1_TITLES(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_TITLES, MXFDMS1Titles))
+#define MXF_IS_DMS1_TITLES(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_TITLES))
+typedef struct _MXFDMS1Titles MXFDMS1Titles;
+typedef MXFDescriptiveMetadataClass MXFDMS1TitlesClass;
+GType mxf_dms1_titles_get_type (void);
+
+#define MXF_TYPE_DMS1_IDENTIFICATION \
+  (mxf_dms1_identification_get_type())
+#define MXF_DMS1_IDENTIFICATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_IDENTIFICATION, MXFDMS1Identification))
+#define MXF_IS_DMS1_IDENTIFICATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_IDENTIFICATION))
+typedef struct _MXFDMS1Identification MXFDMS1Identification;
+typedef MXFDescriptiveMetadataClass MXFDMS1IdentificationClass;
+GType mxf_dms1_identification_get_type (void);
+
+#define MXF_TYPE_DMS1_GROUP_RELATIONSHIP \
+  (mxf_dms1_group_relationship_get_type())
+#define MXF_DMS1_GROUP_RELATIONSHIP(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_GROUP_RELATIONSHIP, MXFDMS1GroupRelationship))
+#define MXF_IS_DMS1_GROUP_RELATIONSHIP(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_GROUP_RELATIONSHIP))
+typedef struct _MXFDMS1GroupRelationship MXFDMS1GroupRelationship;
+typedef MXFDescriptiveMetadataClass MXFDMS1GroupRelationshipClass;
+GType mxf_dms1_group_relationship_get_type (void);
+
+#define MXF_TYPE_DMS1_BRANDING \
+  (mxf_dms1_branding_get_type())
+#define MXF_DMS1_BRANDING(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_BRANDING, MXFDMS1Branding))
+#define MXF_IS_DMS1_BRANDING(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_BRANDING))
+typedef struct _MXFDMS1Branding MXFDMS1Branding;
+typedef MXFDescriptiveMetadataClass MXFDMS1BrandingClass;
+GType mxf_dms1_branding_get_type (void);
+
+#define MXF_TYPE_DMS1_EVENT \
+  (mxf_dms1_event_get_type())
+#define MXF_DMS1_EVENT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_EVENT, MXFDMS1Event))
+#define MXF_IS_DMS1_EVENT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_EVENT))
+typedef struct _MXFDMS1Event MXFDMS1Event;
+typedef MXFDescriptiveMetadataClass MXFDMS1EventClass;
+GType mxf_dms1_event_get_type (void);
+
+#define MXF_TYPE_DMS1_PUBLICATION \
+  (mxf_dms1_publication_get_type())
+#define MXF_DMS1_PUBLICATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PUBLICATION, MXFDMS1Publication))
+#define MXF_IS_DMS1_PUBLICATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PUBLICATION))
+typedef struct _MXFDMS1Publication MXFDMS1Publication;
+typedef MXFDescriptiveMetadataClass MXFDMS1PublicationClass;
+GType mxf_dms1_publication_get_type (void);
+
+#define MXF_TYPE_DMS1_AWARD \
+  (mxf_dms1_award_get_type())
+#define MXF_DMS1_AWARD(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_AWARD, MXFDMS1Award))
+#define MXF_IS_DMS1_AWARD(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_AWARD))
+typedef struct _MXFDMS1Award MXFDMS1Award;
+typedef MXFDescriptiveMetadataClass MXFDMS1AwardClass;
+GType mxf_dms1_award_get_type (void);
+
+#define MXF_TYPE_DMS1_CAPTIONS_DESCRIPTION \
+  (mxf_dms1_captions_description_get_type())
+#define MXF_DMS1_CAPTIONS_DESCRIPTION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CAPTIONS_DESCRIPTION, MXFDMS1CaptionsDescription))
+#define MXF_IS_DMS1_CAPTIONS_DESCRIPTION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CAPTIONS_DESCRIPTION))
+typedef struct _MXFDMS1CaptionsDescription MXFDMS1CaptionsDescription;
+typedef MXFDescriptiveMetadataClass MXFDMS1CaptionsDescriptionClass;
+GType mxf_dms1_captions_description_get_type (void);
+
+#define MXF_TYPE_DMS1_ANNOTATION \
+  (mxf_dms1_annotation_get_type())
+#define MXF_DMS1_ANNOTATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_ANNOTATION, MXFDMS1Annotation))
+#define MXF_IS_DMS1_ANNOTATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_ANNOTATION))
+typedef struct _MXFDMS1Annotation MXFDMS1Annotation;
+typedef MXFDescriptiveMetadataClass MXFDMS1AnnotationClass;
+GType mxf_dms1_annotation_get_type (void);
+
+#define MXF_TYPE_DMS1_SETTING_PERIOD \
+  (mxf_dms1_setting_period_get_type())
+#define MXF_DMS1_SETTING_PERIOD(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_SETTING_PERIOD, MXFDMS1SettingPeriod))
+#define MXF_IS_DMS1_SETTING_PERIOD(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_SETTING_PERIOD))
+typedef struct _MXFDMS1SettingPeriod MXFDMS1SettingPeriod;
+typedef MXFDescriptiveMetadataClass MXFDMS1SettingPeriodClass;
+GType mxf_dms1_setting_period_get_type (void);
+
+#define MXF_TYPE_DMS1_SCRIPTING \
+  (mxf_dms1_scripting_get_type())
+#define MXF_DMS1_SCRIPTING(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_SCRIPTING, MXFDMS1Scripting))
+#define MXF_IS_DMS1_SCRIPTING(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_SCRIPTING))
+typedef struct _MXFDMS1Scripting MXFDMS1Scripting;
+typedef MXFDescriptiveMetadataClass MXFDMS1ScriptingClass;
+GType mxf_dms1_scripting_get_type (void);
+
+#define MXF_TYPE_DMS1_CLASSIFICATION \
+  (mxf_dms1_classification_get_type())
+#define MXF_DMS1_CLASSIFICATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CLASSIFICATION, MXFDMS1Classification))
+#define MXF_IS_DMS1_CLASSIFICATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CLASSIFICATION))
+typedef struct _MXFDMS1Classification MXFDMS1Classification;
+typedef MXFDescriptiveMetadataClass MXFDMS1ClassificationClass;
+GType mxf_dms1_classification_get_type (void);
+
+#define MXF_TYPE_DMS1_SHOT \
+  (mxf_dms1_shot_get_type())
+#define MXF_DMS1_SHOT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_SHOT, MXFDMS1Shot))
+#define MXF_IS_DMS1_SHOT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_SHOT))
+typedef struct _MXFDMS1Shot MXFDMS1Shot;
+typedef MXFDescriptiveMetadataClass MXFDMS1ShotClass;
+GType mxf_dms1_shot_get_type (void);
+
+#define MXF_TYPE_DMS1_KEY_POINT \
+  (mxf_dms1_key_point_get_type())
+#define MXF_DMS1_KEY_POINT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_KEY_POINT, MXFDMS1KeyPoint))
+#define MXF_IS_DMS1_KEY_POINT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_KEY_POINT))
+typedef struct _MXFDMS1KeyPoint MXFDMS1KeyPoint;
+typedef MXFDescriptiveMetadataClass MXFDMS1KeyPointClass;
+GType mxf_dms1_key_point_get_type (void);
+
+#define MXF_TYPE_DMS1_PARTICIPANT \
+  (mxf_dms1_participant_get_type())
+#define MXF_DMS1_PARTICIPANT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PARTICIPANT, MXFDMS1Participant))
+#define MXF_IS_DMS1_PARTICIPANT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PARTICIPANT))
+typedef struct _MXFDMS1Participant MXFDMS1Participant;
+typedef MXFDescriptiveMetadataClass MXFDMS1ParticipantClass;
+GType mxf_dms1_participant_get_type (void);
+
+#define MXF_TYPE_DMS1_CONTACT \
+  (mxf_dms1_contact_get_type())
+#define MXF_DMS1_CONTACT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CONTACT, MXFDMS1Contact))
+#define MXF_IS_DMS1_CONTACT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CONTACT))
+typedef struct _MXFDMS1Contact MXFDMS1Contact;
+typedef MXFDescriptiveMetadataClass MXFDMS1ContactClass;
+GType mxf_dms1_contact_get_type (void);
+
+#define MXF_TYPE_DMS1_PERSON \
+  (mxf_dms1_person_get_type())
+#define MXF_DMS1_PERSON(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PERSON, MXFDMS1Person))
+#define MXF_IS_DMS1_PERSON(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PERSON))
+typedef struct _MXFDMS1Person MXFDMS1Person;
+typedef MXFDescriptiveMetadataClass MXFDMS1PersonClass;
+GType mxf_dms1_person_get_type (void);
+
+#define MXF_TYPE_DMS1_ORGANISATION \
+  (mxf_dms1_organisation_get_type())
+#define MXF_DMS1_ORGANISATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_ORGANISATION, MXFDMS1Organisation))
+#define MXF_IS_DMS1_ORGANISATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_ORGANISATION))
+typedef struct _MXFDMS1Organisation MXFDMS1Organisation;
+typedef MXFDescriptiveMetadataClass MXFDMS1OrganisationClass;
+GType mxf_dms1_organisation_get_type (void);
+
+#define MXF_TYPE_DMS1_LOCATION \
+  (mxf_dms1_location_get_type())
+#define MXF_DMS1_LOCATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_LOCATION, MXFDMS1Location))
+#define MXF_IS_DMS1_LOCATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_LOCATION))
+typedef struct _MXFDMS1Location MXFDMS1Location;
+typedef MXFDescriptiveMetadataClass MXFDMS1LocationClass;
+GType mxf_dms1_location_get_type (void);
+
+#define MXF_TYPE_DMS1_ADDRESS \
+  (mxf_dms1_address_get_type())
+#define MXF_DMS1_ADDRESS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_ADDRESS, MXFDMS1Address))
+#define MXF_IS_DMS1_ADDRESS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_ADDRESS))
+typedef struct _MXFDMS1Address MXFDMS1Address;
+typedef MXFDescriptiveMetadataClass MXFDMS1AddressClass;
+GType mxf_dms1_address_get_type (void);
+
+#define MXF_TYPE_DMS1_COMMUNICATIONS \
+  (mxf_dms1_communications_get_type())
+#define MXF_DMS1_COMMUNICATIONS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_COMMUNICATIONS, MXFDMS1Communications))
+#define MXF_IS_DMS1_COMMUNICATIONS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_COMMUNICATIONS))
+typedef struct _MXFDMS1Communications MXFDMS1Communications;
+typedef MXFDescriptiveMetadataClass MXFDMS1CommunicationsClass;
+GType mxf_dms1_communications_get_type (void);
+
+#define MXF_TYPE_DMS1_CONTRACT \
+  (mxf_dms1_contract_get_type())
+#define MXF_DMS1_CONTRACT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CONTRACT, MXFDMS1Contract))
+#define MXF_IS_DMS1_CONTRACT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CONTRACT))
+typedef struct _MXFDMS1Contract MXFDMS1Contract;
+typedef MXFDescriptiveMetadataClass MXFDMS1ContractClass;
+GType mxf_dms1_contract_get_type (void);
+
+#define MXF_TYPE_DMS1_RIGHTS \
+  (mxf_dms1_rights_get_type())
+#define MXF_DMS1_RIGHTS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_RIGHTS, MXFDMS1Rights))
+#define MXF_IS_DMS1_RIGHTS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_RIGHTS))
+typedef struct _MXFDMS1Rights MXFDMS1Rights;
+typedef MXFDescriptiveMetadataClass MXFDMS1RightsClass;
+GType mxf_dms1_rights_get_type (void);
+
+#define MXF_TYPE_DMS1_PICTURE_FORMAT \
+  (mxf_dms1_picture_format_get_type())
+#define MXF_DMS1_PICTURE_FORMAT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PICTURE_FORMAT, MXFDMS1PictureFormat))
+#define MXF_IS_DMS1_PICTURE_FORMAT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PICTURE_FORMAT))
+typedef struct _MXFDMS1PictureFormat MXFDMS1PictureFormat;
+typedef MXFDescriptiveMetadataClass MXFDMS1PictureFormatClass;
+GType mxf_dms1_picture_format_get_type (void);
+
+#define MXF_TYPE_DMS1_DEVICE_PARAMETERS \
+  (mxf_dms1_device_parameters_get_type())
+#define MXF_DMS1_DEVICE_PARAMETERS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_DEVICE_PARAMETERS, MXFDMS1DeviceParameters))
+#define MXF_IS_DMS1_DEVICE_PARAMETERS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_DEVICE_PARAMETERS))
+typedef struct _MXFDMS1DeviceParameters MXFDMS1DeviceParameters;
+typedef MXFDescriptiveMetadataClass MXFDMS1DeviceParametersClass;
+GType mxf_dms1_device_parameters_get_type (void);
+
+#define MXF_TYPE_DMS1_NAME_VALUE \
+  (mxf_dms1_name_value_get_type())
+#define MXF_DMS1_NAME_VALUE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_NAME_VALUE, MXFDMS1NameValue))
+#define MXF_IS_DMS1_NAME_VALUE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_NAME_VALUE))
+typedef struct _MXFDMS1NameValue MXFDMS1NameValue;
+typedef MXFDescriptiveMetadataClass MXFDMS1NameValueClass;
+GType mxf_dms1_name_value_get_type (void);
+
+#define MXF_TYPE_DMS1_PROCESSING \
+  (mxf_dms1_processing_get_type())
+#define MXF_DMS1_PROCESSING(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PROCESSING, MXFDMS1Processing))
+#define MXF_IS_DMS1_PROCESSING(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PROCESSING))
+typedef struct _MXFDMS1Processing MXFDMS1Processing;
+typedef MXFDescriptiveMetadataClass MXFDMS1ProcessingClass;
+GType mxf_dms1_processing_get_type (void);
+
+#define MXF_TYPE_DMS1_PROJECT \
+  (mxf_dms1_project_get_type())
+#define MXF_DMS1_PROJECT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_PROJECT, MXFDMS1Project))
+#define MXF_IS_DMS1_PROJECT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_PROJECT))
+typedef struct _MXFDMS1Project MXFDMS1Project;
+typedef MXFDescriptiveMetadataClass MXFDMS1ProjectClass;
+GType mxf_dms1_project_get_type (void);
+
+#define MXF_TYPE_DMS1_CONTACTS_LIST \
+  (mxf_dms1_contacts_list_get_type())
+#define MXF_DMS1_CONTACTS_LIST(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CONTACTS_LIST, MXFDMS1ContactsList))
+#define MXF_IS_DMS1_CONTACTS_LIST(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CONTACTS_LIST))
+typedef struct _MXFDMS1ContactsList MXFDMS1ContactsList;
+typedef MXFDescriptiveMetadataClass MXFDMS1ContactsListClass;
+GType mxf_dms1_contacts_list_get_type (void);
+
+#define MXF_TYPE_DMS1_CUE_WORDS \
+  (mxf_dms1_cue_words_get_type())
+#define MXF_DMS1_CUE_WORDS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DMS1_CUE_WORDS, MXFDMS1CueWords))
+#define MXF_IS_DMS1_CUE_WORDS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DMS1_CUE_WORDS))
+typedef struct _MXFDMS1CueWords MXFDMS1CueWords;
+typedef MXFDescriptiveMetadataClass MXFDMS1CueWordsClass;
+GType mxf_dms1_cue_words_get_type (void);
+
+struct _MXFDMS1 {
+  MXFDescriptiveMetadata parent;
+};
+
+struct _MXFDMS1TextLanguage {
+  MXFDMS1 parent;
+
+  gchar extended_text_language_code[13];
+};
+
+struct _MXFDMS1Thesaurus {
+  MXFDMS1TextLanguage parent;
+
+  gchar *thesaurus_name;
+};
+
+struct _MXFDMS1Framework {
+  MXFDMS1 parent;
+
+  gchar framework_extended_text_language_code[13];
+  gchar *framework_thesaurus_name;
+  gchar *framework_title;
+  gchar primary_extended_spoken_language_code[13];
+  gchar secondary_extended_spoken_language_code[13];
+  gchar original_extended_spoken_language_code[13];
+
+  guint32 n_metadata_server_locators;
+  MXFUL *metadata_server_locators_uids;
+  /* TODO */
+
+  guint32 n_titles_sets;
+  MXFUL *titles_sets_uids;
+  MXFDMS1Titles **titles_sets;
+
+  guint32 n_annotations_sets;
+  MXFUL *annotations_sets_uids;
+  MXFDMS1Annotation **annotations_sets;
+
+  guint32 n_participant_sets;
+  MXFUL *participant_sets_uids;
+  MXFDMS1Participant **participant_sets;
+
+  MXFUL contacts_list_set_uid;
+  MXFDMS1ContactsList *contacts_list_set;
+
+  guint32 n_location_sets;
+  MXFUL *location_sets_uids;
+  MXFDMS1Location **location_sets;
+};
+
+struct _MXFDMS1ProductionClipFramework {
+  MXFDMS1Framework parent;
+
+  MXFUL picture_format_set_uid;
+  MXFDMS1PictureFormat *picture_format;
+  
+  guint32 n_captions_description_sets;
+  MXFUL *captions_description_sets_uids;
+  MXFDMS1CaptionsDescription **captions_description_sets;
+
+  guint32 n_contract_sets;
+  MXFUL *contract_sets_uids;
+  MXFDMS1Contract **contract_sets;
+
+  MXFUL project_set_uid;
+  MXFDMS1Project *project_set;
+};
+
+struct _MXFDMS1ProductionFramework {
+  MXFDMS1ProductionClipFramework parent;
+
+  gchar *integration_indication;
+  
+  guint32 n_identification_sets;
+  MXFUL *identification_sets_uids;
+  MXFDMS1Identification **identification_sets;
+
+  guint32 n_group_relationship_sets;
+  MXFUL *group_relationship_sets_uids;
+  MXFDMS1GroupRelationship **group_relationship_sets;
+
+  guint32 n_branding_sets;
+  MXFUL *branding_sets_uids;
+  MXFDMS1Branding **branding_sets;
+
+  guint32 n_event_sets;
+  MXFUL *event_sets_uids;
+  MXFDMS1Event **event_sets;
+
+  guint32 n_award_sets;
+  MXFUL *award_sets_uids;
+  MXFDMS1Award **award_sets;
+
+  guint32 n_setting_period_sets;
+  MXFUL *setting_period_sets_uids;
+  MXFDMS1SettingPeriod **setting_period_sets;
+};
+
+struct _MXFDMS1ClipFramework {
+  MXFDMS1ProductionClipFramework parent;
+
+  gchar *clip_kind;
+  gchar clip_number[33];
+  
+  guint8 extended_clip_id[64];
+  gboolean extended_clip_id_full;
+
+  MXFTimestamp clip_creation_date_and_time;
+  
+  guint16 take_number;
+
+  gchar *slate_information;
+
+  guint32 n_scripting_sets;
+  MXFUL *scripting_sets_uids;
+  MXFDMS1Scripting **scripting_sets;
+
+  guint32 n_shot_sets;
+  MXFUL *shot_sets_uids;
+  MXFDMS1Shot **shot_sets;
+
+  guint32 n_device_parameters_sets;
+  MXFUL *device_parameters_sets_uids;
+  MXFDMS1DeviceParameters **device_parameters_sets;
+
+  MXFUL processing_set_uid;
+  MXFDMS1Processing *processing_set;
+};
+
+struct _MXFDMS1SceneFramework {
+  MXFDMS1Framework parent;
+
+  gchar scene_number[33];
+
+  guint32 n_setting_period_sets;
+  MXFUL *setting_period_sets_uids;
+  MXFDMS1SettingPeriod **setting_period_sets;
+
+  guint32 n_shot_scene_sets;
+  MXFUL *shot_scene_sets_uids;
+  MXFDMS1Shot **shot_scene_sets;
+};
+
+struct _MXFDMS1Titles {
+  MXFDMS1TextLanguage parent;
+
+  gchar *main_title;
+  gchar *secondary_title;
+  gchar *working_title;
+  gchar *original_title;
+  gchar *version_title;
+};
+
+struct _MXFDMS1Identification {
+  MXFDMS1Thesaurus parent;
+
+  gchar identifier_kind[33];
+  guint8 *identifier_value;
+  guint16 identifier_value_length;
+  MXFUL identification_locator;
+  gchar *identification_issuing_authority;
+};
+
+struct _MXFDMS1GroupRelationship {
+  MXFDMS1Thesaurus parent;
+
+  gchar *programming_group_kind;
+  gchar* programming_group_title;
+  gchar *group_synopsis;
+  guint32 numerical_position_in_sequence;
+  guint32 total_number_in_the_sequence;
+  guint16 episodic_start_number;
+  guint16 episodic_end_number;
+};
+
+struct _MXFDMS1Branding {
+  MXFDMS1TextLanguage parent;
+
+  gchar *brand_main_title;
+  gchar *brand_original_title;
+};
+
+struct _MXFDMS1Event {
+  MXFDMS1Thesaurus parent;
+
+  gchar *event_indication;
+  gchar event_start_date_and_time[33];
+  gchar event_end_date_and_time[33];
+  
+  guint32 n_publication_sets;
+  MXFUL *publication_sets_uids;
+  MXFDMS1Publication **publication_sets;
+
+  guint32 n_annotation_sets;
+  MXFUL *annotation_sets_uids;
+  MXFDMS1Annotation **annotation_sets;
+};
+
+struct _MXFDMS1Publication {
+  MXFDMS1 parent;
+
+  gchar *publication_organisation_name;
+  gchar *publication_service_name;
+  gchar *publication_medium;
+  gchar *publication_region;
+};
+
+struct _MXFDMS1Award {
+  MXFDMS1Thesaurus parent;
+
+  gchar *festival;
+  gchar festival_date_and_time[33];
+  gchar *award_name;
+  gchar *award_classification;
+  gchar *nomination_category;
+
+  guint32 n_participant_sets;
+  MXFUL *participant_sets_uids;
+  MXFDMS1Participant **participant_sets;
+};
+
+struct _MXFDMS1CaptionsDescription {
+  MXFDMS1Thesaurus parent;
+
+  gchar extended_captions_language_code[13];
+  gchar *caption_kind;
+};
+
+struct _MXFDMS1Annotation {
+  MXFDMS1Thesaurus parent;
+
+  gchar *annotation_kind;
+  gchar *annotation_synopsis;
+  gchar *annotation_description;
+  gchar *related_material_description;
+
+  guint32 n_classification_sets;
+  MXFUL *classification_sets_uids;
+  MXFDMS1Classification **classification_sets;
+
+  MXFUL cue_words_set_uid;
+  MXFDMS1CueWords *cue_words_set;
+
+  guint32 n_related_material_locators;
+  MXFUL *related_material_locators;
+  /* TODO */
+  
+  guint32 n_participant_sets;
+  MXFUL *participant_sets_uids;
+  MXFDMS1Participant **participant_sets;
+};
+
+struct _MXFDMS1SettingPeriod {
+  MXFDMS1Thesaurus parent;
+
+  MXFTimestamp setting_date_and_time;
+  gchar *time_period_keyword;
+  gchar *setting_period_description;
+};
+
+struct _MXFDMS1Scripting {
+  MXFDMS1Thesaurus parent;
+
+  gchar *scripting_kind;
+  gchar *scripting_text;
+
+  guint32 n_scripting_locators;
+  MXFUL *scripting_locators;
+  /* TODO */
+};
+
+struct _MXFDMS1Classification {
+  MXFDMS1Thesaurus parent;
+
+  gchar content_classification[128];
+
+  guint32 n_name_value_sets;
+  MXFUL *name_value_sets_uids;
+  MXFDMS1NameValue **name_value_sets;
+};
+
+struct _MXFDMS1Shot {
+  MXFDMS1TextLanguage parent;
+
+  gint64 shot_start_position;
+  gint64 shot_duration;
+
+  guint32 n_shot_track_ids;
+  guint32 *shot_track_ids;
+  
+  gchar *shot_description;
+  gchar *shot_comment_kind;
+  gchar *shot_comment;
+
+  MXFUL cue_words_set_uid;
+  MXFDMS1CueWords *cue_words_set;
+
+  guint32 n_key_point_sets;
+  MXFUL *key_point_sets_uids;
+  MXFDMS1KeyPoint **key_point_sets;
+};
+
+struct _MXFDMS1KeyPoint {
+  MXFDMS1Thesaurus parent;
+
+  gchar *keypoint_kind;
+  gchar *keypoint_value;
+  gint64 keypoint_position;
+};
+
+struct _MXFDMS1Participant {
+  MXFDMS1Thesaurus parent;
+
+  MXFUL participant_uid;
+
+  gchar *contribution_status;
+  gchar *job_function;
+  gchar job_function_code[33];
+  gchar *role_or_identity_name;
+
+  guint32 n_person_sets;
+  MXFUL *person_sets_uids;
+  MXFDMS1Person **person_sets;
+
+  guint32 n_organisation_sets;
+  MXFUL *organisation_sets_uids;
+  MXFDMS1Organisation **organisation_sets;
+};
+
+struct _MXFDMS1Contact {
+  MXFDMS1Thesaurus parent;
+
+  MXFUL contact_uid;
+
+  guint32 n_name_value_sets;
+  MXFUL *name_value_sets_uids;
+  MXFDMS1NameValue **name_value_sets;
+
+  guint32 n_address_sets;
+  MXFUL *address_sets_uids;
+  MXFDMS1Address **address_sets;
+};
+
+struct _MXFDMS1Person {
+  MXFDMS1Contact parent;
+
+  gchar *family_name;
+  gchar *first_given_name;
+  gchar *other_given_names;
+  gchar *linking_name;
+  gchar *salutation;
+  gchar *name_suffix;
+  gchar *honours_qualifications;
+  gchar *former_family_name;
+  gchar *person_description;
+  gchar *alternate_name;
+  gchar *nationality;
+  gchar *citizenship;
+
+  guint32 n_organisation_sets;
+  MXFUL *organisation_sets_uids;
+  MXFDMS1Organisation **organisation_sets;
+};
+
+struct _MXFDMS1Organisation {
+  MXFDMS1Contact parent;
+
+  gchar *nature_of_organisation;
+  gchar *organisation_main_name;
+  gchar *organisation_code;
+  gchar *contact_department;
+};
+
+struct _MXFDMS1Location {
+  MXFDMS1Contact parent;
+
+  gchar *location_kind;
+  gchar *location_description;
+};
+
+struct _MXFDMS1Address {
+  MXFDMS1 parent;
+  
+  gchar *room_or_suite_number;
+  gchar *room_or_suite_name;
+  gchar *building_name;
+  gchar *place_name;
+  gchar *street_number;
+  gchar *street_name;
+  gchar *postal_town;
+  gchar *city;
+  gchar *state_or_province_or_country;
+  gchar *postal_code;
+  gchar *country;
+  guint8 geographical_coordinate[12];
+  gchar *astronomical_body_name;
+
+  guint32 n_communications_sets;
+  MXFUL *communications_sets_uids;
+  MXFDMS1Communications **communications_sets;
+
+  guint32 n_name_value_sets;
+  MXFUL *name_value_sets_uids;
+  MXFDMS1NameValue **name_value_sets;
+};
+
+struct _MXFDMS1Communications {
+  MXFDMS1 parent;
+
+  gchar central_telephone_number[33];
+  gchar telephone_number[33];
+  gchar mobile_telephone_number[33];
+  gchar fax_number[33];
+  gchar *email_address;
+  gchar *web_page;
+};
+
+struct _MXFDMS1Contract {
+  MXFDMS1Thesaurus parent;
+
+  gchar supply_contract_number[33];
+
+  guint32 n_rights_sets;
+  MXFUL *rights_sets_uids;
+  MXFDMS1Rights **rights_sets;
+
+  guint32 n_participant_sets;
+  MXFUL *participant_sets_uids;
+  MXFDMS1Participant **participant_sets;
+};
+
+struct _MXFDMS1Rights {
+  MXFDMS1Thesaurus parent;
+
+  gchar *copyright_owner;
+  gchar *rights_holder;
+  gchar *rights_managment_authority;
+  gchar *region_or_area_of_ip_license;
+  gchar *intellectual_property_type;
+  gchar *right_condition;
+  gchar *right_remarks;
+  gchar *intellectual_property_right;
+  MXFTimestamp rights_start_date_and_time;
+  MXFTimestamp rights_stop_date_and_time;
+  guint16 maximum_number_of_usages;
+};
+
+struct _MXFDMS1PictureFormat {
+  MXFDMS1 parent;
+
+  MXFFraction viewport_aspect_ratio;
+  gchar perceived_display_format[33];
+  gchar *colour_descriptor;
+};
+
+struct _MXFDMS1DeviceParameters {
+  MXFDMS1Thesaurus parent;
+
+  gchar *device_type;
+  gchar device_designation[33];
+  gchar device_asset_number[33];
+  guint8 ieee_device_identifier[6];
+  gchar *manufacturer;
+  gchar *device_model;
+  gchar *device_serial_number;
+  gchar *device_usage_description;
+
+  guint32 n_name_value_sets;
+  MXFUL *name_value_sets_uids;
+  MXFDMS1NameValue **name_value_sets;
+};
+
+struct _MXFDMS1NameValue {
+  MXFDMS1 parent;
+
+  gchar *item_name;
+  gchar *item_value;
+
+  MXFUL smpte_universal_label_locator;
+};
+
+struct _MXFDMS1Processing {
+  MXFDMS1 parent;
+
+  gboolean quality_flag;
+  gchar *descriptive_comment;
+  gboolean logo_flag;
+  gchar *graphic_usage_type;
+  guint16 process_steps;
+  guint16 generation_copy_number;
+  guint16 generation_clone_number;
+};
+
+struct _MXFDMS1Project {
+  MXFDMS1 parent;
+
+  gchar project_number[33];
+  gchar *project_name_or_title;
+};
+
+struct _MXFDMS1ContactsList {
+  MXFDMS1 parent;
+
+  guint32 n_person_sets;
+  MXFUL *person_sets_uids;
+  MXFDMS1Person **person_sets;
+
+  guint32 n_organisation_sets;
+  MXFUL *organisation_sets_uids;
+  MXFDMS1Organisation **organisation_sets;
+
+  guint32 n_location_sets;
+  MXFUL *location_sets_uids;
+  MXFDMS1Location **location_sets;
+};
+
+struct _MXFDMS1CueWords {
+  MXFDMS1TextLanguage parent;
+
+  gchar *in_cue_words;
+  gchar *out_cue_words;
+};
+
+void mxf_dms1_initialize (void);
+
+#endif /* _MXF_DMS1_H_ */
diff --git a/gst/mxf/mxfjpeg2000.c b/gst/mxf/mxfjpeg2000.c
index a08c426f..657777f0 100644
--- a/gst/mxf/mxfjpeg2000.c
+++ b/gst/mxf/mxfjpeg2000.c
@@ -106,10 +106,10 @@ mxf_jpeg2000_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
     if (!track->parent.descriptor[i])
       continue;
 
-    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
-            descriptor[i])) {
-      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
+    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
+      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
       f = track->parent.descriptor[i];
       break;
     } else if (MXF_IS_METADATA_FILE_DESCRIPTOR (track->parent.descriptor[i]) &&
diff --git a/gst/mxf/mxfmetadata.c b/gst/mxf/mxfmetadata.c
index 02f301a6..e0d6b5b1 100644
--- a/gst/mxf/mxfmetadata.c
+++ b/gst/mxf/mxfmetadata.c
@@ -114,10 +114,10 @@ mxf_metadata_base_resolve (MXFMetadataBase * self, MXFMetadataBase ** metadata)
 
   if (self->resolved == MXF_METADATA_BASE_RESOLVE_STATE_SUCCESS)
     return TRUE;
-  else if (self->resolved == MXF_METADATA_BASE_RESOLVE_STATE_FAILURE)
+  else if (self->resolved != MXF_METADATA_BASE_RESOLVE_STATE_NONE)
     return FALSE;
 
-  self->resolved = TRUE;
+  self->resolved = MXF_METADATA_BASE_RESOLVE_STATE_RUNNING;;
 
   klass = MXF_METADATA_BASE_GET_CLASS (self);
 
@@ -151,6 +151,13 @@ mxf_metadata_handle_tag (MXFMetadataBase * metadata, MXFPrimerPack * primer,
       GST_DEBUG ("  instance uid = %s",
           mxf_ul_to_string (&self->parent.instance_uid, str));
       break;
+    case 0x0102:
+      if (tag_size != 16)
+        goto error;
+      memcpy (&self->parent.generation_uid, tag_data, 16);
+      GST_DEBUG ("  generation uid = %s",
+          mxf_ul_to_string (&self->parent.generation_uid, str));
+      break;
     default:
       ret =
           MXF_METADATA_BASE_CLASS (mxf_metadata_parent_class)->handle_tag
@@ -327,13 +334,6 @@ mxf_metadata_preface_handle_tag (MXFMetadataBase * metadata,
   gboolean ret = TRUE;
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x3b02:
       if (!mxf_timestamp_parse (&self->last_modified_date, tag_data, tag_size))
         goto error;
@@ -701,13 +701,6 @@ mxf_metadata_content_storage_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x1901:{
       guint32 len;
       guint i;
@@ -867,13 +860,6 @@ mxf_metadata_essence_container_data_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x2701:
       if (tag_size != 32)
         goto error;
@@ -996,13 +982,6 @@ mxf_metadata_generic_package_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x4401:
       if (tag_size != 32)
         goto error;
@@ -1401,13 +1380,6 @@ mxf_metadata_track_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x4801:
       if (tag_size != 4)
         goto error;
@@ -1702,13 +1674,6 @@ mxf_metadata_sequence_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x0201:
       if (tag_size != 16)
         goto error;
@@ -1837,13 +1802,6 @@ mxf_metadata_structural_component_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x0201:
       if (tag_size != 16)
         goto error;
@@ -2249,10 +2207,10 @@ mxf_metadata_dm_segment_resolve (MXFMetadataBase * m,
   while (*p) {
     current = *p;
 
-    /* TODO: if (MXF_IS_DM_FRAMEWORK (current) && */
-    if (mxf_ul_is_equal (&current->instance_uid, &self->dm_framework_uid)) {
+    if (MXF_IS_DESCRIPTIVE_METADATA_FRAMEWORK (current)
+        && mxf_ul_is_equal (&current->instance_uid, &self->dm_framework_uid)) {
       if (mxf_metadata_base_resolve (current, metadata)) {
-        self->dm_framework = current;
+        self->dm_framework = MXF_DESCRIPTIVE_METADATA_FRAMEWORK (current);
       }
       break;
     }
@@ -2318,13 +2276,6 @@ mxf_metadata_generic_descriptor_handle_tag (MXFMetadataBase * metadata,
 #endif
 
   switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
     case 0x2f01:{
       guint32 len;
       guint i;
@@ -2681,8 +2632,8 @@ mxf_metadata_generic_picture_essence_descriptor_handle_tag (MXFMetadataBase *
     default:
       ret =
           MXF_METADATA_BASE_CLASS
-          (mxf_metadata_generic_picture_essence_descriptor_parent_class)->
-          handle_tag (metadata, primer, tag, tag_data, tag_size);
+          (mxf_metadata_generic_picture_essence_descriptor_parent_class)->handle_tag
+          (metadata, primer, tag, tag_data, tag_size);
       break;
   }
 
@@ -2835,8 +2786,8 @@ mxf_metadata_generic_sound_essence_descriptor_handle_tag (MXFMetadataBase *
     default:
       ret =
           MXF_METADATA_BASE_CLASS
-          (mxf_metadata_generic_sound_essence_descriptor_parent_class)->
-          handle_tag (metadata, primer, tag, tag_data, tag_size);
+          (mxf_metadata_generic_sound_essence_descriptor_parent_class)->handle_tag
+          (metadata, primer, tag, tag_data, tag_size);
       break;
   }
 
@@ -2970,8 +2921,8 @@ mxf_metadata_cdci_picture_essence_descriptor_handle_tag (MXFMetadataBase *
     default:
       ret =
           MXF_METADATA_BASE_CLASS
-          (mxf_metadata_cdci_picture_essence_descriptor_parent_class)->
-          handle_tag (metadata, primer, tag, tag_data, tag_size);
+          (mxf_metadata_cdci_picture_essence_descriptor_parent_class)->handle_tag
+          (metadata, primer, tag, tag_data, tag_size);
       break;
   }
 
@@ -3096,8 +3047,8 @@ mxf_metadata_rgba_picture_essence_descriptor_handle_tag (MXFMetadataBase *
     default:
       ret =
           MXF_METADATA_BASE_CLASS
-          (mxf_metadata_rgba_picture_essence_descriptor_parent_class)->
-          handle_tag (metadata, primer, tag, tag_data, tag_size);
+          (mxf_metadata_rgba_picture_essence_descriptor_parent_class)->handle_tag
+          (metadata, primer, tag, tag_data, tag_size);
       break;
   }
 
@@ -3160,8 +3111,8 @@ mxf_metadata_generic_data_essence_descriptor_handle_tag (MXFMetadataBase *
     default:
       ret =
           MXF_METADATA_BASE_CLASS
-          (mxf_metadata_generic_data_essence_descriptor_parent_class)->
-          handle_tag (metadata, primer, tag, tag_data, tag_size);
+          (mxf_metadata_generic_data_essence_descriptor_parent_class)->handle_tag
+          (metadata, primer, tag, tag_data, tag_size);
       break;
   }
 
@@ -3331,41 +3282,6 @@ mxf_metadata_multiple_descriptor_class_init (MXFMetadataMultipleDescriptorClass
 G_DEFINE_ABSTRACT_TYPE (MXFMetadataLocator, mxf_metadata_locator,
     MXF_TYPE_METADATA);
 
-static gboolean
-mxf_metadata_locator_handle_tag (MXFMetadataBase * metadata,
-    MXFPrimerPack * primer, guint16 tag, const guint8 * tag_data,
-    guint tag_size)
-{
-  MXFMetadataLocator *self = MXF_METADATA_LOCATOR (metadata);
-  gboolean ret = TRUE;
-#ifndef GST_DISABLE_GST_DEBUG
-  gchar str[48];
-#endif
-
-  switch (tag) {
-    case 0x0102:
-      if (tag_size != 16)
-        goto error;
-      memcpy (&self->generation_uid, tag_data, 16);
-      GST_DEBUG ("  generation uid = %s",
-          mxf_ul_to_string (&self->generation_uid, str));
-      break;
-    default:
-      ret =
-          MXF_METADATA_BASE_CLASS
-          (mxf_metadata_locator_parent_class)->handle_tag (metadata,
-          primer, tag, tag_data, tag_size);
-      break;
-  }
-
-  return ret;
-
-error:
-  GST_ERROR ("Invalid locator local tag 0x%04x of size %u", tag, tag_size);
-
-  return FALSE;
-}
-
 static void
 mxf_metadata_locator_init (MXFMetadataLocator * self)
 {
@@ -3374,9 +3290,6 @@ mxf_metadata_locator_init (MXFMetadataLocator * self)
 static void
 mxf_metadata_locator_class_init (MXFMetadataLocatorClass * klass)
 {
-  MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) klass;
-
-  metadata_base_class->handle_tag = mxf_metadata_locator_handle_tag;
 }
 
 G_DEFINE_TYPE (MXFMetadataTextLocator, mxf_metadata_text_locator,
@@ -3487,3 +3400,125 @@ mxf_metadata_network_locator_class_init (MXFMetadataNetworkLocatorClass * klass)
   miniobject_class->finalize = mxf_metadata_network_locator_finalize;
   metadata_base_class->handle_tag = mxf_metadata_network_locator_handle_tag;
 }
+
+G_DEFINE_ABSTRACT_TYPE (MXFDescriptiveMetadata, mxf_descriptive_metadata,
+    MXF_TYPE_METADATA_BASE);
+
+static void
+mxf_descriptive_metadata_init (MXFDescriptiveMetadata * self)
+{
+}
+
+static void
+mxf_descriptive_metadata_class_init (MXFDescriptiveMetadataClass * klass)
+{
+}
+
+typedef struct
+{
+  guint8 scheme;
+  GSList *sets;
+} _MXFDescriptiveMetadataScheme;
+
+static GSList *_dm_schemes = NULL;
+
+void
+mxf_descriptive_metadata_register (guint8 scheme, GSList * sets)
+{
+  _MXFDescriptiveMetadataScheme *s =
+      g_slice_new (_MXFDescriptiveMetadataScheme);
+
+  s->scheme = scheme;
+  s->sets = sets;
+  _dm_schemes = g_slist_prepend (_dm_schemes, s);
+}
+
+MXFDescriptiveMetadata *
+mxf_descriptive_metadata_new (guint8 scheme, guint32 type,
+    MXFPrimerPack * primer, const guint8 * data, guint size)
+{
+  GSList *l;
+  GType t = G_TYPE_INVALID;
+  _MXFDescriptiveMetadataScheme *s = NULL;
+  MXFDescriptiveMetadata *ret = NULL;
+
+  g_return_val_if_fail (type != 0, NULL);
+  g_return_val_if_fail (primer != NULL, NULL);
+
+  for (l = _dm_schemes; l; l = l->next) {
+    _MXFDescriptiveMetadataScheme *data = l->data;
+
+    if (data->scheme == scheme) {
+      s = data;
+      break;
+    }
+  }
+
+  if (s == NULL) {
+    GST_WARNING ("Descriptive metadata scheme 0x%02x not supported", scheme);
+    return NULL;
+  }
+
+  for (l = s->sets; l; l = l->next) {
+    MXFDescriptiveMetadataSet *set = l->data;
+
+    if (set->id == type) {
+      t = set->type;
+      break;
+    } else if (set->id == 0x000000) {
+      t = set->type;
+    }
+  }
+
+  if (t == G_TYPE_INVALID) {
+    GST_WARNING
+        ("No handler for type 0x%06x of descriptive metadata scheme 0x%02x found",
+        type, scheme);
+    return NULL;
+  }
+
+  ret = (MXFDescriptiveMetadata *) g_type_create_instance (t);
+  if (!mxf_metadata_base_parse (MXF_METADATA_BASE (ret), primer, data, size)) {
+    GST_ERROR ("Parsing metadata failed");
+    gst_mini_object_unref ((GstMiniObject *) ret);
+    return NULL;
+  }
+
+  ret->type = type;
+
+  return ret;
+}
+
+/* TODO: Remove this once we depend on GLib 2.14 */
+#if GLIB_CHECK_VERSION (2, 14, 0)
+#define __gst_once_init_enter(val) (g_once_init_enter (val))
+#define __gst_once_init_leave(val,newval) (g_once_init_leave (val, newval))
+#endif
+
+GType
+mxf_descriptive_metadata_framework_get_type (void)
+{
+  static volatile gsize type = 0;
+  if (__gst_once_init_enter (&type)) {
+    GType _type = 0;
+    static const GTypeInfo info = {
+      sizeof (MXFDescriptiveMetadataFrameworkInterface),
+      NULL,                     /* base_init */
+      NULL,                     /* base_finalize */
+      NULL,                     /* class_init */
+      NULL,                     /* class_finalize */
+      NULL,                     /* class_data */
+      0,                        /* instance_size */
+      0,                        /* n_preallocs */
+      NULL                      /* instance_init */
+    };
+    _type = g_type_register_static (G_TYPE_INTERFACE,
+        "MXFDescriptiveMetadataFrameworkInterface", &info, 0);
+
+    g_type_interface_add_prerequisite (_type, MXF_TYPE_DESCRIPTIVE_METADATA);
+
+    __gst_once_init_leave (&type, (gsize) _type);
+  }
+
+  return (GType) type;
+}
diff --git a/gst/mxf/mxfmetadata.h b/gst/mxf/mxfmetadata.h
index e5c455e8..5b6f12eb 100644
--- a/gst/mxf/mxfmetadata.h
+++ b/gst/mxf/mxfmetadata.h
@@ -333,16 +333,45 @@ typedef struct _MXFMetadataTextLocator MXFMetadataTextLocator;
 typedef MXFMetadataBaseClass MXFMetadataTextLocatorClass;
 GType mxf_metadata_text_locator_get_type (void);
 
+#define MXF_TYPE_DESCRIPTIVE_METADATA \
+  (mxf_descriptive_metadata_get_type())
+#define MXF_DESCRIPTIVE_METADATA(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),MXF_TYPE_DESCRIPTIVE_METADATA,MXFDescriptiveMetadata))
+#define MXF_IS_DESCRIPTIVE_METADATA(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),MXF_TYPE_DESCRIPTIVE_METADATA))
+#define MXF_DESCRIPTIVE_METADATA_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), MXF_TYPE_DESCRIPTIVE_METADATA, MXFDescriptiveMetadataClass))
+#define MXF_DESCRIPTIVE_METADATA_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),MXF_TYPE_DESCRIPTIVE_METADATA,MXFDescriptiveMetadataClass))
+typedef struct _MXFDescriptiveMetadata MXFDescriptiveMetadata;
+typedef struct _MXFDescriptiveMetadataClass MXFDescriptiveMetadataClass;
+GType mxf_descriptive_metadata_get_type (void);
+
+#define MXF_TYPE_DESCRIPTIVE_METADATA_FRAMEWORK \
+  (mxf_descriptive_metadata_framework_get_type ())
+#define MXF_DESCRIPTIVE_METADATA_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), MXF_TYPE_DESCRIPTIVE_METADATA_FRAMEWORK, MXFDescriptiveMetadataFramework))
+#define MXF_IS_DESCRIPTIVE_METADATA_FRAMEWORK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MXF_TYPE_DESCRIPTIVE_METADATA_FRAMEWORK))
+#define MXF_DESCRIPTIVE_METADATA_FRAMEWORK_GET_INTERFACE(inst) \
+  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), MXF_TYPE_DESCRIPTIVE_METADATA_FRAMEWORK, MXFDescriptiveMetadataFrameworkInterface))
+
+typedef struct _MXFDescriptiveMetadataFramework MXFDescriptiveMetadataFramework; /* dummy object */
+typedef struct _MXFDescriptiveMetadataFrameworkInterface MXFDescriptiveMetadataFrameworkInterface;
+GType mxf_descriptive_metadata_framework_get_type (void);
+
 typedef enum {
   MXF_METADATA_BASE_RESOLVE_STATE_NONE = 0,
   MXF_METADATA_BASE_RESOLVE_STATE_SUCCESS,
-  MXF_METADATA_BASE_RESOLVE_STATE_FAILURE
+  MXF_METADATA_BASE_RESOLVE_STATE_FAILURE,
+  MXF_METADATA_BASE_RESOLVE_STATE_RUNNING
 } MXFMetadataBaseResolveState;
 
 struct _MXFMetadataBase {
   GstMiniObject parent;
 
   MXFUL instance_uid;
+  MXFUL generation_uid;
 
   MXFMetadataBaseResolveState resolved;
 
@@ -365,8 +394,6 @@ struct _MXFMetadata {
 struct _MXFMetadataPreface {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   MXFTimestamp last_modified_date;
   guint16 version;
 
@@ -415,8 +442,6 @@ struct _MXFMetadataIdentification {
 struct _MXFMetadataContentStorage {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   guint32 n_packages;
   MXFUL *packages_uids;
   MXFMetadataGenericPackage **packages;
@@ -429,8 +454,6 @@ struct _MXFMetadataContentStorage {
 struct _MXFMetadataEssenceContainerData {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   MXFUMID linked_package_uid;
   MXFMetadataSourcePackage *linked_package;
 
@@ -441,8 +464,6 @@ struct _MXFMetadataEssenceContainerData {
 struct _MXFMetadataGenericPackage {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   MXFUMID package_uid;
 
   gchar *name;
@@ -486,8 +507,6 @@ typedef enum {
 struct _MXFMetadataTrack {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   guint32 track_id;
   guint32 track_number;
 
@@ -519,8 +538,6 @@ struct _MXFMetadataEventTrack {
 struct _MXFMetadataSequence {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   MXFUL data_definition;
 
   gint64 duration;
@@ -533,8 +550,6 @@ struct _MXFMetadataSequence {
 struct _MXFMetadataStructuralComponent {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   MXFUL data_definition;
   gint64 duration;
 };
@@ -574,14 +589,12 @@ struct _MXFMetadataDMSegment {
   guint32 *track_ids;
       
   MXFUL dm_framework_uid;
-  MXFMetadataBase *dm_framework;
+  MXFDescriptiveMetadataFramework *dm_framework;
 };
 
 struct _MXFMetadataGenericDescriptor {
   MXFMetadata parent;
 
-  MXFUL generation_uid;
-
   guint32 n_locators;
   MXFUL *locators_uids;
   MXFMetadataLocator **locators;
@@ -698,8 +711,6 @@ struct _MXFMetadataMultipleDescriptor {
 
 struct _MXFMetadataLocator {
   MXFMetadata parent;
-
-  MXFUL generation_uid;
 };
 
 struct _MXFMetadataNetworkLocator {
@@ -714,6 +725,25 @@ struct _MXFMetadataTextLocator {
   gchar *locator_name;
 };
 
+typedef struct {
+  guint32 id;
+  GType type;
+} MXFDescriptiveMetadataSet;
+
+struct _MXFDescriptiveMetadata {
+  MXFMetadataBase parent;
+
+  guint32 type;
+};
+
+struct _MXFDescriptiveMetadataClass {
+  MXFMetadataBase parent;
+};
+
+struct _MXFDescriptiveMetadataFrameworkInterface {
+  GTypeInterface parent;
+};
+
 gboolean mxf_metadata_base_parse (MXFMetadataBase *self, MXFPrimerPack *primer, const guint8 *data, guint size);
 gboolean mxf_metadata_base_resolve (MXFMetadataBase *self, MXFMetadataBase **metadata);
 
@@ -726,4 +756,7 @@ MXFMetadataTrackType mxf_metadata_track_identifier_parse (const MXFUL * track_id
 void mxf_metadata_generic_picture_essence_descriptor_set_caps (MXFMetadataGenericPictureEssenceDescriptor * self, GstCaps * caps);
 void mxf_metadata_generic_sound_essence_descriptor_set_caps (MXFMetadataGenericSoundEssenceDescriptor * self, GstCaps * caps);
 
+void mxf_descriptive_metadata_register (guint8 scheme, GSList *sets);
+MXFDescriptiveMetadata * mxf_descriptive_metadata_new (guint8 scheme, guint32 type, MXFPrimerPack * primer, const guint8 * data, guint size);
+
 #endif /* __MXF_METADATA_H__ */
diff --git a/gst/mxf/mxfmpeg.c b/gst/mxf/mxfmpeg.c
index 574cc5a8..e95719d2 100644
--- a/gst/mxf/mxfmpeg.c
+++ b/gst/mxf/mxfmpeg.c
@@ -478,17 +478,17 @@ mxf_mpeg_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
     if (!track->parent.descriptor[i])
       continue;
 
-    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
-            descriptor[i])) {
+    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
       f = track->parent.descriptor[i];
-      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
+      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
       break;
-    } else if (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (track->parent.
-            descriptor[i])) {
+    } else if (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
       f = track->parent.descriptor[i];
-      s = (MXFMetadataGenericSoundEssenceDescriptor *) track->
-          parent.descriptor[i];
+      s = (MXFMetadataGenericSoundEssenceDescriptor *) track->parent.
+          descriptor[i];
       break;
     }
   }
diff --git a/gst/mxf/mxfup.c b/gst/mxf/mxfup.c
index afd8e2a1..8155d8d2 100644
--- a/gst/mxf/mxfup.c
+++ b/gst/mxf/mxfup.c
@@ -222,19 +222,19 @@ mxf_up_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
     if (!track->parent.descriptor[i])
       continue;
 
-    if (MXF_IS_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR (track->
-            parent.descriptor[i])) {
-      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
-      r = (MXFMetadataRGBAPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
-      break;
-    } else if (MXF_IS_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
+    if (MXF_IS_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
             descriptor[i])) {
-      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
-      c = (MXFMetadataCDCIPictureEssenceDescriptor *) track->
-          parent.descriptor[i];
+      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
+      r = (MXFMetadataRGBAPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
+      break;
+    } else if (MXF_IS_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR (track->
+            parent.descriptor[i])) {
+      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
+      c = (MXFMetadataCDCIPictureEssenceDescriptor *) track->parent.
+          descriptor[i];
     }
   }
 
diff --git a/gst/mxf/mxfvc3.c b/gst/mxf/mxfvc3.c
index 1fcb2d7e..398bcc58 100644
--- a/gst/mxf/mxfvc3.c
+++ b/gst/mxf/mxfvc3.c
@@ -100,10 +100,10 @@ mxf_vc3_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
     if (!track->parent.descriptor[i])
       continue;
 
-    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->
-            parent.descriptor[i])) {
-      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
-          descriptor[i];
+    if (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
+            descriptor[i])) {
+      p = (MXFMetadataGenericPictureEssenceDescriptor *) track->
+          parent.descriptor[i];
       f = track->parent.descriptor[i];
       break;
     } else if (MXF_IS_METADATA_FILE_DESCRIPTOR (track->parent.descriptor[i]) &&