Merge branch 'mxfmux'

1 files changed, 2293 insertions, 3 deletions

diff --git a/gst/mxf/mxfmetadata.c b/gst/mxf/mxfmetadata.c
index cc53ec15..07c18b0f 100644
--- a/gst/mxf/mxfmetadata.c
+++ b/gst/mxf/mxfmetadata.c
@@ -27,6 +27,7 @@
 #include "mxfparse.h"
 #include "mxfmetadata.h"
 #include "mxfquark.h"
+#include "mxfwrite.h"
 
 GST_DEBUG_CATEGORY_EXTERN (mxf_debug);
 #define GST_CAT_DEFAULT mxf_debug
@@ -238,6 +239,115 @@ mxf_metadata_base_to_structure (MXFMetadataBase * self)
   return NULL;
 }
 
+GstBuffer *
+mxf_metadata_base_to_buffer (MXFMetadataBase * self, MXFPrimerPack * primer)
+{
+  MXFMetadataBaseClass *klass;
+  GstBuffer *ret;
+  GList *tags, *l;
+  guint size = 0, slen;
+  guint8 ber[9];
+  MXFLocalTag *t, *last;
+  guint8 *data;
+
+  g_return_val_if_fail (MXF_IS_METADATA_BASE (self), NULL);
+  g_return_val_if_fail (primer != NULL, NULL);
+
+  klass = MXF_METADATA_BASE_GET_CLASS (self);
+  g_return_val_if_fail (klass->write_tags, NULL);
+
+  tags = klass->write_tags (self, primer);
+  g_return_val_if_fail (tags != NULL, NULL);
+
+  /* Add unknown tags */
+  if (self->other_tags) {
+    MXFLocalTag *tmp;
+#if GLIB_CHECK_VERSION (2, 16, 0)
+    GHashTableIter iter;
+
+    g_hash_table_iter_init (&iter, self->other_tags);
+#else
+    GList *l, *values;
+
+    values = g_hash_table_get_values (self->other_tags);
+#endif
+
+#if GLIB_CHECK_VERSION (2, 16, 0)
+    while (g_hash_table_iter_next (&iter, NULL, (gpointer) & t)) {
+#else
+    for (l = values; l; l = l->next) {
+      t = l->data;
+#endif
+      tmp = g_slice_dup (MXFLocalTag, t);
+      if (t->g_slice) {
+        tmp->data = g_slice_alloc (t->size);
+        mxf_primer_pack_add_mapping (primer, 0x0000, &t->key);
+        memcpy (tmp->data, t->data, t->size);
+      } else {
+        tmp->data = g_memdup (t->data, t->size);
+      }
+      tags = g_list_prepend (tags, tmp);
+    }
+
+#if !GLIB_CHECK_VERSION (2, 16, 0)
+    g_list_free (values);
+#endif
+  }
+
+  l = g_list_last (tags);
+  last = l->data;
+  tags = g_list_delete_link (tags, l);
+  /* Last element contains the metadata UL */
+  g_return_val_if_fail (last->size == 0, NULL);
+
+  for (l = tags; l; l = l->next) {
+    t = l->data;
+    g_assert (G_MAXUINT - t->size >= size);
+    size += 4 + t->size;
+  }
+
+  slen = mxf_ber_encode_size (size, ber);
+  size += 16 + slen;
+
+  ret = gst_buffer_new_and_alloc (size);
+
+  memcpy (GST_BUFFER_DATA (ret), &last->key, 16);
+  mxf_local_tag_free (last);
+  last = NULL;
+  memcpy (GST_BUFFER_DATA (ret) + 16, ber, slen);
+
+  data = GST_BUFFER_DATA (ret) + 16 + slen;
+  size -= 16 + slen;
+
+  for (l = tags; l; l = l->next) {
+    guint16 local_tag;
+
+    g_assert (size >= 4);
+    t = l->data;
+
+    local_tag =
+        GPOINTER_TO_UINT (g_hash_table_lookup (primer->reverse_mappings,
+            &t->key));
+    g_assert (local_tag != 0);
+
+    GST_WRITE_UINT16_BE (data, local_tag);
+    GST_WRITE_UINT16_BE (data + 2, t->size);
+    data += 4;
+    size -= 4;
+    g_assert (size >= t->size);
+
+    memcpy (data, t->data, t->size);
+    data += t->size;
+    size -= t->size;
+
+    mxf_local_tag_free (t);
+  }
+
+  g_list_free (tags);
+
+  return ret;
+}
+
 G_DEFINE_ABSTRACT_TYPE (MXFMetadata, mxf_metadata, MXF_TYPE_METADATA_BASE);
 
 static gboolean
@@ -281,12 +391,65 @@ error:
   return FALSE;
 }
 
