diff options
Diffstat (limited to 'gst/mxf/mxfmetadata.c')
| -rw-r--r-- | gst/mxf/mxfmetadata.c | 2288 |
1 files changed, 2285 insertions, 3 deletions
diff --git a/gst/mxf/mxfmetadata.c b/gst/mxf/mxfmetadata.c index cc53ec15..29bd8a5f 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,63 @@ 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); +} + +void 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_if_fail (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (self)); + g_return_if_fail (GST_IS_CAPS (caps)); + + s = gst_caps_get_structure (caps, 0); + + if (!gst_structure_get_fraction (s, "framerate", &fps_n, &fps_d)) { + GST_ERROR ("Invalid framerate"); + return; + } + 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; + } + + 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; +} + + G_DEFINE_TYPE (MXFMetadataGenericSoundEssenceDescriptor, mxf_metadata_generic_sound_essence_descriptor, MXF_TYPE_METADATA_FILE_DESCRIPTOR); @@ -3770,12 +5490,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 +5646,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 +5674,33 @@ void mxf_metadata_generic_sound_essence_descriptor_set_caps } } +void mxf_metadata_generic_sound_essence_descriptor_from_caps + (MXFMetadataGenericSoundEssenceDescriptor * self, GstCaps * caps) +{ + gint rate; + gint channels; + GstStructure *s; + + g_return_if_fail (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (self)); + g_return_if_fail (GST_IS_CAPS (caps)); + + s = gst_caps_get_structure (caps, 0); + + if (!gst_structure_get_int (s, "rate", &rate)) { + GST_WARNING ("No samplerate"); + } else { + self->audio_sampling_rate.n = rate; + self->audio_sampling_rate.d = 1; + } + + if (!gst_structure_get_int (s, "channels", &channels)) { + GST_WARNING ("No channels"); + } else { + self->channel_count = channels; + } +} + + G_DEFINE_TYPE (MXFMetadataCDCIPictureEssenceDescriptor, mxf_metadata_cdci_picture_essence_descriptor, MXF_TYPE_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR); @@ -3933,7 +5817,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 +5847,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 +6031,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 +6189,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 +6318,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 +6386,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 +6435,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 +6582,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 +6640,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 +6710,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 +6752,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 +6809,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 +6850,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; } |