diff options
Diffstat (limited to 'gst/mxf/mxfparse.c')
| -rw-r--r-- | gst/mxf/mxfparse.c | 2692 |
1 files changed, 2692 insertions, 0 deletions
diff --git a/gst/mxf/mxfparse.c b/gst/mxf/mxfparse.c new file mode 100644 index 00000000..49f5d685 --- /dev/null +++ b/gst/mxf/mxfparse.c @@ -0,0 +1,2692 @@ +/* GStreamer + * Copyright (C) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <gst/gst.h> +#include <string.h> + +#include "mxfparse.h" + +GST_DEBUG_CATEGORY_EXTERN (mxf_debug); +#define GST_CAT_DEFAULT mxf_debug + +/* SMPTE 377M 3.3: A value of 0 for every field means unknown timestamp */ +static const MXFTimestamp mxf_timestamp_unknown = { 0, 0, 0, 0, 0, 0, 0 }; + +/* FIXME: are zero UMID/UL invalid? Should be in SMPTE 298M, 330M or 336M */ +static const MXFUMID umid_zero = { {0,} }; +static const MXFUL key_zero = { {0,} }; + +/* UL common to all MXF UL */ +static const guint8 mxf_key[] = { 0x06, 0x0e, 0x2b, 0x34 }; + +/* SMPTE 377M 6.1 */ +static const guint8 partition_pack_key[] = + { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0d, 0x01, 0x02, 0x01, + 0x01 +}; + +/* SMPTE 336M */ +static const guint8 fill_key[] = + { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x02, 0x10, + 0x01, 0x00, 0x00, 0x00 +}; + +/* SMPTE 377M 8.1 */ +static const guint8 primer_pack_key[] = + { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0d, 0x01, 0x02, 0x01, + 0x01, 0x05, 0x01, 0x00 +}; + +/* SMPTE 377M 8.6 */ +static const guint8 metadata_key[] = + { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 0x0d, 0x01, 0x01, 0x01, + 0x01 +}; + +static const guint8 random_index_pack_key[] = + { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0d, 0x01, 0x02, 0x01, + 0x01, 0x11, 0x01, 0x00 +}; + +static const guint8 index_table_segment_key[] = + { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, 0x0d, 0x01, 0x02, 0x01, + 0x01, 0x10, 0x01, 0x00 +}; + +gboolean +mxf_is_mxf_packet (const MXFUL * key) +{ + return (memcmp (key, mxf_key, 4) == 0); +} + +/* SMPTE 377M 6.1: Check if this is a valid partition pack */ +gboolean +mxf_is_partition_pack (const MXFUL * key) +{ + if (memcmp (key, partition_pack_key, 13) == 0 && key->u[13] >= 0x02 + && key->u[13] <= 0x04 && key->u[14] < 0x05 && key->u[15] == 0x00) + return TRUE; + + return FALSE; +} + +/* SMPTE 377M 6.2: header partition pack has byte 14 == 0x02 */ +gboolean +mxf_is_header_partition_pack (const MXFUL * key) +{ + if (memcmp (key, partition_pack_key, 13) == 0 && key->u[13] == 0x02 && + key->u[14] < 0x05 && key->u[15] == 0x00) + return TRUE; + + return FALSE; +} + +/* SMPTE 377M 6.3: body partition pack has byte 14 == 0x03 */ +gboolean +mxf_is_body_partition_pack (const MXFUL * key) +{ + if (memcmp (key, partition_pack_key, 13) == 0 && key->u[13] == 0x03 && + key->u[14] < 0x05 && key->u[15] == 0x00) + return TRUE; + + return FALSE; +} + +/* SMPTE 377M 6.4: footer partition pack has byte 14 == 0x04 */ +gboolean +mxf_is_footer_partition_pack (const MXFUL * key) +{ + if (memcmp (key, partition_pack_key, 13) == 0 && key->u[13] == 0x04 && + key->u[14] < 0x05 && key->u[15] == 0x00) + return TRUE; + + return FALSE; +} + +gboolean +mxf_is_fill (const MXFUL * key) +{ + return (memcmp (key, fill_key, 16) == 0); +} + +gboolean +mxf_is_primer_pack (const MXFUL * key) +{ + return (memcmp (key, primer_pack_key, 16) == 0); +} + +gboolean +mxf_is_metadata (const MXFUL * key) +{ + return (memcmp (key, metadata_key, 13) == 0 && key->u[15] == 0x00); +} + +gboolean +mxf_is_random_index_pack (const MXFUL * key) +{ + return (memcmp (key, random_index_pack_key, 16) == 0); +} + +gboolean +mxf_is_index_table_segment (const MXFUL * key) +{ + return (memcmp (key, index_table_segment_key, 16) == 0); +} + +/* SMPTE 379M 6.2.1 */ +gboolean +mxf_is_generic_container_system_item (const MXFUL * key) +{ + return (memcmp (key, mxf_key, 4) == 0 && key->u[4] == 0x02 + && key->u[6] == 0x01 && key->u[8] == 0x0d && key->u[9] == 0x01 + && key->u[10] == 0x03 && key->u[11] == 0x01 && (key->u[12] == 0x04 + || key->u[12] == 0x14)); +} + +/* SMPTE 379M 7.1 */ +gboolean +mxf_is_generic_container_essence_element (const MXFUL * key) +{ + return (memcmp (key, mxf_key, 4) == 0 && key->u[4] == 0x01 + && key->u[5] == 0x02 && key->u[6] == 0x01 && key->u[8] == 0x0d + && key->u[9] == 0x01 && key->u[10] == 0x03 && key->u[11] == 0x01 + && (key->u[12] == 0x05 || key->u[12] == 0x06 || key->u[12] == 0x07 + || key->u[12] == 0x15 || key->u[12] == 0x16 || key->u[12] == 0x17 + || key->u[12] == 0x18)); +} + +/* SMPTE 379M 8 */ +gboolean +mxf_is_generic_container_essence_container_label (const MXFUL * key) +{ + return (key->u[0] == 0x06 && + key->u[1] == 0x0e && + key->u[2] == 0x2b && + key->u[3] == 0x34 && + key->u[4] == 0x04 && + key->u[5] == 0x01 && + key->u[6] == 0x01 && + key->u[8] == 0x0d && + key->u[9] == 0x01 && + key->u[10] == 0x03 && + key->u[11] == 0x01 && (key->u[12] == 0x01 || key->u[12] == 0x02)); +} + +gboolean +mxf_ul_is_equal (const MXFUL * a, const MXFUL * b) +{ + return (memcmp (a, b, 16) == 0); +} + +gboolean +mxf_ul_is_zero (const MXFUL * key) +{ + return (memcmp (key, &key_zero, 16) == 0); +} + +gchar * +mxf_ul_to_string (const MXFUL * key, gchar str[48]) +{ + g_return_val_if_fail (key != NULL, NULL); + g_return_val_if_fail (str != NULL, NULL); + + g_snprintf (str, 48, + "%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x", + key->u[0], key->u[1], key->u[2], key->u[3], key->u[4], key->u[5], + key->u[6], key->u[7], key->u[8], key->u[9], key->u[10], key->u[11], + key->u[12], key->u[13], key->u[14], key->u[15]); + + return str; +} + +gboolean +mxf_umid_is_equal (const MXFUMID * a, const MXFUMID * b) +{ + return (memcmp (a, b, 32) == 0); +} + +gboolean +mxf_umid_is_zero (const MXFUMID * umid) +{ + return (memcmp (umid, &umid_zero, 32) == 0); +} + +gchar * +mxf_umid_to_string (const MXFUMID * key, gchar str[96]) +{ + g_return_val_if_fail (key != NULL, NULL); + g_return_val_if_fail (str != NULL, NULL); + + g_snprintf (str, 96, + "%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x." + "%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x", + key->u[0], key->u[1], key->u[2], key->u[3], key->u[4], key->u[5], + key->u[6], key->u[7], key->u[8], key->u[9], key->u[10], key->u[11], + key->u[12], key->u[13], key->u[14], key->u[15], + key->u[16], + key->u[17], + key->u[18], + key->u[19], + key->u[20], + key->u[21], + key->u[22], + key->u[23], + key->u[24], + key->u[25], + key->u[26], key->u[27], key->u[28], key->u[29], key->u[30], key->u[31] + ); + + return str; +} + + +static guint +gst_mxf_ul_hash (const MXFUL * key) +{ + guint32 ret = 0; + gint i; + + for (i = 0; i < 4; i++) + ret ^= + (key->u[i * 4 + 0] << 24) | (key->u[i * 4 + 1] << 16) | (key->u[i * 4 + + 2] << 8) | (key->u[i * 4 + 3] << 0); + + return ret; +} + +static gboolean +gst_mxf_ul_equal (const MXFUL * a, const MXFUL * b) +{ + return (memcmp (a, b, 16) == 0); +} + +gboolean +mxf_timestamp_parse (MXFTimestamp * timestamp, const guint8 * data, gsize size) +{ + g_return_val_if_fail (data != NULL, FALSE); + g_return_val_if_fail (timestamp != NULL, FALSE); + + memset (timestamp, 0, sizeof (MXFTimestamp)); + + if (size < 8) + return FALSE; + + timestamp->year = GST_READ_UINT16_BE (data); + timestamp->month = GST_READ_UINT8 (data + 2); + timestamp->day = GST_READ_UINT8 (data + 3); + timestamp->hour = GST_READ_UINT8 (data + 4); + timestamp->minute = GST_READ_UINT8 (data + 5); + timestamp->second = GST_READ_UINT8 (data + 6); + timestamp->quarter_msecond = GST_READ_UINT8 (data + 7); + + return TRUE; +} + +gboolean +mxf_timestamp_is_unknown (const MXFTimestamp * a) +{ + return (memcmp (a, &mxf_timestamp_unknown, sizeof (MXFTimestamp)) == 0); +} + +gint +mxf_timestamp_compare (const MXFTimestamp * a, const MXFTimestamp * b) +{ + gint diff; + + if ((diff = a->year - b->year) != 0) + return diff; + else if ((diff = a->month - b->month) != 0) + return diff; + else if ((diff = a->day - b->day) != 0) + return diff; + else if ((diff = a->hour - b->hour) != 0) + return diff; + else if ((diff = a->minute - b->minute) != 0) + return diff; + else if ((diff = a->second - b->second) != 0) + return diff; + else if ((diff = a->quarter_msecond - b->quarter_msecond) != 0) + return diff; + else + return 0; +} + +gboolean +mxf_fraction_parse (MXFFraction * fraction, const guint8 * data, guint16 size) +{ + g_return_val_if_fail (fraction != NULL, FALSE); + g_return_val_if_fail (data != NULL, FALSE); + + memset (fraction, 0, sizeof (MXFFraction)); + + if (size < 8) + return FALSE; + + fraction->n = GST_READ_UINT32_BE (data); + fraction->d = GST_READ_UINT32_BE (data + 4); + + return TRUE; +} + +gchar * +mxf_utf16_to_utf8 (const guint8 * data, guint16 size) +{ + gchar *ret; + GError *error = NULL; + + ret = + g_convert ((const gchar *) data, size, "UTF-8", "UTF-16BE", NULL, NULL, + &error); + + if (ret == NULL) { + GST_WARNING ("UTF-16-BE to UTF-8 conversion failed: %s", error->message); + g_error_free (error); + return NULL; + } + + return ret; +} + +gboolean +mxf_product_version_parse (MXFProductVersion * product_version, + const guint8 * data, gsize size) +{ + g_return_val_if_fail (product_version != NULL, FALSE); + g_return_val_if_fail (data != NULL, FALSE); + + memset (product_version, 0, sizeof (MXFProductVersion)); + + if (size < 10) + return FALSE; + + product_version->major = GST_READ_UINT16_BE (data); + product_version->minor = GST_READ_UINT16_BE (data + 2); + product_version->patch = GST_READ_UINT16_BE (data + 4); + product_version->build = GST_READ_UINT16_BE (data + 6); + product_version->release = GST_READ_UINT16_BE (data + 8); + + return TRUE; +} + +/* SMPTE 377M 6.1, Table 2 */ +gboolean +mxf_partition_pack_parse (const MXFUL * key, MXFPartitionPack * pack, + const guint8 * data, gsize size) +{ + gint i; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + g_return_val_if_fail (size >= 84, FALSE); + + memset (pack, 0, sizeof (MXFPartitionPack)); + + if (key->u[13] == 0x02) + pack->type = MXF_PARTITION_PACK_HEADER; + else if (key->u[13] == 0x03) + pack->type = MXF_PARTITION_PACK_BODY; + else if (key->u[13] == 0x04) + pack->type = MXF_PARTITION_PACK_FOOTER; + + pack->closed = (key->u[14] == 0x02 || key->u[14] == 0x04); + pack->complete = (key->u[14] == 0x03 || key->u[14] == 0x04); + + pack->major_version = GST_READ_UINT16_BE (data); + if (pack->major_version != 1) + goto error; + data += 2; + size -= 2; + + pack->minor_version = GST_READ_UINT16_BE (data); + data += 2; + size -= 2; + + pack->kag_size = GST_READ_UINT32_BE (data); + data += 4; + size -= 4; + + pack->this_partition = GST_READ_UINT64_BE (data); + data += 8; + size -= 8; + + pack->prev_partition = GST_READ_UINT64_BE (data); + data += 8; + size -= 8; + + pack->footer_partition = GST_READ_UINT64_BE (data); + data += 8; + size -= 8; + + pack->header_byte_count = GST_READ_UINT64_BE (data); + data += 8; + size -= 8; + + pack->index_byte_count = GST_READ_UINT64_BE (data); + data += 8; + size -= 8; + + pack->index_sid = GST_READ_UINT32_BE (data); + data += 4; + size -= 4; + + pack->body_offset = GST_READ_UINT64_BE (data); + data += 8; + size -= 8; + + pack->body_sid = GST_READ_UINT32_BE (data); + data += 4; + size -= 4; + + memcpy (&pack->operational_pattern, data, 16); + data += 16; + size -= 16; + + pack->n_essence_containers = GST_READ_UINT32_BE (data); + data += 4; + size -= 4; + + if (GST_READ_UINT32_BE (data) != 16) + goto error; + data += 4; + size -= 4; + + if (size < 16 * pack->n_essence_containers) + goto error; + + if (pack->n_essence_containers) { + pack->essence_containers = g_new (MXFUL, pack->n_essence_containers); + for (i = 0; i < pack->n_essence_containers; i++) + memcpy (&pack->essence_containers[i], data + i * 16, 16); + } + + pack->valid = TRUE; + GST_DEBUG ("Parsed partition pack: \n" + " type = %s, closed = %s, complete = %s\n" + " MXF version = %u.%u\n" + " KAG size = %u\n" + " this partition offset = %" G_GUINT64_FORMAT "\n" + " previous partition offset = %" G_GUINT64_FORMAT "\n" + " footer partition offset = %" G_GUINT64_FORMAT "\n" + " header size = %" G_GUINT64_FORMAT "\n" + " index sid = %u, size %" G_GUINT64_FORMAT "\n" + " body sid = %u, offset %" G_GUINT64_FORMAT "\n" + " operational pattern = %s\n" + " number of essence containers = %u", + (pack->type == MXF_PARTITION_PACK_HEADER) ? "header" : (pack->type == + MXF_PARTITION_PACK_BODY) ? "body" : "footer", + (pack->closed) ? "yes" : "no", (pack->complete) ? "yes" : "no", + pack->major_version, pack->minor_version, pack->kag_size, + pack->this_partition, pack->prev_partition, pack->footer_partition, + pack->header_byte_count, pack->index_sid, pack->index_byte_count, + pack->body_sid, pack->body_offset, + mxf_ul_to_string (&pack->operational_pattern, str), + pack->n_essence_containers); + + for (i = 0; i < pack->n_essence_containers; i++) { + GST_DEBUG (" essence container %d = %s", i, + mxf_ul_to_string (&pack->essence_containers[i], str)); + } + + return TRUE; + +error: + GST_ERROR ("Invalid partition pack"); + + mxf_partition_pack_reset (pack); + return FALSE; +} + +void +mxf_partition_pack_reset (MXFPartitionPack * pack) +{ + g_return_if_fail (pack != NULL); + + g_free (pack->essence_containers); + + memset (pack, 0, sizeof (MXFPartitionPack)); +} + +/* SMPTE 377M 8.2 Table 1 and 2 */ + +static void +_mxf_mapping_ul_free (MXFUL * ul) +{ + g_slice_free (MXFUL, ul); +} + +gboolean +mxf_primer_pack_parse (const MXFUL * key, MXFPrimerPack * pack, + const guint8 * data, gsize size) +{ + gint i; + guint32 n; + + g_return_val_if_fail (data != NULL, FALSE); + g_return_val_if_fail (size >= 8, FALSE); + + memset (pack, 0, sizeof (MXFPrimerPack)); + + pack->mappings = + g_hash_table_new_full (g_direct_hash, g_direct_equal, + (GDestroyNotify) NULL, (GDestroyNotify) _mxf_mapping_ul_free); + + n = GST_READ_UINT32_BE (data); + data += 4; + + if (GST_READ_UINT32_BE (data) != 18) + goto error; + data += 4; + + if (size < 8 + n * 18) + goto error; + + GST_DEBUG ("Parsed primer pack:"); + for (i = 0; i < n; i++) { + guint local_tag; + gchar str[48]; + MXFUL *uid; + + local_tag = GST_READ_UINT16_BE (data); + data += 2; + + if (g_hash_table_lookup (pack->mappings, GUINT_TO_POINTER (local_tag))) + continue; + + uid = g_slice_new (MXFUL); + memcpy (uid, data, 16); + data += 16; + + g_hash_table_insert (pack->mappings, GUINT_TO_POINTER (local_tag), uid); + GST_DEBUG (" Adding primer pack association: 0x%04x -> %s", local_tag, + mxf_ul_to_string (uid, str)); + } + + pack->valid = TRUE; + + return TRUE; + +error: + GST_DEBUG ("Invalid primer pack"); + mxf_primer_pack_reset (pack); + return FALSE; +} + +void +mxf_primer_pack_reset (MXFPrimerPack * pack) +{ + g_return_if_fail (pack != NULL); + + if (pack->mappings) + g_hash_table_destroy (pack->mappings); + memset (pack, 0, sizeof (MXFPrimerPack)); +} + +/* structural metadata parsing */ + +gboolean +mxf_local_tag_parse (const guint8 * data, gsize size, guint16 * tag, + guint16 * tag_size, const guint8 ** tag_data) +{ + g_return_val_if_fail (data != NULL, FALSE); + + if (size < 4) + return FALSE; + + *tag = GST_READ_UINT16_BE (data); + *tag_size = GST_READ_UINT16_BE (data + 2); + + if (size < 4 + *tag_size) + return FALSE; + + *tag_data = data + 4; + + return TRUE; +} + +void +gst_mxf_local_tag_free (MXFLocalTag * tag) +{ + g_free (tag->data); + g_slice_free (MXFLocalTag, tag); +} + +gboolean +gst_metadata_add_custom_tag (const MXFPrimerPack * primer, + guint16 tag, const guint8 * tag_data, guint16 tag_size, + GHashTable ** hash_table) +{ + MXFLocalTag *local_tag; + MXFUL *key; + + g_return_val_if_fail (primer != NULL, FALSE); + g_return_val_if_fail (tag_data != NULL, FALSE); + g_return_val_if_fail (hash_table != NULL, FALSE); + g_return_val_if_fail (primer->mappings != NULL, FALSE); + + if (*hash_table == NULL) + *hash_table = + g_hash_table_new_full ((GHashFunc) gst_mxf_ul_hash, + (GEqualFunc) gst_mxf_ul_equal, (GDestroyNotify) NULL, + (GDestroyNotify) gst_mxf_local_tag_free); + + g_return_val_if_fail (*hash_table != NULL, FALSE); + + key = (MXFUL *) g_hash_table_lookup (primer->mappings, + GUINT_TO_POINTER (((guint) tag))); + + if (key) { + gchar str[48]; + + GST_DEBUG ("Adding local tag 0x%04x with UL %s and size %u", tag, + mxf_ul_to_string (key, str), tag_size); + + local_tag = g_slice_new (MXFLocalTag); + memcpy (&local_tag->key, key, sizeof (MXFUL)); + local_tag->size = tag_size; + local_tag->data = g_memdup (tag_data, tag_size); + + g_hash_table_insert (*hash_table, &local_tag->key, local_tag); + } else { + GST_WARNING ("Local tag with no entry in primer pack: 0x%04x", tag); + } + + return TRUE; +} + +/* All following defined in SMPTE 377M Annex A, B, C, D */ +gboolean +mxf_metadata_preface_parse (const MXFUL * key, + MXFMetadataPreface * preface, const MXFPrimerPack * primer, + const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + gint i; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (preface, 0, sizeof (MXFMetadataPreface)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&preface->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&preface->generation_uid, tag_data, 16); + break; + case 0x3b02: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!mxf_timestamp_parse (&preface->last_modified_date, tag_data, + tag_size)) + goto error; + break; + case 0x3b05: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 2) + goto error; + preface->version = GST_READ_UINT16_BE (tag_data); + break; + case 0x3b07: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + preface->object_model_version = GST_READ_UINT32_BE (tag_data); + break; + case 0x3b08: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&preface->primary_package_uid, tag_data, 16); + break; + case 0x3b06:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + if (tag_size < 8) + goto error; + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + preface->n_identifications = len; + preface->identifications_uids = g_new (MXFUL, len); + for (i = 0; i < len; i++) + memcpy (&preface->identifications_uids[i], tag_data + 8 + i * 16, 16); + break; + } + case 0x3b03: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&preface->content_storage_uid, tag_data, 16); + break; + case 0x3b09: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&preface->operational_pattern, tag_data, 16); + break; + case 0x3b0a:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + if (tag_size < 8) + goto error; + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + preface->n_essence_containers = len; + preface->essence_containers = g_new (MXFUL, len); + for (i = 0; i < len; i++) + memcpy (&preface->essence_containers[i], tag_data + 8 + i * 16, 16); + break; + } + case 0x3b0b:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + if (tag_size < 8) + goto error; + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + preface->n_dm_schemes = len; + preface->dm_schemes = g_new (MXFUL, len); + for (i = 0; i < len; i++) + memcpy (&preface->dm_schemes[i], tag_data + 8 + i * 16, 16); + break; + } + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &preface->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed preface:"); + GST_DEBUG (" instance uid = %s", mxf_ul_to_string (&preface->instance_uid, + str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&preface->generation_uid, str)); + GST_DEBUG (" last modified date = %d/%u/%u %u:%u:%u.%u", + preface->last_modified_date.year, preface->last_modified_date.month, + preface->last_modified_date.day, preface->last_modified_date.hour, + preface->last_modified_date.minute, preface->last_modified_date.second, + (preface->last_modified_date.quarter_msecond * 1000) / 256); + GST_DEBUG (" version = %u.%u", (preface->version >> 8), + (preface->version & 0x0f)); + GST_DEBUG (" object model version = %u", preface->object_model_version); + GST_DEBUG (" primary package = %s", + mxf_ul_to_string (&preface->primary_package_uid, str)); + GST_DEBUG (" content storage = %s", + mxf_ul_to_string (&preface->content_storage_uid, str)); + GST_DEBUG (" operational pattern = %s", + mxf_ul_to_string (&preface->operational_pattern, str)); + GST_DEBUG (" number of identifications = %u", preface->n_identifications); + GST_DEBUG (" number of essence containers = %u", + preface->n_essence_containers); + GST_DEBUG (" number of DM schemes = %u", preface->n_dm_schemes); + + for (i = 0; i < preface->n_identifications; i++) + GST_DEBUG (" identification %d = %s", i, + mxf_ul_to_string (&preface->identifications_uids[i], str)); + + for (i = 0; i < preface->n_essence_containers; i++) + GST_DEBUG (" essence container %d = %s", i, + mxf_ul_to_string (&preface->essence_containers[i], str)); + + for (i = 0; i < preface->n_dm_schemes; i++) + GST_DEBUG (" DM schemes %d = %s", i, + mxf_ul_to_string (&preface->dm_schemes[i], str)); + + return TRUE; + +error: + GST_ERROR ("Invalid preface"); + mxf_metadata_preface_reset (preface); + + return FALSE; +} + +void +mxf_metadata_preface_reset (MXFMetadataPreface * preface) +{ + g_return_if_fail (preface != NULL); + + g_free (preface->identifications_uids); + g_free (preface->identifications); + g_free (preface->essence_containers); + g_free (preface->dm_schemes); + + if (preface->other_tags) + g_hash_table_destroy (preface->other_tags); + + memset (preface, 0, sizeof (MXFMetadataPreface)); +} + +gboolean +mxf_metadata_identification_parse (const MXFUL * key, + MXFMetadataIdentification * identification, + const MXFPrimerPack * primer, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (identification, 0, sizeof (MXFMetadataIdentification)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&identification->instance_uid, tag_data, 16); + break; + case 0x3c09: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&identification->generation_uid, tag_data, 16); + break; + case 0x3c01: + GST_WRITE_UINT16_BE (data, 0x0000); + identification->company_name = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + case 0x3c02: + GST_WRITE_UINT16_BE (data, 0x0000); + identification->product_name = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + case 0x3c03: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 10) + goto error; + if (!mxf_product_version_parse (&identification->product_version, + tag_data, tag_size)) + goto error; + break; + case 0x3c04: + GST_WRITE_UINT16_BE (data, 0x0000); + identification->version_string = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + case 0x3c05: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&identification->product_uid, tag_data, 16); + break; + case 0x3c06: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + if (!mxf_timestamp_parse (&identification->modification_date, tag_data, + tag_size)) + goto error; + break; + case 0x3c07: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 10) + goto error; + if (!mxf_product_version_parse (&identification->toolkit_version, + tag_data, tag_size)) + goto error; + break; + case 0x3c08: + GST_WRITE_UINT16_BE (data, 0x0000); + identification->platform = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &identification->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed identification:"); + GST_DEBUG (" instance uid = %s", + mxf_ul_to_string (&identification->instance_uid, str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&identification->generation_uid, str)); + GST_DEBUG (" company name = %s", + GST_STR_NULL (identification->company_name)); + GST_DEBUG (" product version = %u.%u.%u.%u.%u", + identification->product_version.major, + identification->product_version.minor, + identification->product_version.patch, + identification->product_version.build, + identification->product_version.release); + GST_DEBUG (" version string = %s", + GST_STR_NULL (identification->version_string)); + GST_DEBUG (" product uid = %s", + mxf_ul_to_string (&identification->product_uid, str)); + GST_DEBUG (" modification date = %d/%u/%u %u:%u:%u.%u", + identification->modification_date.year, + identification->modification_date.month, + identification->modification_date.day, + identification->modification_date.hour, + identification->modification_date.minute, + identification->modification_date.second, + (identification->modification_date.quarter_msecond * 1000) / 256); + GST_DEBUG (" toolkit version = %u.%u.%u.%u.%u", + identification->toolkit_version.major, + identification->toolkit_version.minor, + identification->toolkit_version.patch, + identification->toolkit_version.build, + identification->toolkit_version.release); + GST_DEBUG (" platform = %s", GST_STR_NULL (identification->platform)); + + return TRUE; + +error: + GST_ERROR ("Invalid identification"); + mxf_metadata_identification_reset (identification); + + return FALSE; +} + +void mxf_metadata_identification_reset + (MXFMetadataIdentification * identification) +{ + g_return_if_fail (identification != NULL); + + g_free (identification->company_name); + g_free (identification->product_name); + g_free (identification->version_string); + g_free (identification->platform); + + if (identification->other_tags) + g_hash_table_destroy (identification->other_tags); + + memset (identification, 0, sizeof (MXFMetadataIdentification)); +} + +gboolean +mxf_metadata_content_storage_parse (const MXFUL * key, + MXFMetadataContentStorage * content_storage, + const MXFPrimerPack * primer, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + gint i; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (content_storage, 0, sizeof (MXFMetadataContentStorage)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&content_storage->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&content_storage->generation_uid, tag_data, 16); + break; + case 0x1901:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + content_storage->packages_uids = g_new (MXFUL, len); + content_storage->n_packages = len; + for (i = 0; i < len; i++) + memcpy (&content_storage->packages_uids[i], tag_data + 8 + i * 16, + 16); + break; + } + case 0x1902:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + content_storage->essence_container_data_uids = g_new (MXFUL, len); + content_storage->n_essence_container_data = len; + for (i = 0; i < len; i++) + memcpy (&content_storage->essence_container_data_uids[i], + tag_data + 8 + i * 16, 16); + break; + } + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &content_storage->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed content storage:"); + GST_DEBUG (" instance uid = %s", + mxf_ul_to_string (&content_storage->instance_uid, str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&content_storage->generation_uid, str)); + GST_DEBUG (" number of packages = %u", content_storage->n_packages); + GST_DEBUG (" number of essence container data = %u", + content_storage->n_essence_container_data); + + for (i = 0; i < content_storage->n_packages; i++) + GST_DEBUG (" package %i = %s", i, + mxf_ul_to_string (&content_storage->packages_uids[i], str)); + for (i = 0; i < content_storage->n_packages; i++) + GST_DEBUG (" essence container data %i = %s", i, + mxf_ul_to_string (&content_storage->essence_container_data_uids[i], + str)); + + return TRUE; + +error: + GST_ERROR ("Invalid content storage"); + mxf_metadata_content_storage_reset (content_storage); + + return FALSE; +} + +void mxf_metadata_content_storage_reset + (MXFMetadataContentStorage * content_storage) +{ + g_return_if_fail (content_storage != NULL); + + g_free (content_storage->packages); + g_free (content_storage->packages_uids); + g_free (content_storage->essence_container_data); + g_free (content_storage->essence_container_data_uids); + + if (content_storage->other_tags) + g_hash_table_destroy (content_storage->other_tags); + + memset (content_storage, 0, sizeof (MXFMetadataContentStorage)); +} + +gboolean +mxf_metadata_essence_container_data_parse (const MXFUL * key, + MXFMetadataEssenceContainerData * essence_container_data, + const MXFPrimerPack * primer, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[96]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (essence_container_data, 0, sizeof (MXFMetadataEssenceContainerData)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&essence_container_data->instance_uid, tag_data, 16); + break; + case 0x2701: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 32) + goto error; + memcpy (&essence_container_data->linked_package_uid, tag_data, 32); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&essence_container_data->generation_uid, tag_data, 16); + break; + case 0x3f06: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + essence_container_data->index_sid = GST_READ_UINT32_BE (tag_data); + break; + case 0x3f07: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + essence_container_data->body_sid = GST_READ_UINT32_BE (tag_data); + break; + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &essence_container_data->other_tags)) + goto error; + break; + } + next: + + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed essence container data:"); + GST_DEBUG (" instance uid = %s", + mxf_ul_to_string (&essence_container_data->instance_uid, str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&essence_container_data->generation_uid, str)); + GST_DEBUG (" linked package = %s", + mxf_umid_to_string (&essence_container_data->linked_package_uid, str)); + GST_DEBUG (" index sid = %u", essence_container_data->index_sid); + GST_DEBUG (" body sid = %u", essence_container_data->body_sid); + + return TRUE; + +error: + GST_ERROR ("Invalid essence container data"); + mxf_metadata_essence_container_data_reset (essence_container_data); + + return FALSE; +} + +void mxf_metadata_essence_container_data_reset + (MXFMetadataEssenceContainerData * essence_container_data) +{ + g_return_if_fail (essence_container_data != NULL); + + if (essence_container_data->other_tags) + g_hash_table_destroy (essence_container_data->other_tags); + + memset (essence_container_data, 0, sizeof (MXFMetadataEssenceContainerData)); +} + +gboolean +mxf_metadata_generic_package_parse (const MXFUL * key, + MXFMetadataGenericPackage * generic_package, + const MXFPrimerPack * primer, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[96]; + gint i; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (generic_package, 0, sizeof (MXFMetadataGenericPackage)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&generic_package->instance_uid, tag_data, 16); + break; + case 0x4401: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 32) + goto error; + memcpy (&generic_package->package_uid, tag_data, 32); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&generic_package->generation_uid, tag_data, 16); + break; + case 0x4402: + generic_package->name = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + case 0x4405: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!mxf_timestamp_parse (&generic_package->package_creation_date, + tag_data, tag_size)) + goto error; + break; + case 0x4404: + if (!mxf_timestamp_parse (&generic_package->package_modified_date, + tag_data, tag_size)) + goto error; + break; + case 0x4403:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + generic_package->tracks_uids = g_new (MXFUL, len); + generic_package->n_tracks = len; + for (i = 0; i < len; i++) + memcpy (&generic_package->tracks_uids[i], tag_data + 8 + i * 16, 16); + break; + } + case 0x4701: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + + generic_package->n_descriptors = 1; + memcpy (&generic_package->descriptors_uid, tag_data, 16); + break; + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &generic_package->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed package:"); + GST_DEBUG (" instance uid = %s", + mxf_ul_to_string (&generic_package->instance_uid, str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&generic_package->generation_uid, str)); + GST_DEBUG (" UMID = %s", mxf_umid_to_string (&generic_package->package_uid, + str)); + GST_DEBUG (" name = %s", GST_STR_NULL (generic_package->name)); + GST_DEBUG (" creation date = %d/%u/%u %u:%u:%u.%u", + generic_package->package_creation_date.year, + generic_package->package_creation_date.month, + generic_package->package_creation_date.day, + generic_package->package_creation_date.hour, + generic_package->package_creation_date.minute, + generic_package->package_creation_date.second, + (generic_package->package_creation_date.quarter_msecond * 1000) / 256); + GST_DEBUG (" modification date = %d/%u/%u %u:%u:%u.%u", + generic_package->package_modified_date.year, + generic_package->package_modified_date.month, + generic_package->package_modified_date.day, + generic_package->package_modified_date.hour, + generic_package->package_modified_date.minute, + generic_package->package_modified_date.second, + (generic_package->package_modified_date.quarter_msecond * 1000) / 256); + GST_DEBUG (" descriptor = %s", + mxf_ul_to_string (&generic_package->descriptors_uid, str)); + GST_DEBUG (" number of tracks = %u", generic_package->n_tracks); + + for (i = 0; i < generic_package->n_tracks; i++) + GST_DEBUG (" track %d = %s", i, + mxf_ul_to_string (&generic_package->tracks_uids[i], str)); + + return TRUE; + +error: + GST_ERROR ("Invalid package"); + mxf_metadata_generic_package_reset (generic_package); + + return FALSE; +} + +void mxf_metadata_generic_package_reset + (MXFMetadataGenericPackage * generic_package) +{ + g_return_if_fail (generic_package != NULL); + + g_free (generic_package->name); + g_free (generic_package->tracks_uids); + + g_free (generic_package->tracks); + + if (generic_package->other_tags) + g_hash_table_destroy (generic_package->other_tags); + + g_free (generic_package->descriptors); + + memset (generic_package, 0, sizeof (MXFMetadataGenericPackage)); +} + +gboolean +mxf_metadata_track_parse (const MXFUL * key, + MXFMetadataTrack * track, const MXFPrimerPack * primer, + const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (track, 0, sizeof (MXFMetadataTrack)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&track->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&track->generation_uid, tag_data, 16); + break; + case 0x4801: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + track->track_id = GST_READ_UINT32_BE (tag_data); + break; + case 0x4804: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + track->track_number = GST_READ_UINT32_BE (tag_data); + break; + case 0x4802: + GST_WRITE_UINT16_BE (data, 0x0000); + track->track_name = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + case 0x4b01: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!mxf_fraction_parse (&track->edit_rate, tag_data, tag_size)) + goto error; + break; + case 0x4b02: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + track->origin = GST_READ_UINT64_BE (tag_data); + break; + case 0x4803: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&track->sequence_uid, tag_data, 16); + break; + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &track->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed track:"); + GST_DEBUG (" instance uid = %s", mxf_ul_to_string (&track->instance_uid, + str)); + GST_DEBUG (" generation uid = %s", mxf_ul_to_string (&track->generation_uid, + str)); + GST_DEBUG (" track id = %u", track->track_id); + GST_DEBUG (" track number = %u", track->track_number); + GST_DEBUG (" track name = %s", GST_STR_NULL (track->track_name)); + GST_DEBUG (" edit rate = %d/%d", track->edit_rate.n, track->edit_rate.d); + GST_DEBUG (" origin = %" G_GINT64_FORMAT, track->origin); + GST_DEBUG (" sequence uid = %s", mxf_ul_to_string (&track->sequence_uid, + str)); + + return TRUE; + +error: + GST_ERROR ("Invalid track"); + mxf_metadata_track_reset (track); + + return FALSE; +} + +void +mxf_metadata_track_reset (MXFMetadataTrack * track) +{ + g_return_if_fail (track != NULL); + + g_free (track->track_name); + + if (track->descriptor) + g_free (track->descriptor); + + if (track->other_tags) + g_hash_table_destroy (track->other_tags); + + memset (track, 0, sizeof (MXFMetadataTrack)); +} + +/* SMPTE RP224 */ +static const struct +{ + guint8 ul[16]; + MXFMetadataTrackType type; +} mxf_metadata_track_identifier[] = { + { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, + 0x01, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00}, + MXF_METADATA_TRACK_TIMECODE_12M_INACTIVE}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01, + 0x02, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_TIMECODE_12M_ACTIVE}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01, + 0x03, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_TIMECODE_309M}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01, + 0x10, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_METADATA}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02, + 0x01, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_PICTURE_ESSENCE}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02, + 0x02, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_SOUND_ESSENCE}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02, + 0x03, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_DATA_ESSENCE}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03, + 0x01, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_AUXILIARY_DATA}, { { + 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03, + 0x02, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_PARSED_TEXT} +}; + +MXFMetadataTrackType +mxf_metadata_track_identifier_parse (const MXFUL * track_identifier) +{ + guint i; + + for (i = 0; i < G_N_ELEMENTS (mxf_metadata_track_identifier); i++) + if (memcmp (&mxf_metadata_track_identifier[i].ul, &track_identifier->u, + 16) == 0) + return mxf_metadata_track_identifier[i].type; + + return MXF_METADATA_TRACK_UNKNOWN; +} + +gboolean +mxf_metadata_sequence_parse (const MXFUL * key, + MXFMetadataSequence * sequence, const MXFPrimerPack * primer, + const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + gint i; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (sequence, 0, sizeof (MXFMetadataSequence)); + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&sequence->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&sequence->generation_uid, tag_data, 16); + break; + case 0x0201: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&sequence->data_definition, tag_data, 16); + break; + case 0x0202: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + sequence->duration = GST_READ_UINT64_BE (tag_data); + break; + case 0x1001:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + break; + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + if (tag_size < 8 + len * 16) + goto error; + + sequence->structural_components_uids = g_new (MXFUL, len); + sequence->n_structural_components = len; + for (i = 0; i < len; i++) + memcpy (&sequence->structural_components_uids[i], + tag_data + 8 + i * 16, 16); + break; + } + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &sequence->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed sequence:"); + GST_DEBUG (" instance uid = %s", mxf_ul_to_string (&sequence->instance_uid, + str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&sequence->generation_uid, str)); + GST_DEBUG (" data definition = %s", + mxf_ul_to_string (&sequence->data_definition, str)); + GST_DEBUG (" duration = %" G_GINT64_FORMAT, sequence->duration); + GST_DEBUG (" number of structural components = %u", + sequence->n_structural_components); + + for (i = 0; i < sequence->n_structural_components; i++) + GST_DEBUG (" structural component %d = %s", i, + mxf_ul_to_string (&sequence->structural_components_uids[i], str)); + + + return TRUE; + +error: + GST_ERROR ("Invalid sequence"); + mxf_metadata_sequence_reset (sequence); + + return FALSE; +} + +void +mxf_metadata_sequence_reset (MXFMetadataSequence * sequence) +{ + g_return_if_fail (sequence != NULL); + + g_free (sequence->structural_components_uids); + g_free (sequence->structural_components); + + if (sequence->other_tags) + g_hash_table_destroy (sequence->other_tags); + + memset (sequence, 0, sizeof (MXFMetadataSequence)); +} + +gboolean +mxf_metadata_structural_component_parse (const MXFUL * key, + MXFMetadataStructuralComponent * component, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[96]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (component, 0, sizeof (MXFMetadataStructuralComponent)); + + component->type = type; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&component->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&component->generation_uid, tag_data, 16); + break; + case 0x0201: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&component->data_definition, tag_data, 16); + break; + case 0x0202: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + component->duration = GST_READ_UINT64_BE (tag_data); + break; + /* Timecode component specifics */ + case 0x1502: + if (type != MXF_METADATA_TIMECODE_COMPONENT) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 2) + goto error; + component->timecode_component.rounded_timecode_base = + GST_READ_UINT16_BE (tag_data); + break; + case 0x1501: + if (type != MXF_METADATA_TIMECODE_COMPONENT) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + component->timecode_component.start_timecode = + GST_READ_UINT64_BE (tag_data); + break; + case 0x1503: + if (type != MXF_METADATA_TIMECODE_COMPONENT) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + component->timecode_component.drop_frame = + (GST_READ_UINT8 (tag_data) != 0); + break; + /* Source clip specifics */ + case 0x1201: + if (type != MXF_METADATA_SOURCE_CLIP) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + component->source_clip.start_position = GST_READ_UINT64_BE (tag_data); + break; + case 0x1101: + if (type != MXF_METADATA_SOURCE_CLIP) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 32) + goto error; + memcpy (&component->source_clip.source_package_id, tag_data, 32); + break; + case 0x1102: + if (type != MXF_METADATA_SOURCE_CLIP) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + component->source_clip.source_track_id = GST_READ_UINT32_BE (tag_data); + break; + DFLT: + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &component->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed structural component:"); + GST_DEBUG (" instance uid = %s", mxf_ul_to_string (&component->instance_uid, + str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&component->generation_uid, str)); + GST_DEBUG (" type = %s", + (component->type == + MXF_METADATA_TIMECODE_COMPONENT) ? "timecode component" : + "source clip"); + GST_DEBUG (" data definition = %s", + mxf_ul_to_string (&component->data_definition, str)); + GST_DEBUG (" duration = %" G_GINT64_FORMAT, component->duration); + + if (component->type == MXF_METADATA_TIMECODE_COMPONENT) { + GST_DEBUG (" start timecode = %" G_GINT64_FORMAT, + component->timecode_component.start_timecode); + GST_DEBUG (" rounded timecode base = %u", + component->timecode_component.rounded_timecode_base); + GST_DEBUG (" drop frame = %s", + (component->timecode_component.drop_frame) ? "yes" : "no"); + } else { + GST_DEBUG (" start position = %" G_GINT64_FORMAT, + component->source_clip.start_position); + GST_DEBUG (" source package id = %s", + mxf_umid_to_string (&component->source_clip.source_package_id, str)); + GST_DEBUG (" source track id = %u", + component->source_clip.source_track_id); + } + + return TRUE; + +error: + GST_ERROR ("Invalid structural component"); + mxf_metadata_structural_component_reset (component); + + return FALSE; +} + +void mxf_metadata_structural_component_reset + (MXFMetadataStructuralComponent * component) +{ + g_return_if_fail (component != NULL); + + if (component->other_tags) + g_hash_table_destroy (component->other_tags); + + memset (component, 0, sizeof (MXFMetadataStructuralComponent)); +} + +gboolean +mxf_metadata_generic_descriptor_parse (const MXFUL * key, + MXFMetadataGenericDescriptor * descriptor, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + gint i; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (descriptor, 0, sizeof (MXFMetadataGenericDescriptor)); + + descriptor->type = type; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->generation_uid, tag_data, 16); + break; + case 0x2f01:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size < 8) + goto error; + + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + goto next; + + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + + descriptor->locators_uids = g_new (MXFUL, len); + descriptor->n_locators = len; + for (i = 0; i < len; i++) + memcpy (&descriptor->locators_uids[i], tag_data + 8 + i * 16, 16); + break; + } + } + next: + + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed generic descriptor:"); + GST_DEBUG (" instance uid = %s", mxf_ul_to_string (&descriptor->instance_uid, + str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&descriptor->generation_uid, str)); + GST_DEBUG (" type = %u", descriptor->type); + GST_DEBUG (" number of locators = %u", descriptor->n_locators); + + for (i = 0; i < descriptor->n_locators; i++) + GST_DEBUG (" locator %d = %s", i, + mxf_ul_to_string (&descriptor->locators_uids[i], str)); + + return TRUE; + +error: + GST_ERROR ("Invalid generic descriptor"); + mxf_metadata_generic_descriptor_reset (descriptor); + + return FALSE; +} + +void mxf_metadata_generic_descriptor_reset + (MXFMetadataGenericDescriptor * descriptor) +{ + g_return_if_fail (descriptor != NULL); + + switch (descriptor->type) { + case MXF_METADATA_FILE_DESCRIPTOR: + break; + } + + if (descriptor->locators_uids) + g_free (descriptor->locators_uids); + + if (descriptor->locators) + g_free (descriptor->locators); + + if (descriptor->other_tags) + g_hash_table_destroy (descriptor->other_tags); + + memset (descriptor, 0, sizeof (MXFMetadataGenericDescriptor)); +} + +gboolean +mxf_metadata_file_descriptor_parse (const MXFUL * key, + MXFMetadataFileDescriptor * descriptor, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (descriptor, 0, sizeof (MXFMetadataFileDescriptor)); + + if (!mxf_metadata_generic_descriptor_parse (key, + (MXFMetadataGenericDescriptor *) descriptor, primer, type, data, + size)) + goto error; + + descriptor->parent.is_file_descriptor = TRUE; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3006: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->linked_track_id = GST_READ_UINT32_BE (tag_data); + break; + case 0x3001: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!mxf_fraction_parse (&descriptor->sample_rate, tag_data, tag_size)) + goto error; + break; + case 0x3002: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 8) + goto error; + descriptor->container_duration = GST_READ_UINT64_BE (tag_data); + break; + case 0x3004: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->essence_container, tag_data, 16); + break; + case 0x3005: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->codec, tag_data, 16); + break; + default: + if (type != MXF_METADATA_FILE_DESCRIPTOR) + goto next; + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &((MXFMetadataGenericDescriptor *) descriptor)->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed file descriptor:"); + GST_DEBUG (" linked track id = %u", descriptor->linked_track_id); + GST_DEBUG (" sample rate = %d/%d", descriptor->sample_rate.n, + descriptor->sample_rate.d); + GST_DEBUG (" container duration = %" G_GINT64_FORMAT, + descriptor->container_duration); + GST_DEBUG (" essence container = %s", + mxf_ul_to_string (&descriptor->essence_container, str)); + GST_DEBUG (" codec = %s", mxf_ul_to_string (&descriptor->codec, str)); + + return TRUE; + +error: + GST_ERROR ("Invalid file descriptor"); + mxf_metadata_file_descriptor_reset (descriptor); + + return FALSE; +} + +void +mxf_metadata_file_descriptor_reset (MXFMetadataFileDescriptor * descriptor) +{ + g_return_if_fail (descriptor != NULL); + + mxf_metadata_generic_descriptor_reset ((MXFMetadataGenericDescriptor *) + descriptor); + + memset (descriptor, 0, sizeof (MXFMetadataFileDescriptor)); +} + +gboolean +mxf_metadata_generic_sound_essence_descriptor_parse (const MXFUL * key, + MXFMetadataGenericSoundEssenceDescriptor * descriptor, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (descriptor, 0, sizeof (MXFMetadataGenericSoundEssenceDescriptor)); + + if (!mxf_metadata_file_descriptor_parse (key, + (MXFMetadataFileDescriptor *) descriptor, primer, type, data, size)) + goto error; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3d03: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!mxf_fraction_parse (&descriptor->audio_sampling_rate, tag_data, + tag_size)) + goto error; + break; + case 0x3d02: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->locked = (GST_READ_UINT8 (tag_data) != 0); + break; + case 0x3d04: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->audio_ref_level = GST_READ_UINT8 (tag_data); + break; + case 0x3d05: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->electro_spatial_formulation = GST_READ_UINT8 (tag_data); + break; + case 0x3d07: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->channel_count = GST_READ_UINT32_BE (tag_data); + break; + case 0x3d01: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->quantization_bits = GST_READ_UINT32_BE (tag_data); + break; + case 0x3d0c: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->dial_norm = GST_READ_UINT8 (tag_data); + break; + case 0x3d06: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->sound_essence_compression, tag_data, 16); + break; + default: + if (type != MXF_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR) + goto next; + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &((MXFMetadataGenericDescriptor *) descriptor)->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed generic sound essence descriptor:"); + GST_DEBUG (" audio sampling rate = %d/%d", descriptor->audio_sampling_rate.n, + descriptor->audio_sampling_rate.d); + GST_DEBUG (" locked = %s", (descriptor->locked) ? "yes" : "no"); + GST_DEBUG (" audio ref level = %d", descriptor->audio_ref_level); + GST_DEBUG (" electro spatial formulation = %u", + descriptor->electro_spatial_formulation); + GST_DEBUG (" channel count = %u", descriptor->channel_count); + GST_DEBUG (" quantization bits = %u", descriptor->quantization_bits); + GST_DEBUG (" dial norm = %d", descriptor->dial_norm); + GST_DEBUG (" sound essence compression = %s", + mxf_ul_to_string (&descriptor->sound_essence_compression, str)); + + return TRUE; + +error: + GST_ERROR ("Invalid generic sound essence descriptor"); + mxf_metadata_generic_sound_essence_descriptor_reset (descriptor); + + return FALSE; +} + +void mxf_metadata_generic_sound_essence_descriptor_reset + (MXFMetadataGenericSoundEssenceDescriptor * descriptor) +{ + g_return_if_fail (descriptor != NULL); + + mxf_metadata_file_descriptor_reset ((MXFMetadataFileDescriptor *) descriptor); + + memset (descriptor, 0, sizeof (MXFMetadataGenericSoundEssenceDescriptor)); +} + +gboolean +mxf_metadata_generic_picture_essence_descriptor_parse (const MXFUL * key, + MXFMetadataGenericPictureEssenceDescriptor * descriptor, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (descriptor, 0, sizeof (MXFMetadataGenericPictureEssenceDescriptor)); + + if (!mxf_metadata_file_descriptor_parse (key, + (MXFMetadataFileDescriptor *) descriptor, primer, type, data, size)) + goto error; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3215: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->signal_standard = GST_READ_UINT8 (tag_data); + break; + case 0x320c: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->frame_layout = GST_READ_UINT8 (tag_data); + break; + case 0x3203: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->stored_width = GST_READ_UINT32_BE (tag_data); + break; + case 0x3202: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->stored_height = GST_READ_UINT32_BE (tag_data); + break; + case 0x3216: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->stored_f2_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3205: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->sampled_width = GST_READ_UINT32_BE (tag_data); + break; + case 0x3204: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->sampled_height = GST_READ_UINT32_BE (tag_data); + break; + case 0x3206: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->sampled_x_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3207: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->sampled_y_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3208: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->display_height = GST_READ_UINT32_BE (tag_data); + break; + case 0x3209: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->display_width = GST_READ_UINT32_BE (tag_data); + break; + case 0x320a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->display_x_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x320b: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->display_y_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3217: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->display_f2_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x320e: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!mxf_fraction_parse (&descriptor->aspect_ratio, tag_data, tag_size)) + goto error; + break; + case 0x3218: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->active_format_descriptor = GST_READ_UINT8 (tag_data); + break; + case 0x320d: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size < 8) + goto error; + + if (GST_READ_UINT32_BE (tag_data) == 0) + goto next; + + if (GST_READ_UINT32_BE (tag_data) != 2 && + GST_READ_UINT32_BE (tag_data + 4) != 4) + goto error; + + if (tag_size != 16) + goto error; + + descriptor->video_line_map[0] = GST_READ_UINT32_BE (tag_data + 8); + descriptor->video_line_map[1] = GST_READ_UINT32_BE (tag_data + 12); + break; + case 0x320f: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->alpha_transparency = GST_READ_UINT8 (tag_data); + break; + case 0x3210: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->capture_gamma, tag_data, 16); + break; + case 0x3211: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->image_alignment_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3213: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->image_start_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3214: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->image_end_offset = GST_READ_UINT32_BE (tag_data); + break; + case 0x3212: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->field_dominance = GST_READ_UINT8 (tag_data); + break; + case 0x3201: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&descriptor->picture_essence_coding, tag_data, 16); + break; + default: + if (type != MXF_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR) + goto next; + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &((MXFMetadataGenericDescriptor *) descriptor)->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed generic picture essence descriptor:"); + GST_DEBUG (" signal standard = %u", descriptor->signal_standard); + GST_DEBUG (" frame layout = %u", descriptor->frame_layout); + GST_DEBUG (" stored size = %ux%u (f2 = %d)", descriptor->stored_width, + descriptor->stored_height, descriptor->stored_f2_offset); + GST_DEBUG (" sampled size = %ux%u (offset = %d x %d)", + descriptor->sampled_width, descriptor->sampled_height, + descriptor->sampled_x_offset, descriptor->sampled_y_offset); + GST_DEBUG (" display size = %ux%u (f2 = %d, offset = %d x %d)", + descriptor->display_height, descriptor->display_width, + descriptor->display_x_offset, descriptor->display_y_offset, + descriptor->display_f2_offset); + GST_DEBUG (" aspect ratio = %d/%d", descriptor->aspect_ratio.n, + descriptor->aspect_ratio.d); + GST_DEBUG (" active format descriptor = %u", + descriptor->active_format_descriptor); + GST_DEBUG (" video line map = {%i, %i}", descriptor->video_line_map[0], + descriptor->video_line_map[1]); + GST_DEBUG (" alpha transparency = %u", descriptor->alpha_transparency); + GST_DEBUG (" capture gamma = %s", + mxf_ul_to_string (&descriptor->capture_gamma, str)); + GST_DEBUG (" image alignment offset = %u", + descriptor->image_alignment_offset); + GST_DEBUG (" image start offset = %u", descriptor->image_start_offset); + GST_DEBUG (" image end offset = %u", descriptor->image_end_offset); + GST_DEBUG (" field dominance = %u", descriptor->field_dominance); + GST_DEBUG (" picture essence coding = %s", + mxf_ul_to_string (&descriptor->picture_essence_coding, str)); + + return TRUE; + +error: + GST_ERROR ("Invalid generic picture essence descriptor"); + mxf_metadata_generic_picture_essence_descriptor_reset (descriptor); + + return FALSE; +} + +void mxf_metadata_generic_picture_essence_descriptor_reset + (MXFMetadataGenericPictureEssenceDescriptor * descriptor) +{ + g_return_if_fail (descriptor != NULL); + + mxf_metadata_file_descriptor_reset ((MXFMetadataFileDescriptor *) descriptor); + + memset (descriptor, 0, sizeof (MXFMetadataGenericPictureEssenceDescriptor)); +} + +gboolean +mxf_metadata_cdci_picture_essence_descriptor_parse (const MXFUL * key, + MXFMetadataCDCIPictureEssenceDescriptor * descriptor, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (descriptor, 0, sizeof (MXFMetadataCDCIPictureEssenceDescriptor)); + + if (!mxf_metadata_generic_picture_essence_descriptor_parse (key, + (MXFMetadataGenericPictureEssenceDescriptor *) descriptor, primer, + type, data, size)) + goto error; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3301: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->component_depth = GST_READ_UINT32_BE (tag_data); + break; + case 0x3302: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->horizontal_subsampling = GST_READ_UINT32_BE (tag_data); + break; + case 0x3308: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->vertical_subsampling = GST_READ_UINT32_BE (tag_data); + break; + case 0x3303: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->color_siting = GST_READ_UINT8 (tag_data); + break; + case 0x330b: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 1) + goto error; + descriptor->reversed_byte_order = GST_READ_UINT8 (tag_data); + break; + case 0x3307: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 2) + goto error; + descriptor->padding_bits = GST_READ_UINT16_BE (tag_data); + break; + case 0x3309: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->alpha_sample_depth = GST_READ_UINT32_BE (tag_data); + break; + case 0x3304: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->black_ref_level = GST_READ_UINT32_BE (tag_data); + break; + case 0x3305: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->white_ref_level = GST_READ_UINT32_BE (tag_data); + break; + case 0x3306: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 4) + goto error; + descriptor->color_range = GST_READ_UINT32_BE (tag_data); + break; + default: + if (type != MXF_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR) + goto next; + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &((MXFMetadataGenericDescriptor *) descriptor)->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed CDCI picture essence descriptor:"); + GST_DEBUG (" component depth = %u", descriptor->component_depth); + GST_DEBUG (" horizontal subsampling = %u", + descriptor->horizontal_subsampling); + GST_DEBUG (" vertical subsampling = %u", descriptor->vertical_subsampling); + GST_DEBUG (" color siting = %u", descriptor->color_siting); + GST_DEBUG (" reversed byte order = %s", + (descriptor->reversed_byte_order) ? "yes" : "no"); + GST_DEBUG (" padding bits = %d", descriptor->padding_bits); + GST_DEBUG (" alpha sample depth = %u", descriptor->alpha_sample_depth); + GST_DEBUG (" black ref level = %u", descriptor->black_ref_level); + GST_DEBUG (" white ref level = %u", descriptor->white_ref_level); + GST_DEBUG (" color range = %u", descriptor->color_range); + + return TRUE; + +error: + GST_ERROR ("Invalid CDCI picture essence descriptor"); + mxf_metadata_cdci_picture_essence_descriptor_reset (descriptor); + + return FALSE; +} + +void mxf_metadata_cdci_picture_essence_descriptor_reset + (MXFMetadataCDCIPictureEssenceDescriptor * descriptor) +{ + g_return_if_fail (descriptor != NULL); + + mxf_metadata_generic_picture_essence_descriptor_reset ( + (MXFMetadataGenericPictureEssenceDescriptor *) descriptor); + + memset (descriptor, 0, sizeof (MXFMetadataCDCIPictureEssenceDescriptor)); +} + +gboolean +mxf_metadata_multiple_descriptor_parse (const MXFUL * key, + MXFMetadataMultipleDescriptor * descriptor, + const MXFPrimerPack * primer, guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + gint i; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (descriptor, 0, sizeof (MXFMetadataMultipleDescriptor)); + + if (!mxf_metadata_file_descriptor_parse (key, + (MXFMetadataFileDescriptor *) descriptor, primer, type, data, size)) + goto error; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3f01:{ + guint32 len; + guint i; + + GST_WRITE_UINT16_BE (data, 0x0000); + + if (tag_size < 8) + goto error; + len = GST_READ_UINT32_BE (tag_data); + if (len == 0) + goto next; + + if (GST_READ_UINT32_BE (tag_data + 4) != 16) + goto error; + + descriptor->n_sub_descriptors = len; + descriptor->sub_descriptors_uids = g_new0 (MXFUL, len); + for (i = 0; i < len; i++) + memcpy (&descriptor->sub_descriptors_uids[i], tag_data + 8 + i * 16, + 16); + break; + } + default: + if (type != MXF_METADATA_MULTIPLE_DESCRIPTOR) + goto next; + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &((MXFMetadataGenericDescriptor *) descriptor)->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed multiple descriptor:"); + GST_DEBUG (" number of sub descriptors = %u", descriptor->n_sub_descriptors); + for (i = 0; i < descriptor->n_sub_descriptors; i++) + GST_DEBUG (" sub descriptor %d = %s", i, + mxf_ul_to_string (&descriptor->sub_descriptors_uids[i], str)); + + return TRUE; + +error: + GST_ERROR ("Invalid multiple descriptor"); + mxf_metadata_multiple_descriptor_reset (descriptor); + + return FALSE; +} + +void mxf_metadata_multiple_descriptor_reset + (MXFMetadataMultipleDescriptor * descriptor) +{ + g_return_if_fail (descriptor != NULL); + + g_free (descriptor->sub_descriptors_uids); + g_free (descriptor->sub_descriptors); + + mxf_metadata_file_descriptor_reset ((MXFMetadataFileDescriptor *) descriptor); + + memset (descriptor, 0, sizeof (MXFMetadataMultipleDescriptor)); +} + +gboolean +mxf_metadata_locator_parse (const MXFUL * key, + MXFMetadataLocator * locator, const MXFPrimerPack * primer, + guint16 type, const guint8 * data, gsize size) +{ + guint16 tag, tag_size; + const guint8 *tag_data; + gchar str[48]; + + g_return_val_if_fail (data != NULL, FALSE); + + memset (locator, 0, sizeof (MXFMetadataLocator)); + + locator->type = type; + + while (mxf_local_tag_parse (data, size, &tag, &tag_size, &tag_data)) { + if (tag_size == 0 || tag == 0x0000) + goto next; + + switch (tag) { + case 0x3c0a: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&locator->instance_uid, tag_data, 16); + break; + case 0x0102: + GST_WRITE_UINT16_BE (data, 0x0000); + if (tag_size != 16) + goto error; + memcpy (&locator->generation_uid, tag_data, 16); + break; + case 0x4101: + if (type != MXF_METADATA_TEXT_LOCATOR + && type != MXF_METADATA_NETWORK_LOCATOR) + goto DFLT; + GST_WRITE_UINT16_BE (data, 0x0000); + locator->location = mxf_utf16_to_utf8 (tag_data, tag_size); + break; + DFLT: + default: + GST_WRITE_UINT16_BE (data, 0x0000); + if (!gst_metadata_add_custom_tag (primer, tag, tag_data, tag_size, + &locator->other_tags)) + goto error; + break; + } + + next: + data += 4 + tag_size; + size -= 4 + tag_size; + } + + GST_DEBUG ("Parsed locator:"); + GST_DEBUG (" instance uid = %s", mxf_ul_to_string (&locator->instance_uid, + str)); + GST_DEBUG (" generation uid = %s", + mxf_ul_to_string (&locator->generation_uid, str)); + GST_DEBUG (" location = %s", GST_STR_NULL (locator->location)); + + return TRUE; + +error: + GST_ERROR ("Invalid locator"); + mxf_metadata_locator_reset (locator); + + return FALSE; +} + +void +mxf_metadata_locator_reset (MXFMetadataLocator * locator) +{ + g_return_if_fail (locator != NULL); + + if (locator->location) + g_free (locator->location); + + if (locator->other_tags) + g_hash_table_destroy (locator->other_tags); + + memset (locator, 0, sizeof (MXFMetadataLocator)); +} |