+static GList *
+mxf_metadata_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
+{
+  MXFMetadata *self = MXF_METADATA (m);
+  GList *ret = NULL;
+  MXFLocalTag *t;
+  MXFMetadataClass *klass;
+  static const guint8 metadata_key[] = {
+    0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01,
+    0x0d, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+  };
+  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, 0x01, 0x00, 0x00, 0x00
+  };
+
+  g_return_val_if_fail (MXF_IS_METADATA (self), NULL);
+  klass = MXF_METADATA_GET_CLASS (self);
+
+  /* Last element contains the metadata key */
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, metadata_key, 16);
+  GST_WRITE_UINT16_BE (&t->key.u[13], klass->type);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &instance_uid_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (16);
+  t->g_slice = TRUE;
+  memcpy (t->data, &self->parent.instance_uid, 16);
+  mxf_primer_pack_add_mapping (primer, 0x3c0a, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (!mxf_ul_is_zero (&self->parent.generation_uid)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &generation_uid_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (16);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->parent.generation_uid, 16);
+    mxf_primer_pack_add_mapping (primer, 0x0102, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_class_init (MXFMetadataClass * klass)
 {
   MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) klass;
 
   metadata_base_class->handle_tag = mxf_metadata_handle_tag;
+  metadata_base_class->write_tags = mxf_metadata_write_tags;
 }
 
 static void
@@ -712,6 +875,159 @@ mxf_metadata_preface_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_preface_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
+{
+  MXFMetadataPreface *self = MXF_METADATA_PREFACE (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS (mxf_metadata_preface_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  guint i;
+  static const guint8 last_modified_date_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x10, 0x02, 0x04, 0x00, 0x00
+  };
+  static const guint8 version_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x03, 0x01, 0x02, 0x01, 0x05, 0x00, 0x00, 0x00
+  };
+  static const guint8 object_model_version_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x03, 0x01, 0x02, 0x01, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 primary_package_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x06, 0x01, 0x01, 0x04, 0x01, 0x08, 0x00, 0x00
+  };
+  static const guint8 identifications_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x06, 0x04, 0x00, 0x00
+  };
+  static const guint8 content_storage_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x02, 0x01, 0x00, 0x00
+  };
+  static const guint8 operational_pattern_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x01, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 essence_containers_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x01, 0x02, 0x02, 0x10, 0x02, 0x01, 0x00, 0x00
+  };
+  static const guint8 dm_schemes_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x01, 0x02, 0x02, 0x10, 0x02, 0x02, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &last_modified_date_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (8);
+  t->g_slice = TRUE;
+  mxf_timestamp_write (&self->last_modified_date, t->data);
+  mxf_primer_pack_add_mapping (primer, 0x3b02, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &version_ul, 16);
+  t->size = 2;
+  t->data = g_slice_alloc (2);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT16_BE (t->data, self->version);
+  mxf_primer_pack_add_mapping (primer, 0x3b05, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->object_model_version) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &object_model_version_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (4);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->object_model_version);
+    mxf_primer_pack_add_mapping (primer, 0x3b07, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_ul_is_zero (&self->primary_package_uid)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &primary_package_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (16);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->primary_package_uid, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3b08, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &identifications_ul, 16);
+  t->size = 8 + 16 * self->n_identifications;
+  t->data = g_slice_alloc0 (t->size);
+  t->g_slice = TRUE;
+  mxf_primer_pack_add_mapping (primer, 0x3b06, &t->key);
+  GST_WRITE_UINT32_BE (t->data, self->n_identifications);
+  GST_WRITE_UINT32_BE (t->data + 4, 16);
+  for (i = 0; i < self->n_identifications; i++) {
+    if (!self->identifications[i])
+      continue;
+
+    memcpy (t->data + 8 + 16 * i,
+        &MXF_METADATA_BASE (self->identifications[i])->instance_uid, 16);
+  }
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &content_storage_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  mxf_primer_pack_add_mapping (primer, 0x3b03, &t->key);
+  memcpy (t->data, &MXF_METADATA_BASE (self->content_storage)->instance_uid,
+      16);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &operational_pattern_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  mxf_primer_pack_add_mapping (primer, 0x3b09, &t->key);
+  memcpy (t->data, &self->operational_pattern, 16);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &essence_containers_ul, 16);
+  t->size = 8 + 16 * self->n_essence_containers;
+  t->data = g_slice_alloc0 (t->size);
+  t->g_slice = TRUE;
+  mxf_primer_pack_add_mapping (primer, 0x3b0a, &t->key);
+  GST_WRITE_UINT32_BE (t->data, self->n_essence_containers);
+  GST_WRITE_UINT32_BE (t->data + 4, 16);
+  for (i = 0; i < self->n_essence_containers; i++) {
+    memcpy (t->data + 8 + 16 * i, &self->essence_containers[i], 16);
+  }
+  ret = g_list_prepend (ret, t);
+
+  if (self->dm_schemes) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &dm_schemes_ul, 16);
+    t->size = 8 + 16 * self->n_dm_schemes;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    mxf_primer_pack_add_mapping (primer, 0x3b0b, &t->key);
+    GST_WRITE_UINT32_BE (t->data, self->n_dm_schemes);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_dm_schemes; i++) {
+      memcpy (t->data + 8 + 16 * i, &self->dm_schemes[i], 16);
+    }
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_preface_init (MXFMetadataPreface * self)
 {
@@ -729,6 +1045,7 @@ mxf_metadata_preface_class_init (MXFMetadataPrefaceClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_preface_handle_tag;
   metadata_base_class->resolve = mxf_metadata_preface_resolve;
   metadata_base_class->to_structure = mxf_metadata_preface_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_preface_write_tags;
   metadata_base_class->name_quark = MXF_QUARK (PREFACE);
   metadata_class->type = 0x012f;
 }
@@ -912,6 +1229,127 @@ mxf_metadata_identification_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_identification_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataIdentification *self = MXF_METADATA_IDENTIFICATION (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_identification_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 company_name_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00
+  };
+  static const guint8 product_name_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x03, 0x01, 0x00, 0x00
+  };
+  static const guint8 product_version_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 version_string_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x05, 0x01, 0x00, 0x00
+  };
+  static const guint8 product_uid_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x07, 0x00, 0x00, 0x00
+  };
+  static const guint8 modification_date_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x10, 0x02, 0x03, 0x00, 0x00
+  };
+  static const guint8 toolkit_version_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x0A, 0x00, 0x00, 0x00
+  };
+  static const guint8 platform_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x07, 0x01, 0x06, 0x01, 0x00, 0x00
+  };
+
+  if (self->company_name) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &company_name_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->company_name, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x3c01, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->product_name) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &product_name_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->product_name, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x3c02, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_product_version_is_valid (&self->product_version)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &product_version_ul, 16);
+    t->size = 10;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    mxf_product_version_write (&self->product_version, t->data);
+    mxf_primer_pack_add_mapping (primer, 0x3c03, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->version_string) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &version_string_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->version_string, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x3c04, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_ul_is_zero (&self->product_uid)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &product_uid_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->product_uid, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3c05, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_timestamp_is_unknown (&self->modification_date)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &modification_date_ul, 16);
+    t->size = 8;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    mxf_timestamp_write (&self->modification_date, t->data);
+    mxf_primer_pack_add_mapping (primer, 0x3c06, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_product_version_is_valid (&self->toolkit_version)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &toolkit_version_ul, 16);
+    t->size = 10;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    mxf_product_version_write (&self->toolkit_version, t->data);
+    mxf_primer_pack_add_mapping (primer, 0x3c07, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->platform) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &platform_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->platform, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x3c08, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_identification_init (MXFMetadataIdentification * self)
 {
@@ -929,6 +1367,7 @@ mxf_metadata_identification_class_init (MXFMetadataIdentificationClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_identification_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (IDENTIFICATION);
   metadata_base_class->to_structure = mxf_metadata_identification_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_identification_write_tags;
   metadata_class->type = 0x0130;
 }
 
@@ -1151,6 +1590,69 @@ mxf_metadata_content_storage_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_content_storage_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataContentStorage *self = MXF_METADATA_CONTENT_STORAGE (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_content_storage_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  guint i;
+  static const guint8 packages_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x05, 0x01, 0x00, 0x00
+  };
+  static const guint8 essence_container_data_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x05, 0x02, 0x00, 0x00
+  };
+
+  if (self->packages) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &packages_ul, 16);
+    t->size = 8 + 16 * self->n_packages;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_packages);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_packages; i++) {
+      if (!self->packages[i])
+        continue;
+
+      memcpy (t->data + 8 + i * 16,
+          &MXF_METADATA_BASE (self->packages[i])->instance_uid, 16);
+    }
+
+    mxf_primer_pack_add_mapping (primer, 0x1901, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->essence_container_data) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &essence_container_data_ul, 16);
+    t->size = 8 + 16 * self->n_essence_container_data;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_essence_container_data);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_essence_container_data; i++) {
+      if (!self->essence_container_data[i])
+        continue;
+
+      memcpy (t->data + 8 + i * 16,
+          &MXF_METADATA_BASE (self->essence_container_data[i])->instance_uid,
+          16);
+    }
+
+    mxf_primer_pack_add_mapping (primer, 0x1902, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_content_storage_init (MXFMetadataContentStorage * self)
 {
@@ -1169,6 +1671,7 @@ mxf_metadata_content_storage_class_init (MXFMetadataContentStorageClass * klass)
   metadata_base_class->resolve = mxf_metadata_content_storage_resolve;
   metadata_base_class->name_quark = MXF_QUARK (CONTENT_STORAGE);
   metadata_base_class->to_structure = mxf_metadata_content_storage_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_content_storage_write_tags;
   metadata_class->type = 0x0118;
 }
 
@@ -1298,6 +1801,63 @@ mxf_metadata_essence_container_data_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_essence_container_data_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataEssenceContainerData *self =
+      MXF_METADATA_ESSENCE_CONTAINER_DATA (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_essence_container_data_parent_class)->write_tags (m,
+      primer);
+  MXFLocalTag *t;
+  static const guint8 linked_package_uid_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 body_sid_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x01, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 index_sid_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x01, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &linked_package_uid_ul, 16);
+  t->size = 32;
+  t->data = g_slice_alloc0 (32);
+  t->g_slice = TRUE;
+  if (self->linked_package)
+    memcpy (t->data, &self->linked_package->parent.package_uid, 32);
+  mxf_primer_pack_add_mapping (primer, 0x2701, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &body_sid_ul, 16);
+  t->size = 4;
+  t->data = g_slice_alloc (4);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->body_sid);
+  mxf_primer_pack_add_mapping (primer, 0x3f07, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->index_sid) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &index_sid_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (4);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->index_sid);
+    mxf_primer_pack_add_mapping (primer, 0x3f07, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_essence_container_data_init (MXFMetadataEssenceContainerData *
     self)
@@ -1318,6 +1878,8 @@ static void
   metadata_base_class->name_quark = MXF_QUARK (ESSENCE_CONTAINER_DATA);
   metadata_base_class->to_structure =
       mxf_metadata_essence_container_data_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_essence_container_data_write_tags;
   metadata_class->type = 0x0123;
 }
 
@@ -1518,6 +2080,95 @@ mxf_metadata_generic_package_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_generic_package_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataGenericPackage *self = MXF_METADATA_GENERIC_PACKAGE (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_generic_package_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 package_uid_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x15, 0x10, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 name_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x03, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 package_creation_date_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x10, 0x01, 0x03, 0x00, 0x00
+  };
+  static const guint8 package_modified_date_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x10, 0x02, 0x05, 0x00, 0x00
+  };
+  static const guint8 tracks_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x06, 0x05, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &package_uid_ul, 16);
+  t->size = 32;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  memcpy (t->data, &self->package_uid, 32);
+  mxf_primer_pack_add_mapping (primer, 0x4401, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->name) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &name_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->name, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x4402, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &package_creation_date_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  mxf_timestamp_write (&self->package_creation_date, t->data);
+  mxf_primer_pack_add_mapping (primer, 0x4405, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &package_modified_date_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  mxf_timestamp_write (&self->package_modified_date, t->data);
+  mxf_primer_pack_add_mapping (primer, 0x4404, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->tracks) {
+    guint i;
+
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &tracks_ul, 16);
+    t->size = 8 + 16 * self->n_tracks;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_tracks);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_tracks; i++) {
+      if (!self->tracks[i])
+        continue;
+
+      memcpy (t->data + 8 + 16 * i,
+          &MXF_METADATA_BASE (self->tracks[i])->instance_uid, 16);
+    }
+    mxf_primer_pack_add_mapping (primer, 0x4403, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_generic_package_init (MXFMetadataGenericPackage * self)
 {
@@ -1534,6 +2185,7 @@ mxf_metadata_generic_package_class_init (MXFMetadataGenericPackageClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_generic_package_handle_tag;
   metadata_base_class->resolve = mxf_metadata_generic_package_resolve;
   metadata_base_class->to_structure = mxf_metadata_generic_package_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_generic_package_write_tags;
 }
 
 G_DEFINE_TYPE (MXFMetadataMaterialPackage, mxf_metadata_material_package,
@@ -1802,6 +2454,34 @@ mxf_metadata_source_package_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_source_package_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataSourcePackage *self = MXF_METADATA_SOURCE_PACKAGE (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_source_package_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 descriptor_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x02, 0x03, 0x00, 0x00
+  };
+
+  if (self->descriptor) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &descriptor_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &MXF_METADATA_BASE (self->descriptor)->instance_uid, 16);
+    mxf_primer_pack_add_mapping (primer, 0x4701, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_source_package_init (MXFMetadataSourcePackage * self)
 {
@@ -1818,6 +2498,7 @@ mxf_metadata_source_package_class_init (MXFMetadataSourcePackageClass * klass)
   metadata_base_class->resolve = mxf_metadata_source_package_resolve;
   metadata_base_class->name_quark = MXF_QUARK (SOURCE_PACKAGE);
   metadata_base_class->to_structure = mxf_metadata_source_package_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_source_package_write_tags;
   metadata_class->type = 0x0137;
 }
 
@@ -1959,6 +2640,69 @@ mxf_metadata_track_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_track_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
+{
+  MXFMetadataTrack *self = MXF_METADATA_TRACK (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS (mxf_metadata_track_parent_class)->write_tags (m,
+      primer);
+  MXFLocalTag *t;
+  static const guint8 track_id_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x01, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 track_number_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x01, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 track_name_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x01, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 sequence_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x02, 0x04, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &track_id_ul, 16);
+  t->size = 4;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->track_id);
+  mxf_primer_pack_add_mapping (primer, 0x4801, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &track_number_ul, 16);
+  t->size = 4;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->track_number);
+  mxf_primer_pack_add_mapping (primer, 0x4804, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->track_name) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &track_name_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->track_name, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x4802, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &sequence_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  memcpy (t->data, &MXF_METADATA_BASE (self->sequence)->instance_uid, 16);
+  mxf_primer_pack_add_mapping (primer, 0x4803, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  return ret;
+}
+
 static void
 mxf_metadata_track_init (MXFMetadataTrack * self)
 {
@@ -1975,6 +2719,7 @@ mxf_metadata_track_class_init (MXFMetadataTrackClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_track_handle_tag;
   metadata_base_class->resolve = mxf_metadata_track_resolve;
   metadata_base_class->to_structure = mxf_metadata_track_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_track_write_tags;
 }
 
 /* SMPTE RP224 */
@@ -2022,6 +2767,18 @@ mxf_metadata_track_identifier_parse (const MXFUL * track_identifier)
   return MXF_METADATA_TRACK_UNKNOWN;
 }
 
+const MXFUL *
+mxf_metadata_track_identifier_get (MXFMetadataTrackType type)
+{
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS (mxf_metadata_track_identifier); i++)
+    if (mxf_metadata_track_identifier[i].type == type)
+      return (const MXFUL *) &mxf_metadata_track_identifier[i].ul;
+
+  return NULL;
+}
+
 G_DEFINE_TYPE (MXFMetadataTimelineTrack, mxf_metadata_timeline_track,
     MXF_TYPE_METADATA_TRACK);
 
@@ -2078,6 +2835,46 @@ mxf_metadata_timeline_track_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_timeline_track_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataTimelineTrack *self = MXF_METADATA_TIMELINE_TRACK (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_timeline_track_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 edit_rate_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x30, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 origin_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x03, 0x01, 0x03, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &edit_rate_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->edit_rate.n);
+  GST_WRITE_UINT32_BE (t->data + 4, self->edit_rate.d);
+  mxf_primer_pack_add_mapping (primer, 0x4b01, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &origin_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT64_BE (t->data, self->origin);
+  mxf_primer_pack_add_mapping (primer, 0x4b02, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  return ret;
+}
+
 static void
 mxf_metadata_timeline_track_init (MXFMetadataTimelineTrack * self)
 {
@@ -2093,6 +2890,7 @@ mxf_metadata_timeline_track_class_init (MXFMetadataTimelineTrackClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_timeline_track_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (TIMELINE_TRACK);
   metadata_base_class->to_structure = mxf_metadata_timeline_track_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_timeline_track_write_tags;
   metadata_class->type = 0x013b;
 }
 
@@ -2152,6 +2950,46 @@ mxf_metadata_event_track_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_event_track_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataEventTrack *self = MXF_METADATA_EVENT_TRACK (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_event_track_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 event_edit_rate_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x30, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 event_origin_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x07, 0x02, 0x01, 0x03, 0x01, 0x0B, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &event_edit_rate_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->event_edit_rate.n);
+  GST_WRITE_UINT32_BE (t->data + 4, self->event_edit_rate.d);
+  mxf_primer_pack_add_mapping (primer, 0x4901, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &event_origin_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT64_BE (t->data, self->event_origin);
+  mxf_primer_pack_add_mapping (primer, 0x4902, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  return ret;
+}
+
 static void
 mxf_metadata_event_track_init (MXFMetadataEventTrack * self)
 {
@@ -2167,6 +3005,7 @@ mxf_metadata_event_track_class_init (MXFMetadataEventTrackClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_event_track_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (EVENT_TRACK);
   metadata_base_class->to_structure = mxf_metadata_event_track_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_event_track_write_tags;
   metadata_class->type = 0x0139;
 }
 
@@ -2345,6 +3184,71 @@ mxf_metadata_sequence_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_sequence_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
+{
+  MXFMetadataSequence *self = MXF_METADATA_SEQUENCE (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS (mxf_metadata_sequence_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 data_definition_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 duration_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00
+  };
+  static const guint8 structural_components_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x06, 0x09, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &data_definition_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  memcpy (t->data, &self->data_definition, 16);
+  mxf_primer_pack_add_mapping (primer, 0x0201, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &duration_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT64_BE (t->data, self->duration);
+  mxf_primer_pack_add_mapping (primer, 0x0202, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->structural_components) {
+    guint i;
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &structural_components_ul, 16);
+    t->size = 8 + 16 * self->n_structural_components;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+
+    GST_WRITE_UINT32_BE (t->data, self->n_structural_components);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_structural_components; i++) {
+      if (!self->structural_components[i])
+        continue;
+
+      memcpy (t->data + 8 + i * 16,
+          &MXF_METADATA_BASE (self->structural_components[i])->instance_uid,
+          16);
+    }
+
+    mxf_primer_pack_add_mapping (primer, 0x1001, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_sequence_init (MXFMetadataSequence * self)
 {
@@ -2363,6 +3267,7 @@ mxf_metadata_sequence_class_init (MXFMetadataSequenceClass * klass)
   metadata_base_class->resolve = mxf_metadata_sequence_resolve;
   metadata_base_class->name_quark = MXF_QUARK (SEQUENCE);
   metadata_base_class->to_structure = mxf_metadata_sequence_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_sequence_write_tags;
   metadata_class->type = 0x010f;
 }
 
@@ -2429,6 +3334,45 @@ mxf_metadata_structural_component_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_structural_component_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataStructuralComponent *self = MXF_METADATA_STRUCTURAL_COMPONENT (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_structural_component_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 data_definition_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 duration_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &data_definition_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  memcpy (t->data, &self->data_definition, 16);
+  mxf_primer_pack_add_mapping (primer, 0x0201, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &duration_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT64_BE (t->data, self->duration);
+  mxf_primer_pack_add_mapping (primer, 0x0202, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  return ret;
+}
+
 static void
 mxf_metadata_structural_component_init (MXFMetadataStructuralComponent * self)
 {
@@ -2445,6 +3389,8 @@ static void
       mxf_metadata_structural_component_handle_tag;
   metadata_base_class->to_structure =
       mxf_metadata_structural_component_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_structural_component_write_tags;
 }
 
 G_DEFINE_TYPE (MXFMetadataTimecodeComponent, mxf_metadata_timecode_component,
@@ -2512,6 +3458,58 @@ mxf_metadata_timecode_component_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_timecode_component_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataTimecodeComponent *self = MXF_METADATA_TIMECODE_COMPONENT (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_timecode_component_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 rounded_timecode_base_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x04, 0x01, 0x01, 0x02, 0x06, 0x00, 0x00
+  };
+  static const guint8 start_timecode_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x03, 0x01, 0x05, 0x00, 0x00
+  };
+  static const guint8 drop_frame_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x04, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &rounded_timecode_base_ul, 16);
+  t->size = 2;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT16_BE (t->data, self->rounded_timecode_base);
+  mxf_primer_pack_add_mapping (primer, 0x1502, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &start_timecode_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT64_BE (t->data, self->start_timecode);
+  mxf_primer_pack_add_mapping (primer, 0x1501, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &drop_frame_ul, 16);
+  t->size = 1;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT8 (t->data, (self->drop_frame) ? 1 : 0);
+  mxf_primer_pack_add_mapping (primer, 0x1503, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  return ret;
+}
+
 static void
 mxf_metadata_timecode_component_init (MXFMetadataTimecodeComponent * self)
 {
@@ -2529,6 +3527,7 @@ mxf_metadata_timecode_component_class_init (MXFMetadataTimecodeComponentClass *
   metadata_base_class->name_quark = MXF_QUARK (TIMECODE_COMPONENT);
   metadata_base_class->to_structure =
       mxf_metadata_timecode_component_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_timecode_component_write_tags;
   metadata_class->type = 0x0114;
 }
 
@@ -2643,6 +3642,57 @@ mxf_metadata_source_clip_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_source_clip_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataSourceClip *self = MXF_METADATA_SOURCE_CLIP (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_source_clip_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 start_position_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00
+  };
+  static const guint8 source_package_id_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 source_track_id_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x03, 0x02, 0x00, 0x00, 0x00
+  };
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &start_position_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT64_BE (t->data, self->start_position);
+  mxf_primer_pack_add_mapping (primer, 0x1201, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &source_package_id_ul, 16);
+  t->size = 32;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  memcpy (t->data, &self->source_package_id, 32);
+  mxf_primer_pack_add_mapping (primer, 0x1101, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &source_track_id_ul, 16);
+  t->size = 4;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->source_track_id);
+  mxf_primer_pack_add_mapping (primer, 0x1102, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  return ret;
+}
 
 static void
 mxf_metadata_source_clip_init (MXFMetadataSourceClip * self)
@@ -2660,6 +3710,7 @@ mxf_metadata_source_clip_class_init (MXFMetadataSourceClipClass * klass)
   metadata_base_class->resolve = mxf_metadata_source_clip_resolve;
   metadata_base_class->name_quark = MXF_QUARK (SOURCE_CLIP);
   metadata_base_class->to_structure = mxf_metadata_source_clip_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_source_clip_write_tags;
   metadata_class->type = 0x0111;
 }
 
@@ -2771,6 +3822,39 @@ mxf_metadata_dm_source_clip_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_dm_source_clip_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataDMSourceClip *self = MXF_METADATA_DM_SOURCE_CLIP (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_dm_source_clip_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 track_ids_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x01, 0x07, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00
+  };
+
+  if (self->track_ids) {
+    guint i;
+
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &track_ids_ul, 16);
+    t->size = 8 + 4 * self->n_track_ids;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_track_ids);
+    GST_WRITE_UINT32_BE (t->data + 4, 4);
+    for (i = 0; i < self->n_track_ids; i++)
+      GST_WRITE_UINT32_BE (t->data + 8 + i * 4, self->track_ids[i]);
+    mxf_primer_pack_add_mapping (primer, 0x6103, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_dm_source_clip_init (MXFMetadataDMSourceClip * self)
 {
@@ -2788,6 +3872,7 @@ mxf_metadata_dm_source_clip_class_init (MXFMetadataDMSourceClipClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_dm_source_clip_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (DM_SOURCE_CLIP);
   metadata_base_class->to_structure = mxf_metadata_dm_source_clip_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_dm_source_clip_write_tags;
   metadata_class->type = 0x0145;
 }
 
@@ -2965,10 +4050,84 @@ mxf_metadata_dm_segment_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_dm_segment_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
+{
+  MXFMetadataDMSegment *self = MXF_METADATA_DM_SEGMENT (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS (mxf_metadata_dm_segment_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 event_start_position_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x07, 0x02, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00
+  };
+  static const guint8 event_comment_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x30, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 track_ids_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x01, 0x07, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 dm_framework_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x06, 0x01, 0x01, 0x04, 0x02, 0x0C, 0x00, 0x00
+  };
+
+  if (self->event_start_position != -1) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &event_start_position_ul, 16);
+    t->size = 8;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT64_BE (t->data, self->event_start_position);
+    mxf_primer_pack_add_mapping (primer, 0x0601, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->event_comment) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &event_comment_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->event_comment, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x0602, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->track_ids) {
+    guint i;
+
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &track_ids_ul, 16);
+    t->size = 8 + 4 * self->n_track_ids;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_track_ids);
+    GST_WRITE_UINT32_BE (t->data + 4, 4);
+    for (i = 0; i < self->n_track_ids; i++)
+      GST_WRITE_UINT32_BE (t->data + 8 + i * 4, self->track_ids[i]);
+    mxf_primer_pack_add_mapping (primer, 0x6102, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->dm_framework) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &dm_framework_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &MXF_METADATA_BASE (self->dm_framework)->instance_uid, 16);
+    mxf_primer_pack_add_mapping (primer, 0x6101, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_dm_segment_init (MXFMetadataDMSegment * self)
 {
-
+  self->event_start_position = -1;
 }
 
 static void
@@ -2983,6 +4142,7 @@ mxf_metadata_dm_segment_class_init (MXFMetadataDMSegmentClass * klass)
   metadata_base_class->resolve = mxf_metadata_dm_segment_resolve;
   metadata_base_class->name_quark = MXF_QUARK (DM_SEGMENT);
   metadata_base_class->to_structure = mxf_metadata_dm_segment_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_dm_segment_write_tags;
   metadata_class->type = 0x0141;
 }
 
@@ -3129,6 +4289,43 @@ mxf_metadata_generic_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_generic_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataGenericDescriptor *self = MXF_METADATA_GENERIC_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_generic_descriptor_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 locators_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x06, 0x03, 0x00, 0x00
+  };
+
+  if (self->locators) {
+    guint i;
+
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &locators_ul, 16);
+    t->size = 8 + 16 * self->n_locators;;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_locators);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_locators; i++) {
+      if (!self->locators[i])
+        continue;
+      memcpy (t->data + 8 + 16 * i,
+          &MXF_METADATA_BASE (self->locators[i])->instance_uid, 16);
+    }
+    mxf_primer_pack_add_mapping (primer, 0x2f01, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_generic_descriptor_init (MXFMetadataGenericDescriptor * self)
 {
@@ -3147,6 +4344,7 @@ mxf_metadata_generic_descriptor_class_init (MXFMetadataGenericDescriptorClass *
   metadata_base_class->resolve = mxf_metadata_generic_descriptor_resolve;
   metadata_base_class->to_structure =
       mxf_metadata_generic_descriptor_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_generic_descriptor_write_tags;
 }
 
 G_DEFINE_TYPE (MXFMetadataFileDescriptor, mxf_metadata_file_descriptor,
@@ -3247,6 +4445,91 @@ mxf_metadata_file_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_file_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataFileDescriptor *self = MXF_METADATA_FILE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_file_descriptor_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 linked_track_id_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x06, 0x01, 0x01, 0x03, 0x05, 0x00, 0x00, 0x00
+  };
+  static const guint8 sample_rate_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 container_duration_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x06, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 essence_container_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x01, 0x02, 0x00, 0x00
+  };
+  static const guint8 codec_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x06, 0x01, 0x01, 0x04, 0x01, 0x03, 0x00, 0x00
+  };
+
+  if (self->linked_track_id) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &linked_track_id_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->linked_track_id);
+    mxf_primer_pack_add_mapping (primer, 0x3006, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &sample_rate_ul, 16);
+  t->size = 8;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT32_BE (t->data, self->sample_rate.n);
+  GST_WRITE_UINT32_BE (t->data + 4, self->sample_rate.d);
+  mxf_primer_pack_add_mapping (primer, 0x3001, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->container_duration > 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &container_duration_ul, 16);
+    t->size = 8;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT64_BE (t->data, self->container_duration);
+    mxf_primer_pack_add_mapping (primer, 0x3002, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &essence_container_ul, 16);
+  t->size = 16;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  memcpy (t->data, &self->essence_container, 16);
+  mxf_primer_pack_add_mapping (primer, 0x3004, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (!mxf_ul_is_zero (&self->codec)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &codec_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->codec, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3005, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_file_descriptor_init (MXFMetadataFileDescriptor * self)
 {
@@ -3262,6 +4545,7 @@ mxf_metadata_file_descriptor_class_init (MXFMetadataFileDescriptorClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_file_descriptor_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (FILE_DESCRIPTOR);
   metadata_base_class->to_structure = mxf_metadata_file_descriptor_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_file_descriptor_write_tags;
   metadata_class->type = 0x0125;
 }
 
@@ -3567,6 +4851,383 @@ mxf_metadata_generic_picture_essence_descriptor_to_structure (MXFMetadataBase *
   return ret;
 }
 
+static GList *
+mxf_metadata_generic_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataGenericPictureEssenceDescriptor *self =
+      MXF_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_generic_picture_essence_descriptor_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 signal_standard_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x05, 0x01, 0x13, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 frame_layout_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 stored_width_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x02, 0x02, 0x00, 0x00, 0x00
+  };
+  static const guint8 stored_height_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 stored_f2_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x03, 0x02, 0x08, 0x00, 0x00, 0x00
+  };
+  static const guint8 sampled_width_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x08, 0x00, 0x00, 0x00
+  };
+  static const guint8 sampled_height_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x07, 0x00, 0x00, 0x00
+  };
+  static const guint8 sampled_x_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x09, 0x00, 0x00, 0x00
+  };
+  static const guint8 sampled_y_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x0A, 0x00, 0x00, 0x00
+  };
+  static const guint8 display_height_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x0B, 0x00, 0x00, 0x00
+  };
+  static const guint8 display_width_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x0C, 0x00, 0x00, 0x00
+  };
+  static const guint8 display_x_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x0D, 0x00, 0x00, 0x00
+  };
+  static const guint8 display_y_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x0E, 0x00, 0x00, 0x00
+  };
+  static const guint8 display_f2_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x03, 0x02, 0x07, 0x00, 0x00, 0x00
+  };
+  static const guint8 aspect_ratio_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 active_format_descriptor_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x03, 0x02, 0x09, 0x00, 0x00, 0x00
+  };
+  static const guint8 video_line_map_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x03, 0x02, 0x05, 0x00, 0x00, 0x00
+  };
+  static const guint8 alpha_transparency_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x05, 0x20, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 capture_gamma_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x00
+  };
+  static const guint8 image_alignment_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x18, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 image_start_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x18, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 image_end_offset_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x18, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 field_dominance_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x03, 0x01, 0x06, 0x00, 0x00, 0x00
+  };
+  static const guint8 picture_essence_coding_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+
+  if (self->signal_standard != 1) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &signal_standard_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->signal_standard);
+    mxf_primer_pack_add_mapping (primer, 0x3215, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->frame_layout != 255) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &frame_layout_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->frame_layout);
+    mxf_primer_pack_add_mapping (primer, 0x320c, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->stored_width != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &stored_width_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->stored_width);
+    mxf_primer_pack_add_mapping (primer, 0x3203, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->stored_height != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &stored_height_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->stored_height);
+    mxf_primer_pack_add_mapping (primer, 0x3202, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->stored_f2_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &stored_f2_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->stored_f2_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3216, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->sampled_width != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &sampled_width_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->sampled_width);
+    mxf_primer_pack_add_mapping (primer, 0x3205, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->sampled_height != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &sampled_height_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->sampled_height);
+    mxf_primer_pack_add_mapping (primer, 0x3204, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->sampled_x_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &sampled_x_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->sampled_x_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3206, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->sampled_y_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &sampled_y_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->sampled_y_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3207, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->display_height != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &display_height_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->display_height);
+    mxf_primer_pack_add_mapping (primer, 0x3208, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->display_width != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &display_width_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->display_width);
+    mxf_primer_pack_add_mapping (primer, 0x3209, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->display_x_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &display_x_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->display_x_offset);
+    mxf_primer_pack_add_mapping (primer, 0x320a, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->display_y_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &display_y_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->display_y_offset);
+    mxf_primer_pack_add_mapping (primer, 0x320b, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->display_f2_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &display_f2_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->display_f2_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3217, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->aspect_ratio.n != 0 && self->aspect_ratio.d != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &aspect_ratio_ul, 16);
+    t->size = 8;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->aspect_ratio.n);
+    GST_WRITE_UINT32_BE (t->data + 4, self->aspect_ratio.d);
+    mxf_primer_pack_add_mapping (primer, 0x320e, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->active_format_descriptor != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &active_format_descriptor_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->active_format_descriptor);
+    mxf_primer_pack_add_mapping (primer, 0x3218, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->video_line_map[0] != 0 || self->video_line_map[1] != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &video_line_map_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT64_BE (t->data, self->video_line_map[0]);
+    GST_WRITE_UINT64_BE (t->data + 8, self->video_line_map[1]);
+    mxf_primer_pack_add_mapping (primer, 0x320d, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->alpha_transparency != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &alpha_transparency_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->alpha_transparency);
+    mxf_primer_pack_add_mapping (primer, 0x320f, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_ul_is_zero (&self->capture_gamma)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &capture_gamma_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->capture_gamma, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3210, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->image_alignment_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &image_alignment_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->image_alignment_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3211, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->image_start_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &image_start_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->image_start_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3213, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->image_end_offset != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &image_end_offset_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->image_end_offset);
+    mxf_primer_pack_add_mapping (primer, 0x3214, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->field_dominance != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &field_dominance_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->field_dominance);
+    mxf_primer_pack_add_mapping (primer, 0x3212, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_ul_is_zero (&self->picture_essence_coding)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &picture_essence_coding_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->picture_essence_coding, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3201, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
     mxf_metadata_generic_picture_essence_descriptor_init
     (MXFMetadataGenericPictureEssenceDescriptor * self)
@@ -3588,6 +5249,8 @@ static void
       MXF_QUARK (GENERIC_PICTURE_ESSENCE_DESCRIPTOR);
   metadata_base_class->to_structure =
       mxf_metadata_generic_picture_essence_descriptor_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_generic_picture_essence_descriptor_write_tags;
   metadata_class->type = 0x0127;
 }
 
@@ -3641,6 +5304,66 @@ void mxf_metadata_generic_picture_essence_descriptor_set_caps
       par_n, par_d, NULL);
 }
 
+static gint
+gst_greatest_common_divisor (gint a, gint b)
+{
+  while (b != 0) {
+    int temp = a;
+
+    a = b;
+    b = temp % b;
+  }
+
+  return ABS (a);
+}
+
+gboolean
+    mxf_metadata_generic_picture_essence_descriptor_from_caps
+    (MXFMetadataGenericPictureEssenceDescriptor * self, GstCaps * caps) {
+  gint par_n, par_d, gcd;
+  gint width, height;
+  gint fps_n, fps_d;
+  MXFMetadataFileDescriptor *f = (MXFMetadataFileDescriptor *) self;
+  GstStructure *s;
+
+  g_return_val_if_fail (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR
+      (self), FALSE);
+  g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
+
+  s = gst_caps_get_structure (caps, 0);
+
+  if (!gst_structure_get_fraction (s, "framerate", &fps_n, &fps_d)) {
+    GST_ERROR ("Invalid framerate");
+    return FALSE;
+  }
+  f->sample_rate.n = fps_n;
+  f->sample_rate.d = fps_d;
+
+  if (!gst_structure_get_int (s, "width", &width) ||
+      !gst_structure_get_int (s, "height", &height)) {
+    GST_ERROR ("Invalid width/height");
+    return FALSE;
+  }
+
+  self->stored_width = width;
+  self->stored_height = height;
+
+  if (!gst_structure_get_fraction (s, "pixel-aspect-ratio", &par_n, &par_d)) {
+    par_n = 1;
+    par_d = 1;
+  }
+
+  self->aspect_ratio.n = par_n * width;
+  self->aspect_ratio.d = par_d * height;
+  gcd =
+      gst_greatest_common_divisor (self->aspect_ratio.n, self->aspect_ratio.d);
+  self->aspect_ratio.n /= gcd;
+  self->aspect_ratio.d /= gcd;
+
+  return TRUE;
+}
+
+
 G_DEFINE_TYPE (MXFMetadataGenericSoundEssenceDescriptor,
     mxf_metadata_generic_sound_essence_descriptor,
     MXF_TYPE_METADATA_FILE_DESCRIPTOR);
@@ -3770,12 +5493,147 @@ mxf_metadata_generic_sound_essence_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_generic_sound_essence_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataGenericSoundEssenceDescriptor *self =
+      MXF_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_generic_sound_essence_descriptor_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 audio_sampling_rate_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00
+  };
+  static const guint8 locked_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x04, 0x02, 0x03, 0x01, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 audio_ref_level_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x02, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00
+  };
+  static const guint8 electro_spatial_formulation_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 channel_count_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x02, 0x01, 0x01, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 quantization_bits_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x04, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 dial_norm_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x02, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 sound_essence_compression_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x02, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00
+  };
+
+  if (self->audio_sampling_rate.d && self->audio_sampling_rate.n) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &audio_sampling_rate_ul, 16);
+    t->size = 8;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->audio_sampling_rate.n);
+    GST_WRITE_UINT32_BE (t->data + 4, self->audio_sampling_rate.d);
+    mxf_primer_pack_add_mapping (primer, 0x3d03, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  t = g_slice_new0 (MXFLocalTag);
+  memcpy (&t->key, &locked_ul, 16);
+  t->size = 1;
+  t->data = g_slice_alloc (t->size);
+  t->g_slice = TRUE;
+  GST_WRITE_UINT8 (t->data, (self->locked) ? 1 : 0);
+  mxf_primer_pack_add_mapping (primer, 0x3d02, &t->key);
+  ret = g_list_prepend (ret, t);
+
+  if (self->audio_ref_level) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &audio_ref_level_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->audio_ref_level);
+    mxf_primer_pack_add_mapping (primer, 0x3d04, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->electro_spatial_formulation != 255) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &electro_spatial_formulation_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->electro_spatial_formulation);
+    mxf_primer_pack_add_mapping (primer, 0x3d05, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->channel_count) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &channel_count_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->channel_count);
+    mxf_primer_pack_add_mapping (primer, 0x3d07, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->quantization_bits) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &quantization_bits_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->quantization_bits);
+    mxf_primer_pack_add_mapping (primer, 0x3d01, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->dial_norm != 0) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &dial_norm_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->dial_norm);
+    mxf_primer_pack_add_mapping (primer, 0x3d0c, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (!mxf_ul_is_zero (&self->sound_essence_compression)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &sound_essence_compression_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->sound_essence_compression, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3d06, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
     mxf_metadata_generic_sound_essence_descriptor_init
     (MXFMetadataGenericSoundEssenceDescriptor * self)
 {
   self->audio_sampling_rate.n = 48000;
   self->audio_sampling_rate.d = 1;
+  self->electro_spatial_formulation = 255;
 }
 
 static void
@@ -3791,6 +5649,8 @@ static void
       MXF_QUARK (GENERIC_SOUND_ESSENCE_DESCRIPTOR);
   metadata_base_class->to_structure =
       mxf_metadata_generic_sound_essence_descriptor_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_generic_sound_essence_descriptor_write_tags;
   metadata_class->type = 0x0142;
 }
 
@@ -3817,6 +5677,38 @@ void mxf_metadata_generic_sound_essence_descriptor_set_caps
   }
 }
 
+gboolean
+    mxf_metadata_generic_sound_essence_descriptor_from_caps
+    (MXFMetadataGenericSoundEssenceDescriptor * self, GstCaps * caps) {
+  gint rate;
+  gint channels;
+  GstStructure *s;
+
+  g_return_val_if_fail (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (self),
+      FALSE);
+  g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
+
+  s = gst_caps_get_structure (caps, 0);
+
+  if (!gst_structure_get_int (s, "rate", &rate) || rate == 0) {
+    GST_WARNING ("No samplerate");
+    return FALSE;
+  } else {
+    self->audio_sampling_rate.n = rate;
+    self->audio_sampling_rate.d = 1;
+  }
+
+  if (!gst_structure_get_int (s, "channels", &channels) || channels == 0) {
+    GST_WARNING ("No channels");
+    return FALSE;
+  } else {
+    self->channel_count = channels;
+  }
+
+  return TRUE;
+}
+
+
 G_DEFINE_TYPE (MXFMetadataCDCIPictureEssenceDescriptor,
     mxf_metadata_cdci_picture_essence_descriptor,
     MXF_TYPE_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR);
@@ -3933,7 +5825,7 @@ mxf_metadata_cdci_picture_essence_descriptor_to_structure (MXFMetadataBase * m)
     gst_structure_id_set (ret, MXF_QUARK (VERTICAL_SUBSAMPLING), G_TYPE_UINT,
         self->vertical_subsampling, NULL);
 
-  if (self->color_siting != 0)
+  if (self->color_siting != 255)
     gst_structure_id_set (ret, MXF_QUARK (COLOR_SITING), G_TYPE_UCHAR,
         self->color_siting, NULL);
 
@@ -3963,11 +5855,176 @@ mxf_metadata_cdci_picture_essence_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_cdci_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataCDCIPictureEssenceDescriptor *self =
+      MXF_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_cdci_picture_essence_descriptor_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 component_depth_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x05, 0x03, 0x0A, 0x00, 0x00, 0x00
+  };
+  static const guint8 horizontal_subsampling_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x05, 0x00, 0x00, 0x00
+  };
+  static const guint8 vertical_subsampling_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x05, 0x01, 0x10, 0x00, 0x00, 0x00
+  };
+  static const guint8 color_siting_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x01, 0x06, 0x00, 0x00, 0x00
+  };
+  static const guint8 reversed_byte_order_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x03, 0x01, 0x02, 0x01, 0x0A, 0x00, 0x00, 0x00
+  };
+  static const guint8 padding_bits_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x18, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00
+  };
+  static const guint8 alpha_sample_depth_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x05, 0x03, 0x07, 0x00, 0x00, 0x00
+  };
+  static const guint8 black_ref_level_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x03, 0x03, 0x00, 0x00, 0x00
+  };
+  static const guint8 white_ref_level_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x04, 0x01, 0x05, 0x03, 0x04, 0x00, 0x00, 0x00
+  };
+  static const guint8 color_range_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x05, 0x03, 0x05, 0x00, 0x00, 0x00
+  };
+
+  if (self->component_depth) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &component_depth_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->component_depth);
+    mxf_primer_pack_add_mapping (primer, 0x3301, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->horizontal_subsampling) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &horizontal_subsampling_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->horizontal_subsampling);
+    mxf_primer_pack_add_mapping (primer, 0x3302, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->vertical_subsampling) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &vertical_subsampling_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->vertical_subsampling);
+    mxf_primer_pack_add_mapping (primer, 0x3308, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->color_siting != 0xff) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &color_siting_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->color_siting);
+    mxf_primer_pack_add_mapping (primer, 0x3303, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->reversed_byte_order) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &reversed_byte_order_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, (self->reversed_byte_order) ? 1 : 0);
+    mxf_primer_pack_add_mapping (primer, 0x330b, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->padding_bits) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &padding_bits_ul, 16);
+    t->size = 2;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT16_BE (t->data, self->padding_bits);
+    mxf_primer_pack_add_mapping (primer, 0x3307, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->alpha_sample_depth) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &alpha_sample_depth_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->alpha_sample_depth);
+    mxf_primer_pack_add_mapping (primer, 0x3309, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->black_ref_level) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &black_ref_level_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->black_ref_level);
+    mxf_primer_pack_add_mapping (primer, 0x3304, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->white_ref_level) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &white_ref_level_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->white_ref_level);
+    mxf_primer_pack_add_mapping (primer, 0x3305, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->color_range) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &color_range_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->color_range);
+    mxf_primer_pack_add_mapping (primer, 0x3306, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
     mxf_metadata_cdci_picture_essence_descriptor_init
     (MXFMetadataCDCIPictureEssenceDescriptor * self)
 {
-
+  self->color_siting = 0xff;
 }
 
 static void
@@ -3982,6 +6039,8 @@ static void
   metadata_base_class->name_quark = MXF_QUARK (CDCI_PICTURE_ESSENCE_DESCRIPTOR);
   metadata_base_class->to_structure =
       mxf_metadata_cdci_picture_essence_descriptor_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_cdci_picture_essence_descriptor_write_tags;
   metadata_class->type = 0x0128;
 }
 
@@ -4138,6 +6197,112 @@ mxf_metadata_rgba_picture_essence_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_rgba_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataRGBAPictureEssenceDescriptor *self =
+      MXF_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_rgba_picture_essence_descriptor_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 component_max_ref_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x05, 0x03, 0x0B, 0x00, 0x00, 0x00
+  };
+  static const guint8 component_min_ref_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x05, 0x03, 0x0C, 0x00, 0x00, 0x00
+  };
+  static const guint8 alpha_max_ref_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x05, 0x03, 0x0D, 0x00, 0x00, 0x00
+  };
+  static const guint8 alpha_min_ref_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x05, 0x03, 0x0E, 0x00, 0x00, 0x00
+  };
+  static const guint8 scanning_direction_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x05,
+    0x04, 0x01, 0x04, 0x04, 0x01, 0x00, 0x00, 0x00
+  };
+  static const guint8 pixel_layout_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x04, 0x01, 0x05, 0x03, 0x06, 0x00, 0x00, 0x00
+  };
+
+  if (self->component_max_ref != 255) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &component_max_ref_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->component_max_ref);
+    mxf_primer_pack_add_mapping (primer, 0x3406, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->component_min_ref) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &component_min_ref_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->component_min_ref);
+    mxf_primer_pack_add_mapping (primer, 0x3407, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->alpha_max_ref != 255) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &alpha_max_ref_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->alpha_max_ref);
+    mxf_primer_pack_add_mapping (primer, 0x3408, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->alpha_min_ref) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &alpha_min_ref_ul, 16);
+    t->size = 4;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->alpha_min_ref);
+    mxf_primer_pack_add_mapping (primer, 0x3409, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->scanning_direction) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &scanning_direction_ul, 16);
+    t->size = 1;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT8 (t->data, self->scanning_direction);
+    mxf_primer_pack_add_mapping (primer, 0x3405, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  if (self->pixel_layout) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &pixel_layout_ul, 16);
+    t->size = 2 * self->n_pixel_layout + 2;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, self->pixel_layout, self->n_pixel_layout * 2);
+    mxf_primer_pack_add_mapping (primer, 0x3401, &t->key);
+    ret = g_list_prepend (ret, t);
+
+  }
+
+  return ret;
+}
+
 static void
     mxf_metadata_rgba_picture_essence_descriptor_init
     (MXFMetadataRGBAPictureEssenceDescriptor * self)
@@ -4161,6 +6326,8 @@ static void
   metadata_base_class->name_quark = MXF_QUARK (RGBA_PICTURE_ESSENCE_DESCRIPTOR);
   metadata_base_class->to_structure =
       mxf_metadata_rgba_picture_essence_descriptor_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_rgba_picture_essence_descriptor_write_tags;
   metadata_class->type = 0x0129;
 }
 
@@ -4227,6 +6394,36 @@ mxf_metadata_generic_data_essence_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_generic_data_essence_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataGenericDataEssenceDescriptor *self =
+      MXF_METADATA_GENERIC_DATA_ESSENCE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_generic_data_essence_descriptor_parent_class)->write_tags
+      (m, primer);
+  MXFLocalTag *t;
+  static const guint8 data_essence_coding_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03,
+    0x04, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00
+  };
+
+  if (!mxf_ul_is_zero (&self->data_essence_coding)) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &data_essence_coding_ul, 16);
+    t->size = 16;
+    t->data = g_slice_alloc (t->size);
+    t->g_slice = TRUE;
+    memcpy (t->data, &self->data_essence_coding, 16);
+    mxf_primer_pack_add_mapping (primer, 0x3e01, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
     mxf_metadata_generic_data_essence_descriptor_init
     (MXFMetadataGenericDataEssenceDescriptor * self)
@@ -4246,6 +6443,8 @@ static void
   metadata_base_class->name_quark = MXF_QUARK (GENERIC_DATA_ESSENCE_DESCRIPTOR);
   metadata_base_class->to_structure =
       mxf_metadata_generic_data_essence_descriptor_to_structure;
+  metadata_base_class->write_tags =
+      mxf_metadata_generic_data_essence_descriptor_write_tags;
   metadata_class->type = 0x0143;
 }
 
@@ -4391,6 +6590,44 @@ mxf_metadata_multiple_descriptor_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_multiple_descriptor_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataMultipleDescriptor *self = MXF_METADATA_MULTIPLE_DESCRIPTOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_multiple_descriptor_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 sub_descriptors_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04,
+    0x06, 0x01, 0x01, 0x04, 0x06, 0x0B, 0x00, 0x00
+  };
+
+  if (self->sub_descriptors) {
+    guint i;
+
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &sub_descriptors_ul, 16);
+    t->size = 8 + 16 * self->n_sub_descriptors;
+    t->data = g_slice_alloc0 (t->size);
+    t->g_slice = TRUE;
+    GST_WRITE_UINT32_BE (t->data, self->n_sub_descriptors);
+    GST_WRITE_UINT32_BE (t->data + 4, 16);
+    for (i = 0; i < self->n_sub_descriptors; i++) {
+      if (!self->sub_descriptors[i])
+        continue;
+
+      memcpy (t->data + 8 + 16 * i,
+          &MXF_METADATA_BASE (self->sub_descriptors[i])->instance_uid, 16);
+    }
+    mxf_primer_pack_add_mapping (primer, 0x3f01, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_multiple_descriptor_init (MXFMetadataMultipleDescriptor * self)
 {
@@ -4411,6 +6648,7 @@ mxf_metadata_multiple_descriptor_class_init (MXFMetadataMultipleDescriptorClass
   metadata_base_class->name_quark = MXF_QUARK (MULTIPLE_DESCRIPTOR);
   metadata_base_class->to_structure =
       mxf_metadata_multiple_descriptor_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_multiple_descriptor_write_tags;
   metadata_class->type = 0x0144;
 }
 
@@ -4480,6 +6718,31 @@ mxf_metadata_text_locator_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_text_locator_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataTextLocator *self = MXF_METADATA_TEXT_LOCATOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_text_locator_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 locator_name_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02,
+    0x01, 0x04, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00
+  };
+
+  if (self->locator_name) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &locator_name_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->locator_name, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x4101, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_text_locator_init (MXFMetadataTextLocator * self)
 {
@@ -4497,6 +6760,7 @@ mxf_metadata_text_locator_class_init (MXFMetadataTextLocatorClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_text_locator_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (TEXT_LOCATOR);
   metadata_base_class->to_structure = mxf_metadata_text_locator_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_text_locator_write_tags;
   metadata_class->type = 0x0133;
 }
 
@@ -4553,6 +6817,31 @@ mxf_metadata_network_locator_to_structure (MXFMetadataBase * m)
   return ret;
 }
 
+static GList *
+mxf_metadata_network_locator_write_tags (MXFMetadataBase * m,
+    MXFPrimerPack * primer)
+{
+  MXFMetadataNetworkLocator *self = MXF_METADATA_NETWORK_LOCATOR (m);
+  GList *ret =
+      MXF_METADATA_BASE_CLASS
+      (mxf_metadata_network_locator_parent_class)->write_tags (m, primer);
+  MXFLocalTag *t;
+  static const guint8 url_string_ul[] = {
+    0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00
+  };
+
+  if (self->url_string) {
+    t = g_slice_new0 (MXFLocalTag);
+    memcpy (&t->key, &url_string_ul, 16);
+    t->data = mxf_utf8_to_utf16 (self->url_string, &t->size);
+    mxf_primer_pack_add_mapping (primer, 0x4001, &t->key);
+    ret = g_list_prepend (ret, t);
+  }
+
+  return ret;
+}
+
 static void
 mxf_metadata_network_locator_init (MXFMetadataNetworkLocator * self)
 {
@@ -4569,6 +6858,7 @@ mxf_metadata_network_locator_class_init (MXFMetadataNetworkLocatorClass * klass)
   metadata_base_class->handle_tag = mxf_metadata_network_locator_handle_tag;
   metadata_base_class->name_quark = MXF_QUARK (NETWORK_LOCATOR);
   metadata_base_class->to_structure = mxf_metadata_network_locator_to_structure;
+  metadata_base_class->write_tags = mxf_metadata_network_locator_write_tags;
   metadata_class->type = 0x0133;
 }