summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--gst/mxf/Makefile.am2
-rw-r--r--gst/mxf/mxf.c8
-rw-r--r--gst/mxf/mxfaes-bwf.c196
-rw-r--r--gst/mxf/mxfdemux.c12
-rw-r--r--gst/mxf/mxfmetadata.c1183
-rw-r--r--gst/mxf/mxfmetadata.h6
-rw-r--r--gst/mxf/mxfmpeg.c36
-rw-r--r--gst/mxf/mxfquark.c211
-rw-r--r--gst/mxf/mxfquark.h204
-rw-r--r--gst/mxf/mxftypes.h2
10 files changed, 1854 insertions, 6 deletions
diff --git a/gst/mxf/Makefile.am b/gst/mxf/Makefile.am
index 1a061387..499ac625 100644
--- a/gst/mxf/Makefile.am
+++ b/gst/mxf/Makefile.am
@@ -2,6 +2,7 @@ plugin_LTLIBRARIES = libgstmxf.la
libgstmxf_la_SOURCES = \
mxf.c \
+ mxfquark.c \
mxfdemux.c \
mxfparse.c \
mxfaes-bwf.c \
@@ -21,6 +22,7 @@ libgstmxf_la_LIBADD = $(GST_LIBS) $(GST_BASE_LIBS) $(GST_PLUGINS_BASE_LIBS) \
libgstmxf_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
noinst_HEADERS = \
+ mxfquark.h \
mxfdemux.h \
mxfparse.h \
mxfaes-bwf.h \
diff --git a/gst/mxf/mxf.c b/gst/mxf/mxf.c
index 58fa0302..ec477721 100644
--- a/gst/mxf/mxf.c
+++ b/gst/mxf/mxf.c
@@ -22,6 +22,7 @@
#include <gst/gst.h>
+#include "mxfquark.h"
#include "mxfdemux.h"
#include "mxfaes-bwf.h"
#include "mxfmpeg.h"
@@ -41,12 +42,19 @@ mxf_init (void)
{
gst_tag_register (GST_TAG_MXF_UMID, GST_TAG_FLAG_META,
G_TYPE_STRING, "UMID", "Unique Material Identifier", NULL);
+ gst_tag_register (GST_TAG_MXF_STRUCTURE, GST_TAG_FLAG_META,
+ GST_TYPE_STRUCTURE, "Structure", "Structural metadata of "
+ "the MXF file", NULL);
+ gst_tag_register (GST_TAG_MXF_DESCRIPTIVE_METADATA_FRAMEWORK,
+ GST_TAG_FLAG_META, GST_TYPE_STRUCTURE, "DM Framework",
+ "Descriptive metadata framework", NULL);
}
static gboolean
plugin_init (GstPlugin * plugin)
{
mxf_init ();
+ mxf_quark_initialize ();
mxf_metadata_init_types ();
mxf_aes_bwf_init ();
mxf_mpeg_init ();
diff --git a/gst/mxf/mxfaes-bwf.c b/gst/mxf/mxfaes-bwf.c
index 364cfb7f..7a3ad4ec 100644
--- a/gst/mxf/mxfaes-bwf.c
+++ b/gst/mxf/mxfaes-bwf.c
@@ -36,6 +36,7 @@
#include <string.h>
#include "mxfaes-bwf.h"
+#include "mxfquark.h"
GST_DEBUG_CATEGORY_EXTERN (mxf_debug);
#define GST_CAT_DEFAULT mxf_debug
@@ -231,6 +232,79 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_wave_audio_essence_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_wave_audio_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataWaveAudioEssenceDescriptor *self =
+ MXF_METADATA_WAVE_AUDIO_ESSENCE_DESCRIPTOR (m);
+ gchar str[48];
+
+ gst_structure_id_set (ret, MXF_QUARK (BLOCK_ALIGN), G_TYPE_UINT,
+ self->block_align, NULL);
+
+ if (self->sequence_offset)
+ gst_structure_id_set (ret, MXF_QUARK (SEQUENCE_OFFSET), G_TYPE_UCHAR,
+ self->sequence_offset, NULL);
+
+ if (self->avg_bps)
+ gst_structure_id_set (ret, MXF_QUARK (AVG_BPS), G_TYPE_UINT, self->avg_bps,
+ NULL);
+
+ if (!mxf_ul_is_zero (&self->channel_assignment)) {
+ gst_structure_id_set (ret, MXF_QUARK (CHANNEL_ASSIGNMENT), G_TYPE_STRING,
+ mxf_ul_to_string (&self->channel_assignment, str), NULL);
+ }
+
+ if (self->peak_envelope_version)
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_ENVELOPE_VERSION), G_TYPE_UINT,
+ self->peak_envelope_version, NULL);
+
+ if (self->peak_envelope_format)
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_ENVELOPE_FORMAT), G_TYPE_UINT,
+ self->peak_envelope_format, NULL);
+
+ if (self->points_per_peak_value)
+ gst_structure_id_set (ret, MXF_QUARK (POINTS_PER_PEAK_VALUE), G_TYPE_UINT,
+ self->points_per_peak_value, NULL);
+
+ if (self->peak_envelope_block_size)
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_ENVELOPE_BLOCK_SIZE),
+ G_TYPE_UINT, self->peak_envelope_block_size, NULL);
+
+ if (self->peak_channels)
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_CHANNELS), G_TYPE_UINT,
+ self->peak_channels, NULL);
+
+ if (self->peak_frames)
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_FRAMES), G_TYPE_UINT,
+ self->peak_frames, NULL);
+
+ if (self->peak_of_peaks_position)
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_OF_PEAKS_POSITION), G_TYPE_INT64,
+ self->peak_of_peaks_position, NULL);
+
+ if (!mxf_timestamp_is_unknown (&self->peak_envelope_timestamp))
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_ENVELOPE_TIMESTAMP),
+ G_TYPE_STRING, mxf_timestamp_to_string (&self->peak_envelope_timestamp,
+ str), NULL);
+
+ if (self->peak_envelope_data) {
+ GstBuffer *buf = gst_buffer_new_and_alloc (self->peak_envelope_data_length);
+
+ memcpy (GST_BUFFER_DATA (buf), self->peak_envelope_data,
+ self->peak_envelope_data_length);
+ gst_structure_id_set (ret, MXF_QUARK (PEAK_ENVELOPE_DATA), GST_TYPE_BUFFER,
+ buf, NULL);
+ gst_buffer_unref (buf);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_wave_audio_essence_descriptor_init
(MXFMetadataWaveAudioEssenceDescriptor * self)
@@ -246,6 +320,9 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_wave_audio_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (WAVE_AUDIO_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_wave_audio_essence_descriptor_to_structure;
}
/* SMPTE 382M Annex 2 */
@@ -511,6 +588,122 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_aes3_audio_essence_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_aes3_audio_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataAES3AudioEssenceDescriptor *self =
+ MXF_METADATA_AES3_AUDIO_ESSENCE_DESCRIPTOR (m);
+
+ if (self->emphasis)
+ gst_structure_id_set (ret, MXF_QUARK (EMPHASIS), G_TYPE_UCHAR,
+ self->emphasis, NULL);
+
+ if (self->block_start_offset)
+ gst_structure_id_set (ret, MXF_QUARK (BLOCK_START_OFFSET), G_TYPE_UINT,
+ self->block_start_offset, NULL);
+
+ if (self->auxiliary_bits_mode)
+ gst_structure_id_set (ret, MXF_QUARK (AUXILIARY_BITS_MODE), G_TYPE_UCHAR,
+ self->auxiliary_bits_mode, NULL);
+
+ if (self->channel_status_mode) {
+ GstBuffer *buf = gst_buffer_new_and_alloc (self->n_channel_status_mode);
+
+ memcpy (GST_BUFFER_DATA (buf), self->channel_status_mode,
+ self->n_channel_status_mode);
+ gst_structure_id_set (ret, MXF_QUARK (CHANNEL_STATUS_MODE), GST_TYPE_BUFFER,
+ buf, NULL);
+ gst_buffer_unref (buf);
+ }
+
+ if (self->channel_status_mode) {
+ GstBuffer *buf = gst_buffer_new_and_alloc (self->n_channel_status_mode);
+
+ memcpy (GST_BUFFER_DATA (buf), self->channel_status_mode,
+ self->n_channel_status_mode);
+ gst_structure_id_set (ret, MXF_QUARK (CHANNEL_STATUS_MODE), GST_TYPE_BUFFER,
+ buf, NULL);
+ gst_buffer_unref (buf);
+ }
+
+ if (self->fixed_channel_status_data) {
+ guint i;
+ GValue va = { 0, }
+ , v = {
+ 0,};
+ GstBuffer *buf;
+
+ g_value_init (&va, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_fixed_channel_status_data; i++) {
+ buf = gst_buffer_new_and_alloc (24);
+ g_value_init (&v, GST_TYPE_BUFFER);
+
+ memcpy (GST_BUFFER_DATA (buf), self->fixed_channel_status_data[i], 24);
+ gst_value_set_buffer (&v, buf);
+ gst_value_array_append_value (&va, &v);
+ gst_buffer_unref (buf);
+ g_value_unset (&v);
+ }
+
+ if (gst_value_array_get_size (&va) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (FIXED_CHANNEL_STATUS_DATA),
+ &va);
+ g_value_unset (&va);
+ }
+
+
+ if (self->user_data_mode) {
+ GstBuffer *buf = gst_buffer_new_and_alloc (self->n_user_data_mode);
+
+ memcpy (GST_BUFFER_DATA (buf), self->user_data_mode,
+ self->n_user_data_mode);
+ gst_structure_id_set (ret, MXF_QUARK (USER_DATA_MODE), GST_TYPE_BUFFER, buf,
+ NULL);
+ gst_buffer_unref (buf);
+ }
+
+ if (self->fixed_user_data) {
+ guint i;
+ GValue va = { 0, }
+ , v = {
+ 0,};
+ GstBuffer *buf;
+
+ g_value_init (&va, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_fixed_user_data; i++) {
+ buf = gst_buffer_new_and_alloc (24);
+ g_value_init (&v, GST_TYPE_BUFFER);
+
+ memcpy (GST_BUFFER_DATA (buf), self->fixed_user_data[i], 24);
+ gst_value_set_buffer (&v, buf);
+ gst_value_array_append_value (&va, &v);
+ gst_buffer_unref (buf);
+ g_value_unset (&v);
+ }
+
+ if (gst_value_array_get_size (&va) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (FIXED_USER_DATA), &va);
+ g_value_unset (&va);
+ }
+
+ if (self->linked_timecode_track_id)
+ gst_structure_id_set (ret, MXF_QUARK (LINKED_TIMECODE_TRACK_ID),
+ G_TYPE_UINT, self->linked_timecode_track_id, NULL);
+
+ if (self->stream_number)
+ gst_structure_id_set (ret, MXF_QUARK (STREAM_NUMBER), G_TYPE_UCHAR,
+ self->stream_number, NULL);
+
+ return ret;
+}
+
+
static void
mxf_metadata_aes3_audio_essence_descriptor_init
(MXFMetadataAES3AudioEssenceDescriptor * self)
@@ -529,6 +722,9 @@ static void
mxf_metadata_aes3_audio_essence_descriptor_finalize;
metadata_base_class->handle_tag =
mxf_metadata_aes3_audio_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (AES3_AUDIO_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_aes3_audio_essence_descriptor_to_structure;
}
static gboolean
diff --git a/gst/mxf/mxfdemux.c b/gst/mxf/mxfdemux.c
index 46cf5e48..b96b1685 100644
--- a/gst/mxf/mxfdemux.c
+++ b/gst/mxf/mxfdemux.c
@@ -498,6 +498,8 @@ gst_mxf_demux_resolve_references (GstMXFDemux * demux)
GList *l, *values;
#endif
MXFMetadataBase *m = NULL;
+ GstStructure *structure;
+ GstTagList *taglist;
GST_DEBUG_OBJECT (demux, "Resolve metadata references");
demux->update_metadata = FALSE;
@@ -542,6 +544,14 @@ gst_mxf_demux_resolve_references (GstMXFDemux * demux)
demux->metadata_resolved = TRUE;
+ taglist = gst_tag_list_new ();
+ structure =
+ mxf_metadata_base_to_structure (MXF_METADATA_BASE (demux->preface));
+ gst_tag_list_add (taglist, GST_TAG_MERGE_APPEND, GST_TAG_MXF_STRUCTURE,
+ structure, NULL);
+ gst_element_found_tags (GST_ELEMENT (demux), taglist);
+ gst_structure_free (structure);
+
#if !GLIB_CHECK_VERSION (2, 16, 0)
g_list_free (values);
#endif
@@ -812,7 +822,7 @@ gst_mxf_demux_update_essence_tracks (GstMXFDemux * demux)
if (MXF_IS_METADATA_GENERIC_DATA_ESSENCE_DESCRIPTOR (track->
parent.descriptor[0]))
mxf_ul_to_string (&MXF_METADATA_GENERIC_DATA_ESSENCE_DESCRIPTOR
- (track->parent.descriptor[0])->data_essence_compression,
+ (track->parent.descriptor[0])->data_essence_coding,
essence_compression);
name =
diff --git a/gst/mxf/mxfmetadata.c b/gst/mxf/mxfmetadata.c
index 44acb785..c1849c0d 100644
--- a/gst/mxf/mxfmetadata.c
+++ b/gst/mxf/mxfmetadata.c
@@ -26,6 +26,7 @@
#include "mxfparse.h"
#include "mxfmetadata.h"
+#include "mxfquark.h"
GST_DEBUG_CATEGORY_EXTERN (mxf_debug);
#define GST_CAT_DEFAULT mxf_debug
@@ -61,6 +62,83 @@ mxf_metadata_base_resolve_default (MXFMetadataBase * self,
return TRUE;
}
+static GstStructure *
+mxf_metadata_base_to_structure_default (MXFMetadataBase * self)
+{
+ MXFMetadataBaseClass *klass = MXF_METADATA_BASE_GET_CLASS (self);
+ GstStructure *ret;
+ gchar str[48];
+
+ g_return_val_if_fail (klass->name_quark != 0, NULL);
+
+ ret = gst_structure_id_empty_new (klass->name_quark);
+
+ if (!mxf_ul_is_zero (&self->instance_uid)) {
+ mxf_ul_to_string (&self->instance_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (INSTANCE_UID), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (!mxf_ul_is_zero (&self->generation_uid)) {
+ mxf_ul_to_string (&self->generation_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (GENERATION_UID), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (self->other_tags) {
+ MXFLocalTag *tag;
+ GValue va = { 0, };
+ GValue v = { 0, };
+ GstStructure *s;
+ GstBuffer *buf;
+#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
+
+ g_value_init (&va, GST_TYPE_ARRAY);
+
+#if GLIB_CHECK_VERSION (2, 16, 0)
+ while (g_hash_table_iter_next (&iter, NULL, (gpointer) & tag)) {
+#else
+ for (l = values; l; l = l->next) {
+ tag = l->data;
+#endif
+
+ g_value_init (&v, GST_TYPE_STRUCTURE);
+ s = gst_structure_id_empty_new (MXF_QUARK (TAG));
+
+ mxf_ul_to_string (&tag->key, str);
+
+ buf = gst_buffer_new_and_alloc (tag->size);
+ memcpy (GST_BUFFER_DATA (buf), tag->data, tag->size);
+
+ gst_structure_id_set (s, MXF_QUARK (NAME), G_TYPE_STRING, str,
+ MXF_QUARK (DATA), GST_TYPE_BUFFER, buf, NULL);
+
+ gst_value_set_structure (&v, s);
+ gst_structure_free (s);
+ gst_buffer_unref (buf);
+ gst_value_array_append_value (&va, &v);
+ g_value_unset (&v);
+ }
+
+ gst_structure_id_set_value (ret, MXF_QUARK (OTHER_TAGS), &va);
+ g_value_unset (&va);
+
+#if !GLIB_CHECK_VERSION (2, 16, 0)
+ g_list_free (values);
+#endif
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_base_init (MXFMetadataBase * self)
{
@@ -75,6 +153,7 @@ mxf_metadata_base_class_init (MXFMetadataBaseClass * klass)
miniobject_class->finalize = mxf_metadata_base_finalize;
klass->handle_tag = mxf_metadata_base_handle_tag;
klass->resolve = mxf_metadata_base_resolve_default;
+ klass->to_structure = mxf_metadata_base_to_structure_default;
}
gboolean
@@ -117,7 +196,7 @@ mxf_metadata_base_resolve (MXFMetadataBase * self, GHashTable * metadata)
else if (self->resolved != MXF_METADATA_BASE_RESOLVE_STATE_NONE)
return FALSE;
- self->resolved = MXF_METADATA_BASE_RESOLVE_STATE_RUNNING;;
+ self->resolved = MXF_METADATA_BASE_RESOLVE_STATE_RUNNING;
klass = MXF_METADATA_BASE_GET_CLASS (self);
@@ -131,6 +210,24 @@ mxf_metadata_base_resolve (MXFMetadataBase * self, GHashTable * metadata)
return ret;
}
+GstStructure *
+mxf_metadata_base_to_structure (MXFMetadataBase * self)
+{
+ MXFMetadataBaseClass *klass;
+
+ g_return_val_if_fail (MXF_IS_METADATA_BASE (self), NULL);
+
+ g_return_val_if_fail (self->resolved ==
+ MXF_METADATA_BASE_RESOLVE_STATE_SUCCESS, NULL);
+
+ klass = MXF_METADATA_BASE_GET_CLASS (self);
+
+ if (klass->to_structure)
+ return klass->to_structure (self);
+
+ return NULL;
+}
+
G_DEFINE_ABSTRACT_TYPE (MXFMetadata, mxf_metadata, MXF_TYPE_METADATA_BASE);
static gboolean
@@ -498,6 +595,135 @@ mxf_metadata_preface_resolve (MXFMetadataBase * m, GHashTable * metadata)
metadata);
}
+static GstStructure *
+mxf_metadata_preface_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS (mxf_metadata_preface_parent_class)->to_structure
+ (m);
+ MXFMetadataPreface *self = MXF_METADATA_PREFACE (m);
+ gchar str[48];
+ guint i;
+
+ if (!mxf_timestamp_is_unknown (&self->last_modified_date)) {
+ mxf_timestamp_to_string (&self->last_modified_date, str);
+ gst_structure_id_set (ret, MXF_QUARK (LAST_MODIFIED_DATE), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ if (self->version != 0)
+ gst_structure_id_set (ret, MXF_QUARK (VERSION), G_TYPE_UINT, self->version,
+ NULL);
+
+ if (self->object_model_version != 0)
+ gst_structure_id_set (ret, MXF_QUARK (OBJECT_MODEL_VERSION), G_TYPE_UINT,
+ self->object_model_version, NULL);
+
+ if (!mxf_ul_is_zero (&self->primary_package_uid)) {
+ mxf_ul_to_string (&self->primary_package_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (PRIMARY_PACKAGE), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (self->n_identifications > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_identifications; i++) {
+ GstStructure *s;
+
+ if (self->identifications[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE
+ (self->identifications[i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (IDENTIFICATIONS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ if (self->content_storage) {
+ GstStructure *s =
+ mxf_metadata_base_to_structure (MXF_METADATA_BASE
+ (self->content_storage));
+ gst_structure_id_set (ret, MXF_QUARK (CONTENT_STORAGE), GST_TYPE_STRUCTURE,
+ s, NULL);
+ gst_structure_free (s);
+ }
+
+ if (!mxf_ul_is_zero (&self->operational_pattern)) {
+ mxf_ul_to_string (&self->operational_pattern, str);
+ gst_structure_id_set (ret, MXF_QUARK (OPERATIONAL_PATTERN), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ if (self->n_essence_containers > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_essence_containers; i++) {
+ if (mxf_ul_is_zero (&self->essence_containers[i]))
+ continue;
+
+ g_value_init (&val, G_TYPE_STRING);
+
+ mxf_ul_to_string (&self->essence_containers[i], str);
+ g_value_set_string (&val, str);
+
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (ESSENCE_CONTAINERS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ if (self->n_dm_schemes > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_dm_schemes; i++) {
+ if (mxf_ul_is_zero (&self->dm_schemes[i]))
+ continue;
+
+ g_value_init (&val, G_TYPE_STRING);
+
+ mxf_ul_to_string (&self->dm_schemes[i], str);
+ g_value_set_string (&val, str);
+
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (DM_SCHEMES), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_preface_init (MXFMetadataPreface * self)
{
@@ -513,6 +739,8 @@ mxf_metadata_preface_class_init (MXFMetadataPrefaceClass * klass)
miniobject_class->finalize = mxf_metadata_preface_finalize;
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->name_quark = MXF_QUARK (PREFACE);
}
G_DEFINE_TYPE (MXFMetadataIdentification, mxf_metadata_identification,
@@ -624,6 +852,76 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_identification_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_identification_parent_class)->to_structure (m);
+ MXFMetadataIdentification *self = MXF_METADATA_IDENTIFICATION (m);
+ gchar str[48];
+
+ if (!mxf_ul_is_zero (&self->this_generation_uid)) {
+ mxf_ul_to_string (&self->this_generation_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (THIS_GENERATION_UID), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ if (self->company_name)
+ gst_structure_id_set (ret, MXF_QUARK (COMPANY_NAME), G_TYPE_STRING,
+ self->company_name, NULL);
+
+ if (self->product_name)
+ gst_structure_id_set (ret, MXF_QUARK (PRODUCT_NAME), G_TYPE_STRING,
+ self->product_name, NULL);
+
+ if (self->product_version.major ||
+ self->product_version.minor ||
+ self->product_version.patch ||
+ self->product_version.build || self->product_version.release) {
+ g_snprintf (str, 48, "%u.%u.%u.%u.%u", self->product_version.major,
+ self->product_version.minor,
+ self->product_version.patch,
+ self->product_version.build, self->product_version.release);
+ gst_structure_id_set (ret, MXF_QUARK (PRODUCT_VERSION), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (self->version_string)
+ gst_structure_id_set (ret, MXF_QUARK (VERSION_STRING), G_TYPE_STRING,
+ self->version_string, NULL);
+
+ if (!mxf_ul_is_zero (&self->product_uid)) {
+ mxf_ul_to_string (&self->product_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (PRODUCT_UID), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (!mxf_timestamp_is_unknown (&self->modification_date)) {
+ mxf_timestamp_to_string (&self->modification_date, str);
+ gst_structure_id_set (ret, MXF_QUARK (MODIFICATION_DATE), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ if (self->toolkit_version.major ||
+ self->toolkit_version.minor ||
+ self->toolkit_version.patch ||
+ self->toolkit_version.build || self->toolkit_version.release) {
+ g_snprintf (str, 48, "%u.%u.%u.%u.%u", self->toolkit_version.major,
+ self->toolkit_version.minor,
+ self->toolkit_version.patch,
+ self->toolkit_version.build, self->toolkit_version.release);
+ gst_structure_id_set (ret, MXF_QUARK (TOOLKIT_VERSION), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (self->platform)
+ gst_structure_id_set (ret, MXF_QUARK (PLATFORM), G_TYPE_STRING,
+ self->platform, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_identification_init (MXFMetadataIdentification * self)
{
@@ -638,6 +936,8 @@ mxf_metadata_identification_class_init (MXFMetadataIdentificationClass * klass)
miniobject_class->finalize = mxf_metadata_identification_finalize;
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;
}
G_DEFINE_TYPE (MXFMetadataContentStorage, mxf_metadata_content_storage,
@@ -788,6 +1088,77 @@ mxf_metadata_content_storage_resolve (MXFMetadataBase * m,
(mxf_metadata_content_storage_parent_class)->resolve (m, metadata);
}
+static GstStructure *
+mxf_metadata_content_storage_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_content_storage_parent_class)->to_structure (m);
+ MXFMetadataContentStorage *self = MXF_METADATA_CONTENT_STORAGE (m);
+ guint i;
+
+ if (self->n_packages > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_packages; i++) {
+ GstStructure *s;
+
+ if (self->packages[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE (self->packages
+ [i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (PACKAGES), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ if (self->n_essence_container_data > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_essence_container_data; i++) {
+ GstStructure *s;
+
+ if (self->essence_container_data[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE
+ (self->essence_container_data[i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (ESSENCE_CONTAINER_DATA),
+ &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_content_storage_init (MXFMetadataContentStorage * self)
{
@@ -803,6 +1174,8 @@ mxf_metadata_content_storage_class_init (MXFMetadataContentStorageClass * klass)
miniobject_class->finalize = mxf_metadata_content_storage_finalize;
metadata_base_class->handle_tag = mxf_metadata_content_storage_handle_tag;
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;
}
G_DEFINE_TYPE (MXFMetadataEssenceContainerData,
@@ -908,6 +1281,29 @@ mxf_metadata_essence_container_data_resolve (MXFMetadataBase * m,
(mxf_metadata_essence_container_data_parent_class)->resolve (m, metadata);
}
+static GstStructure *
+mxf_metadata_essence_container_data_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_essence_container_data_parent_class)->to_structure (m);
+ MXFMetadataEssenceContainerData *self =
+ MXF_METADATA_ESSENCE_CONTAINER_DATA (m);
+ gchar str[96];
+
+ if (!mxf_umid_is_zero (&self->linked_package_uid)) {
+ mxf_umid_to_string (&self->linked_package_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (LINKED_PACKAGE), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ gst_structure_id_set (ret, MXF_QUARK (INDEX_SID), G_TYPE_UINT,
+ self->index_sid, MXF_QUARK (BODY_SID), G_TYPE_UINT, self->body_sid, NULL);
+
+
+ return ret;
+}
+
static void
mxf_metadata_essence_container_data_init (MXFMetadataEssenceContainerData *
self)
@@ -924,6 +1320,9 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_essence_container_data_handle_tag;
metadata_base_class->resolve = mxf_metadata_essence_container_data_resolve;
+ metadata_base_class->name_quark = MXF_QUARK (ESSENCE_CONTAINER_DATA);
+ metadata_base_class->to_structure =
+ mxf_metadata_essence_container_data_to_structure;
}
G_DEFINE_ABSTRACT_TYPE (MXFMetadataGenericPackage, mxf_metadata_generic_package,
@@ -1063,6 +1462,66 @@ mxf_metadata_generic_package_resolve (MXFMetadataBase * m,
(mxf_metadata_generic_package_parent_class)->resolve (m, metadata);
}
+static GstStructure *
+mxf_metadata_generic_package_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_generic_package_parent_class)->to_structure (m);
+ MXFMetadataGenericPackage *self = MXF_METADATA_GENERIC_PACKAGE (m);
+ guint i;
+ gchar str[96];
+
+ mxf_umid_to_string (&self->package_uid, str);
+ gst_structure_id_set (ret, MXF_QUARK (PACKAGE_UID), G_TYPE_STRING, str, NULL);
+
+ if (self->name)
+ gst_structure_id_set (ret, MXF_QUARK (NAME), G_TYPE_STRING, self->name,
+ NULL);
+
+ if (!mxf_timestamp_is_unknown (&self->package_creation_date)) {
+ mxf_timestamp_to_string (&self->package_creation_date, str);
+ gst_structure_id_set (ret, MXF_QUARK (PACKAGE_CREATION_DATE), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ if (!mxf_timestamp_is_unknown (&self->package_modified_date)) {
+ mxf_timestamp_to_string (&self->package_modified_date, str);
+ gst_structure_id_set (ret, MXF_QUARK (PACKAGE_MODIFIED_DATE), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ if (self->n_tracks > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_tracks; i++) {
+ GstStructure *s;
+
+ if (self->tracks[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE (self->tracks[i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (TRACKS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_generic_package_init (MXFMetadataGenericPackage * self)
{
@@ -1078,6 +1537,7 @@ mxf_metadata_generic_package_class_init (MXFMetadataGenericPackageClass * klass)
miniobject_class->finalize = mxf_metadata_generic_package_finalize;
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;
}
G_DEFINE_TYPE (MXFMetadataMaterialPackage, mxf_metadata_material_package,
@@ -1187,6 +1647,7 @@ mxf_metadata_material_package_class_init (MXFMetadataMaterialPackageClass *
MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) klass;
metadata_base_class->resolve = mxf_metadata_material_package_resolve;
+ metadata_base_class->name_quark = MXF_QUARK (MATERIAL_PACKAGE);
}
G_DEFINE_TYPE (MXFMetadataSourcePackage, mxf_metadata_source_package,
@@ -1323,6 +1784,25 @@ mxf_metadata_source_package_resolve (MXFMetadataBase * m, GHashTable * metadata)
return ret;
}
+static GstStructure *
+mxf_metadata_source_package_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_source_package_parent_class)->to_structure (m);
+ MXFMetadataSourcePackage *self = MXF_METADATA_SOURCE_PACKAGE (m);
+ GstStructure *s;
+
+ if (!self->descriptor)
+ return ret;
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE (self->descriptor));
+ gst_structure_id_set (ret, MXF_QUARK (DESCRIPTOR), GST_TYPE_STRUCTURE, s,
+ NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_source_package_init (MXFMetadataSourcePackage * self)
{
@@ -1336,6 +1816,8 @@ mxf_metadata_source_package_class_init (MXFMetadataSourcePackageClass * klass)
metadata_base_class->handle_tag = mxf_metadata_source_package_handle_tag;
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;
}
G_DEFINE_ABSTRACT_TYPE (MXFMetadataTrack, mxf_metadata_track,
@@ -1448,6 +1930,34 @@ mxf_metadata_track_resolve (MXFMetadataBase * m, GHashTable * metadata)
metadata);
}
+static GstStructure *
+mxf_metadata_track_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS (mxf_metadata_track_parent_class)->to_structure
+ (m);
+ MXFMetadataTrack *self = MXF_METADATA_TRACK (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (TRACK_ID), G_TYPE_UINT, self->track_id,
+ MXF_QUARK (TRACK_NUMBER), G_TYPE_UINT, self->track_number, NULL);
+
+ if (self->track_name)
+ gst_structure_id_set (ret, MXF_QUARK (TRACK_NAME), G_TYPE_STRING,
+ self->track_name, NULL);
+
+ if (self->sequence) {
+ GstStructure *s =
+ mxf_metadata_base_to_structure (MXF_METADATA_BASE (self->sequence));
+
+ gst_structure_id_set (ret, MXF_QUARK (SEQUENCE), GST_TYPE_STRUCTURE, s,
+ NULL);
+ gst_structure_free (s);
+ }
+
+
+ return ret;
+}
+
static void
mxf_metadata_track_init (MXFMetadataTrack * self)
{
@@ -1463,6 +1973,7 @@ mxf_metadata_track_class_init (MXFMetadataTrackClass * klass)
miniobject_class->finalize = mxf_metadata_track_finalize;
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;
}
/* SMPTE RP224 */
@@ -1551,6 +2062,21 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_timeline_track_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_timeline_track_parent_class)->to_structure (m);
+ MXFMetadataTimelineTrack *self = MXF_METADATA_TIMELINE_TRACK (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (EDIT_RATE), GST_TYPE_FRACTION,
+ self->edit_rate.n, self->edit_rate.d, MXF_QUARK (ORIGIN), G_TYPE_INT64,
+ self->origin, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_timeline_track_init (MXFMetadataTimelineTrack * self)
{
@@ -1563,6 +2089,8 @@ mxf_metadata_timeline_track_class_init (MXFMetadataTimelineTrackClass * klass)
MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) 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;
}
G_DEFINE_TYPE (MXFMetadataEventTrack, mxf_metadata_event_track,
@@ -1606,6 +2134,21 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_event_track_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_event_track_parent_class)->to_structure (m);
+ MXFMetadataEventTrack *self = MXF_METADATA_EVENT_TRACK (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (EVENT_EDIT_RATE), GST_TYPE_FRACTION,
+ self->event_edit_rate.n, self->event_edit_rate.d,
+ MXF_QUARK (EVENT_ORIGIN), G_TYPE_INT64, self->event_origin, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_event_track_init (MXFMetadataEventTrack * self)
{
@@ -1618,6 +2161,8 @@ mxf_metadata_event_track_class_init (MXFMetadataEventTrackClass * klass)
MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) 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;
}
G_DEFINE_TYPE (MXFMetadataStaticTrack, mxf_metadata_static_track,
@@ -1631,6 +2176,9 @@ mxf_metadata_static_track_init (MXFMetadataStaticTrack * self)
static void
mxf_metadata_static_track_class_init (MXFMetadataStaticTrackClass * klass)
{
+ MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) klass;
+
+ metadata_base_class->name_quark = MXF_QUARK (STATIC_TRACK);
}
G_DEFINE_TYPE (MXFMetadataSequence, mxf_metadata_sequence, MXF_TYPE_METADATA);
@@ -1744,6 +2292,52 @@ mxf_metadata_sequence_resolve (MXFMetadataBase * m, GHashTable * metadata)
}
+static GstStructure *
+mxf_metadata_sequence_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS (mxf_metadata_sequence_parent_class)->to_structure
+ (m);
+ MXFMetadataSequence *self = MXF_METADATA_SEQUENCE (m);
+ guint i;
+ gchar str[48];
+
+ mxf_ul_to_string (&self->data_definition, str);
+ gst_structure_id_set (ret, MXF_QUARK (DATA_DEFINITION), G_TYPE_STRING, str,
+ MXF_QUARK (DURATION), G_TYPE_INT64, self->duration, NULL);
+
+ if (self->n_structural_components > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_structural_components; i++) {
+ GstStructure *s;
+
+ if (self->structural_components[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE
+ (self->structural_components[i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (STRUCTURAL_COMPONENTS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_sequence_init (MXFMetadataSequence * self)
{
@@ -1759,6 +2353,8 @@ mxf_metadata_sequence_class_init (MXFMetadataSequenceClass * klass)
miniobject_class->finalize = mxf_metadata_sequence_finalize;
metadata_base_class->handle_tag = mxf_metadata_sequence_handle_tag;
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;
}
G_DEFINE_TYPE (MXFMetadataStructuralComponent,
@@ -1808,6 +2404,22 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_structural_component_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_structural_component_parent_class)->to_structure (m);
+ MXFMetadataStructuralComponent *self = MXF_METADATA_STRUCTURAL_COMPONENT (m);
+ gchar str[48];
+
+ mxf_ul_to_string (&self->data_definition, str);
+ gst_structure_id_set (ret, MXF_QUARK (DATA_DEFINITION), G_TYPE_STRING, str,
+ MXF_QUARK (DURATION), G_TYPE_INT64, self->duration, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_structural_component_init (MXFMetadataStructuralComponent * self)
{
@@ -1822,6 +2434,8 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_structural_component_handle_tag;
+ metadata_base_class->to_structure =
+ mxf_metadata_structural_component_to_structure;
}
G_DEFINE_TYPE (MXFMetadataTimecodeComponent, mxf_metadata_timecode_component,
@@ -1873,6 +2487,22 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_timecode_component_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_timecode_component_parent_class)->to_structure (m);
+ MXFMetadataTimecodeComponent *self = MXF_METADATA_TIMECODE_COMPONENT (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (START_TIMECODE), G_TYPE_INT64,
+ self->start_timecode, MXF_QUARK (ROUNDED_TIMECODE_BASE), G_TYPE_UINT,
+ self->rounded_timecode_base, MXF_QUARK (DROP_FRAME), G_TYPE_BOOLEAN,
+ self->drop_frame, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_timecode_component_init (MXFMetadataTimecodeComponent * self)
{
@@ -1886,6 +2516,9 @@ mxf_metadata_timecode_component_class_init (MXFMetadataTimecodeComponentClass *
MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) klass;
metadata_base_class->handle_tag = mxf_metadata_timecode_component_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (TIMECODE_COMPONENT);
+ metadata_base_class->to_structure =
+ mxf_metadata_timecode_component_to_structure;
}
G_DEFINE_TYPE (MXFMetadataSourceClip, mxf_metadata_source_clip,
@@ -1982,6 +2615,24 @@ mxf_metadata_source_clip_resolve (MXFMetadataBase * m, GHashTable * metadata)
(m, metadata);
}
+static GstStructure *
+mxf_metadata_source_clip_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_source_clip_parent_class)->to_structure (m);
+ MXFMetadataSourceClip *self = MXF_METADATA_SOURCE_CLIP (m);
+ gchar str[96];
+
+ mxf_umid_to_string (&self->source_package_id, str);
+ gst_structure_id_set (ret, MXF_QUARK (START_POSITION), G_TYPE_INT64,
+ self->start_position, MXF_QUARK (SOURCE_PACKAGE), G_TYPE_STRING, str,
+ MXF_QUARK (SOURCE_TRACK_ID), G_TYPE_UINT, self->source_track_id, NULL);
+
+ return ret;
+}
+
+
static void
mxf_metadata_source_clip_init (MXFMetadataSourceClip * self)
{
@@ -1995,6 +2646,8 @@ mxf_metadata_source_clip_class_init (MXFMetadataSourceClipClass * klass)
metadata_base_class->handle_tag = mxf_metadata_source_clip_handle_tag;
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;
}
G_DEFINE_TYPE (MXFMetadataDMSourceClip, mxf_metadata_dm_source_clip,
@@ -2072,6 +2725,39 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_dm_source_clip_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_dm_source_clip_parent_class)->to_structure (m);
+ MXFMetadataDMSourceClip *self = MXF_METADATA_DM_SOURCE_CLIP (m);
+ guint i;
+
+ if (self->n_track_ids > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_track_ids; i++) {
+ g_value_init (&val, G_TYPE_UINT);
+
+ g_value_set_uint (&val, self->track_ids[i]);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (TRACK_IDS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_dm_source_clip_init (MXFMetadataDMSourceClip * self)
{
@@ -2086,6 +2772,8 @@ mxf_metadata_dm_source_clip_class_init (MXFMetadataDMSourceClipClass * klass)
miniobject_class->finalize = mxf_metadata_dm_source_clip_finalize;
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;
}
G_DEFINE_TYPE (MXFMetadataDMSegment, mxf_metadata_dm_segment,
@@ -2211,6 +2899,55 @@ mxf_metadata_dm_segment_resolve (MXFMetadataBase * m, GHashTable * metadata)
(m, metadata);
}
+static GstStructure *
+mxf_metadata_dm_segment_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_dm_segment_parent_class)->to_structure (m);
+ MXFMetadataDMSegment *self = MXF_METADATA_DM_SEGMENT (m);
+ guint i;
+
+ gst_structure_id_set (ret, MXF_QUARK (EVENT_START_POSITION), G_TYPE_INT64,
+ self->event_start_position, NULL);
+
+ if (self->event_comment)
+ gst_structure_id_set (ret, MXF_QUARK (EVENT_COMMENT), G_TYPE_STRING,
+ self->event_comment, NULL);
+
+ if (self->dm_framework) {
+ GstStructure *s =
+ mxf_metadata_base_to_structure (MXF_METADATA_BASE (self->dm_framework));
+
+ gst_structure_id_set (ret, MXF_QUARK (DM_FRAMEWORK), GST_TYPE_STRUCTURE, s,
+ NULL);
+ gst_structure_free (s);
+ }
+
+ if (self->n_track_ids > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_track_ids; i++) {
+ g_value_init (&val, G_TYPE_UINT);
+
+ g_value_set_uint (&val, self->track_ids[i]);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (TRACK_IDS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_dm_segment_init (MXFMetadataDMSegment * self)
{
@@ -2226,6 +2963,8 @@ mxf_metadata_dm_segment_class_init (MXFMetadataDMSegmentClass * klass)
miniobject_class->finalize = mxf_metadata_dm_segment_finalize;
metadata_base_class->handle_tag = mxf_metadata_dm_segment_handle_tag;
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;
}
G_DEFINE_ABSTRACT_TYPE (MXFMetadataGenericDescriptor,
@@ -2330,6 +3069,47 @@ mxf_metadata_generic_descriptor_resolve (MXFMetadataBase * m,
(mxf_metadata_generic_descriptor_parent_class)->resolve (m, metadata);
}
+static GstStructure *
+mxf_metadata_generic_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_generic_descriptor_parent_class)->to_structure (m);
+ MXFMetadataGenericDescriptor *self = MXF_METADATA_GENERIC_DESCRIPTOR (m);
+ guint i;
+
+ if (self->n_locators > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_locators; i++) {
+ GstStructure *s;
+
+ if (self->locators[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE (self->locators
+ [i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (LOCATORS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_generic_descriptor_init (MXFMetadataGenericDescriptor * self)
{
@@ -2346,6 +3126,8 @@ mxf_metadata_generic_descriptor_class_init (MXFMetadataGenericDescriptorClass *
miniobject_class->finalize = mxf_metadata_generic_descriptor_finalize;
metadata_base_class->handle_tag = mxf_metadata_generic_descriptor_handle_tag;
metadata_base_class->resolve = mxf_metadata_generic_descriptor_resolve;
+ metadata_base_class->to_structure =
+ mxf_metadata_generic_descriptor_to_structure;
}
G_DEFINE_TYPE (MXFMetadataFileDescriptor, mxf_metadata_file_descriptor,
@@ -2413,6 +3195,39 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_file_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_file_descriptor_parent_class)->to_structure (m);
+ MXFMetadataFileDescriptor *self = MXF_METADATA_FILE_DESCRIPTOR (m);
+ gchar str[48];
+
+ if (self->linked_track_id)
+ gst_structure_id_set (ret, MXF_QUARK (LINKED_TRACK_ID), G_TYPE_UINT,
+ self->linked_track_id, NULL);
+
+ if (self->sample_rate.n && self->sample_rate.d)
+ gst_structure_id_set (ret, MXF_QUARK (SAMPLE_RATE), GST_TYPE_FRACTION,
+ self->sample_rate.n, self->sample_rate.d, NULL);
+
+ if (self->container_duration)
+ gst_structure_id_set (ret, MXF_QUARK (CONTAINER_DURATION), G_TYPE_INT64,
+ self->container_duration, NULL);
+
+ mxf_ul_to_string (&self->essence_container, str);
+ gst_structure_id_set (ret, MXF_QUARK (ESSENCE_CONTAINER), G_TYPE_STRING, str,
+ NULL);
+
+ if (!mxf_ul_is_zero (&self->codec)) {
+ mxf_ul_to_string (&self->codec, str);
+ gst_structure_id_set (ret, MXF_QUARK (CODEC), G_TYPE_STRING, str, NULL);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_file_descriptor_init (MXFMetadataFileDescriptor * self)
{
@@ -2425,6 +3240,8 @@ mxf_metadata_file_descriptor_class_init (MXFMetadataFileDescriptorClass * klass)
MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) 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;
}
G_DEFINE_TYPE (MXFMetadataGenericPictureEssenceDescriptor,
@@ -2623,6 +3440,112 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_generic_picture_essence_descriptor_to_structure (MXFMetadataBase *
+ m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_generic_picture_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataGenericPictureEssenceDescriptor *self =
+ MXF_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (m);
+ gchar str[48];
+
+ gst_structure_id_set (ret, MXF_QUARK (SIGNAL_STANDARD), G_TYPE_UCHAR,
+ self->signal_standard, NULL);
+
+ if (self->frame_layout != 255)
+ gst_structure_id_set (ret, MXF_QUARK (FRAME_LAYOUT), G_TYPE_UCHAR,
+ self->frame_layout, NULL);
+
+ if (self->stored_width != 0 && self->stored_height != 0)
+ gst_structure_id_set (ret, MXF_QUARK (STORED_WIDTH), G_TYPE_UINT,
+ self->stored_width, MXF_QUARK (STORED_HEIGHT), G_TYPE_UINT,
+ self->stored_height, NULL);
+
+ if (self->stored_f2_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (STORED_F2_OFFSET), G_TYPE_INT,
+ self->stored_f2_offset, NULL);
+
+ if (self->sampled_width != 0 && self->sampled_height != 0)
+ gst_structure_id_set (ret, MXF_QUARK (SAMPLED_WIDTH), G_TYPE_UINT,
+ self->sampled_width, MXF_QUARK (SAMPLED_HEIGHT), G_TYPE_UINT,
+ self->sampled_height, NULL);
+
+ if (self->sampled_x_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (SAMPLED_X_OFFSET), G_TYPE_INT,
+ self->sampled_x_offset, NULL);
+
+ if (self->sampled_y_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (SAMPLED_Y_OFFSET), G_TYPE_INT,
+ self->sampled_y_offset, NULL);
+
+ if (self->display_width != 0 && self->display_height != 0)
+ gst_structure_id_set (ret, MXF_QUARK (DISPLAY_WIDTH), G_TYPE_UINT,
+ self->display_width, MXF_QUARK (DISPLAY_HEIGHT), G_TYPE_UINT,
+ self->display_height, NULL);
+
+ if (self->display_x_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (DISPLAY_X_OFFSET), G_TYPE_INT,
+ self->display_x_offset, NULL);
+
+ if (self->display_y_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (DISPLAY_Y_OFFSET), G_TYPE_INT,
+ self->display_y_offset, NULL);
+
+ if (self->display_f2_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (DISPLAY_F2_OFFSET), G_TYPE_INT,
+ self->display_f2_offset, NULL);
+
+ if (self->aspect_ratio.n != 0 && self->aspect_ratio.d != 0)
+ gst_structure_id_set (ret, MXF_QUARK (ASPECT_RATIO), GST_TYPE_FRACTION,
+ self->aspect_ratio.n, self->aspect_ratio.d, NULL);
+
+ if (self->active_format_descriptor)
+ gst_structure_id_set (ret, MXF_QUARK (ACTIVE_FORMAT_DESCRIPTOR),
+ G_TYPE_UCHAR, self->active_format_descriptor, NULL);
+
+ if (self->video_line_map[0] != 0 && self->video_line_map[1] != 0)
+ gst_structure_id_set (ret, MXF_QUARK (VIDEO_LINE_MAP_0), G_TYPE_UINT,
+ self->video_line_map[0], MXF_QUARK (VIDEO_LINE_MAP_1), G_TYPE_UINT,
+ self->video_line_map[1], NULL);
+
+ if (self->alpha_transparency != 0)
+ gst_structure_id_set (ret, MXF_QUARK (ALPHA_TRANSPARENCY), G_TYPE_UCHAR,
+ self->alpha_transparency, NULL);
+
+ if (!mxf_ul_is_zero (&self->capture_gamma)) {
+ mxf_ul_to_string (&self->capture_gamma, str);
+ gst_structure_id_set (ret, MXF_QUARK (CAPTURE_GAMMA), G_TYPE_STRING, str,
+ NULL);
+ }
+
+ if (self->image_alignment_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (IMAGE_ALIGNMENT_OFFSET), G_TYPE_UINT,
+ self->image_alignment_offset, NULL);
+
+ if (self->image_start_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (IMAGE_START_OFFSET), G_TYPE_UINT,
+ self->image_start_offset, NULL);
+
+ if (self->image_end_offset != 0)
+ gst_structure_id_set (ret, MXF_QUARK (IMAGE_END_OFFSET), G_TYPE_UINT,
+ self->image_end_offset, NULL);
+
+ if (self->field_dominance != 0)
+ gst_structure_id_set (ret, MXF_QUARK (FIELD_DOMINANCE), G_TYPE_UCHAR,
+ self->field_dominance, NULL);
+
+ if (!mxf_ul_is_zero (&self->picture_essence_coding)) {
+ mxf_ul_to_string (&self->picture_essence_coding, str);
+ gst_structure_id_set (ret, MXF_QUARK (PICTURE_ESSENCE_CODING),
+ G_TYPE_STRING, str, NULL);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_generic_picture_essence_descriptor_init
(MXFMetadataGenericPictureEssenceDescriptor * self)
@@ -2639,6 +3562,10 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_generic_picture_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark =
+ MXF_QUARK (GENERIC_PICTURE_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_generic_picture_essence_descriptor_to_structure;
}
void mxf_metadata_generic_picture_essence_descriptor_set_caps
@@ -2777,6 +3704,49 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_generic_sound_essence_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_generic_sound_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataGenericSoundEssenceDescriptor *self =
+ MXF_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (AUDIO_SAMPLING_RATE), GST_TYPE_FRACTION,
+ self->audio_sampling_rate.n, self->audio_sampling_rate.d, NULL);
+
+ gst_structure_id_set (ret, MXF_QUARK (LOCKED), G_TYPE_BOOLEAN, self->locked,
+ NULL);
+
+ if (self->electro_spatial_formulation != 0)
+ gst_structure_id_set (ret, MXF_QUARK (ELECTRO_SPATIAL_FORMULATION),
+ G_TYPE_UCHAR, self->electro_spatial_formulation, NULL);
+
+ if (self->channel_count != 0)
+ gst_structure_id_set (ret, MXF_QUARK (CHANNEL_COUNT), G_TYPE_UINT,
+ self->channel_count, NULL);
+
+ if (self->quantization_bits != 0)
+ gst_structure_id_set (ret, MXF_QUARK (QUANTIZATION_BITS), G_TYPE_UINT,
+ self->quantization_bits, NULL);
+
+ if (self->dial_norm != 0)
+ gst_structure_id_set (ret, MXF_QUARK (DIAL_NORM), G_TYPE_CHAR,
+ self->dial_norm, NULL);
+
+ if (!mxf_ul_is_zero (&self->sound_essence_compression)) {
+ gchar str[48];
+
+ mxf_ul_to_string (&self->sound_essence_compression, str);
+ gst_structure_id_set (ret, MXF_QUARK (SOUND_ESSENCE_COMPRESSION),
+ G_TYPE_STRING, str, NULL);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_generic_sound_essence_descriptor_init
(MXFMetadataGenericSoundEssenceDescriptor * self)
@@ -2793,6 +3763,10 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_generic_sound_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark =
+ MXF_QUARK (GENERIC_SOUND_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_generic_sound_essence_descriptor_to_structure;
}
void mxf_metadata_generic_sound_essence_descriptor_set_caps
@@ -2912,6 +3886,58 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_cdci_picture_essence_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_cdci_picture_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataCDCIPictureEssenceDescriptor *self =
+ MXF_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR (m);
+
+ if (self->component_depth != 0)
+ gst_structure_id_set (ret, MXF_QUARK (COMPONENT_DEPTH), G_TYPE_UINT,
+ self->component_depth, NULL);
+
+ if (self->horizontal_subsampling != 0)
+ gst_structure_id_set (ret, MXF_QUARK (HORIZONTAL_SUBSAMPLING), G_TYPE_UINT,
+ self->horizontal_subsampling, NULL);
+
+ if (self->vertical_subsampling != 0)
+ gst_structure_id_set (ret, MXF_QUARK (VERTICAL_SUBSAMPLING), G_TYPE_UINT,
+ self->vertical_subsampling, NULL);
+
+ if (self->color_siting != 0)
+ gst_structure_id_set (ret, MXF_QUARK (COLOR_SITING), G_TYPE_UCHAR,
+ self->color_siting, NULL);
+
+ gst_structure_id_set (ret, MXF_QUARK (REVERSED_BYTE_ORDER), G_TYPE_BOOLEAN,
+ self->reversed_byte_order, NULL);
+
+ if (self->padding_bits != 0)
+ gst_structure_id_set (ret, MXF_QUARK (PADDING_BITS), G_TYPE_INT,
+ self->padding_bits, NULL);
+
+ if (self->alpha_sample_depth != 0)
+ gst_structure_id_set (ret, MXF_QUARK (ALPHA_SAMPLE_DEPTH), G_TYPE_UINT,
+ self->alpha_sample_depth, NULL);
+
+ if (self->black_ref_level != 0)
+ gst_structure_id_set (ret, MXF_QUARK (BLACK_REF_LEVEL), G_TYPE_UINT,
+ self->black_ref_level, NULL);
+
+ if (self->white_ref_level != 0)
+ gst_structure_id_set (ret, MXF_QUARK (WHITE_REF_LEVEL), G_TYPE_UINT,
+ self->white_ref_level, NULL);
+
+ if (self->color_range != 0)
+ gst_structure_id_set (ret, MXF_QUARK (COLOR_RANGE), G_TYPE_UINT,
+ self->color_range, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_cdci_picture_essence_descriptor_init
(MXFMetadataCDCIPictureEssenceDescriptor * self)
@@ -2927,6 +3953,9 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_cdci_picture_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (CDCI_PICTURE_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_cdci_picture_essence_descriptor_to_structure;
}
G_DEFINE_TYPE (MXFMetadataRGBAPictureEssenceDescriptor,
@@ -3038,6 +4067,50 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_rgba_picture_essence_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_rgba_picture_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataRGBAPictureEssenceDescriptor *self =
+ MXF_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR (m);
+
+ if (self->component_max_ref != 255)
+ gst_structure_id_set (ret, MXF_QUARK (COMPONENT_MAX_REF), G_TYPE_UINT,
+ self->component_max_ref, NULL);
+
+ if (self->component_min_ref != 0)
+ gst_structure_id_set (ret, MXF_QUARK (COMPONENT_MIN_REF), G_TYPE_UINT,
+ self->component_min_ref, NULL);
+
+ if (self->alpha_max_ref != 255)
+ gst_structure_id_set (ret, MXF_QUARK (ALPHA_MAX_REF), G_TYPE_UINT,
+ self->alpha_max_ref, NULL);
+
+ if (self->alpha_min_ref != 0)
+ gst_structure_id_set (ret, MXF_QUARK (ALPHA_MIN_REF), G_TYPE_UINT,
+ self->alpha_min_ref, NULL);
+
+ if (self->scanning_direction != 0)
+ gst_structure_id_set (ret, MXF_QUARK (SCANNING_DIRECTION), G_TYPE_UCHAR,
+ self->scanning_direction, NULL);
+
+ if (self->n_pixel_layout != 0) {
+ gchar *pl = g_new0 (gchar, self->n_pixel_layout * 2 + 1);
+
+ memcpy (pl, self->pixel_layout, self->n_pixel_layout * 2);
+
+ gst_structure_id_set (ret, MXF_QUARK (PIXEL_LAYOUT), G_TYPE_STRING, pl,
+ NULL);
+
+ g_free (pl);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_rgba_picture_essence_descriptor_init
(MXFMetadataRGBAPictureEssenceDescriptor * self)
@@ -3057,6 +4130,9 @@ static void
mxf_metadata_rgba_picture_essence_descriptor_finalize;
metadata_base_class->handle_tag =
mxf_metadata_rgba_picture_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (RGBA_PICTURE_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_rgba_picture_essence_descriptor_to_structure;
}
G_DEFINE_TYPE (MXFMetadataGenericDataEssenceDescriptor,
@@ -3079,9 +4155,9 @@ mxf_metadata_generic_data_essence_descriptor_handle_tag (MXFMetadataBase *
case 0x3e01:
if (tag_size != 16)
goto error;
- memcpy (&self->data_essence_compression, tag_data, 16);
- GST_DEBUG (" data essence compression = %s",
- mxf_ul_to_string (&self->data_essence_compression, str));
+ memcpy (&self->data_essence_coding, tag_data, 16);
+ GST_DEBUG (" data essence coding = %s",
+ mxf_ul_to_string (&self->data_essence_coding, str));
break;
default:
ret =
@@ -3102,6 +4178,26 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_generic_data_essence_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_generic_data_essence_descriptor_parent_class)->to_structure
+ (m);
+ MXFMetadataGenericDataEssenceDescriptor *self =
+ MXF_METADATA_GENERIC_DATA_ESSENCE_DESCRIPTOR (m);
+ gchar str[48];
+
+ if (!mxf_ul_is_zero (&self->data_essence_coding)) {
+ mxf_ul_to_string (&self->data_essence_coding, str);
+ gst_structure_id_set (ret, MXF_QUARK (DATA_ESSENCE_CODING), G_TYPE_STRING,
+ str, NULL);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_generic_data_essence_descriptor_init
(MXFMetadataGenericDataEssenceDescriptor * self)
@@ -3117,6 +4213,9 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_generic_data_essence_descriptor_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (GENERIC_DATA_ESSENCE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_generic_data_essence_descriptor_to_structure;
}
G_DEFINE_TYPE (MXFMetadataMultipleDescriptor, mxf_metadata_multiple_descriptor,
@@ -3220,6 +4319,47 @@ mxf_metadata_multiple_descriptor_resolve (MXFMetadataBase * m,
(mxf_metadata_multiple_descriptor_parent_class)->resolve (m, metadata);
}
+static GstStructure *
+mxf_metadata_multiple_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_multiple_descriptor_parent_class)->to_structure (m);
+ MXFMetadataMultipleDescriptor *self = MXF_METADATA_MULTIPLE_DESCRIPTOR (m);
+ guint i;
+
+ if (self->n_sub_descriptors > 0) {
+ GValue arr = { 0, }
+ , val = {
+ 0,};
+
+ g_value_init (&arr, GST_TYPE_ARRAY);
+
+ for (i = 0; i < self->n_sub_descriptors; i++) {
+ GstStructure *s;
+
+ if (self->sub_descriptors[i] == NULL)
+ continue;
+
+ g_value_init (&val, GST_TYPE_STRUCTURE);
+
+ s = mxf_metadata_base_to_structure (MXF_METADATA_BASE
+ (self->sub_descriptors[i]));
+ gst_value_set_structure (&val, s);
+ gst_structure_free (s);
+ gst_value_array_append_value (&arr, &val);
+ g_value_unset (&val);
+ }
+
+ if (gst_value_array_get_size (&arr) > 0)
+ gst_structure_id_set_value (ret, MXF_QUARK (SUB_DESCRIPTORS), &arr);
+
+ g_value_unset (&arr);
+ }
+
+ return ret;
+}
+
static void
mxf_metadata_multiple_descriptor_init (MXFMetadataMultipleDescriptor * self)
{
@@ -3236,6 +4376,9 @@ mxf_metadata_multiple_descriptor_class_init (MXFMetadataMultipleDescriptorClass
miniobject_class->finalize = mxf_metadata_multiple_descriptor_finalize;
metadata_base_class->handle_tag = mxf_metadata_multiple_descriptor_handle_tag;
metadata_base_class->resolve = mxf_metadata_multiple_descriptor_resolve;
+ metadata_base_class->name_quark = MXF_QUARK (MULTIPLE_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_multiple_descriptor_to_structure;
}
G_DEFINE_ABSTRACT_TYPE (MXFMetadataLocator, mxf_metadata_locator,
@@ -3290,6 +4433,20 @@ mxf_metadata_text_locator_handle_tag (MXFMetadataBase * metadata,
return ret;
}
+static GstStructure *
+mxf_metadata_text_locator_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_text_locator_parent_class)->to_structure (m);
+ MXFMetadataTextLocator *self = MXF_METADATA_TEXT_LOCATOR (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (LOCATOR_NAME), G_TYPE_STRING,
+ self->locator_name, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_text_locator_init (MXFMetadataTextLocator * self)
{
@@ -3304,6 +4461,8 @@ mxf_metadata_text_locator_class_init (MXFMetadataTextLocatorClass * klass)
miniobject_class->finalize = mxf_metadata_text_locator_finalize;
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;
}
G_DEFINE_TYPE (MXFMetadataNetworkLocator, mxf_metadata_network_locator,
@@ -3345,6 +4504,20 @@ mxf_metadata_network_locator_handle_tag (MXFMetadataBase * metadata,
return ret;
}
+static GstStructure *
+mxf_metadata_network_locator_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_network_locator_parent_class)->to_structure (m);
+ MXFMetadataNetworkLocator *self = MXF_METADATA_NETWORK_LOCATOR (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (URL_STRING), G_TYPE_STRING,
+ self->url_string, NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_network_locator_init (MXFMetadataNetworkLocator * self)
{
@@ -3358,6 +4531,8 @@ mxf_metadata_network_locator_class_init (MXFMetadataNetworkLocatorClass * klass)
miniobject_class->finalize = mxf_metadata_network_locator_finalize;
metadata_base_class->handle_tag = mxf_metadata_network_locator_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (NETWORK_LOCATOR);
+ metadata_base_class->to_structure = mxf_metadata_network_locator_to_structure;
}
G_DEFINE_ABSTRACT_TYPE (MXFDescriptiveMetadata, mxf_descriptive_metadata,
diff --git a/gst/mxf/mxfmetadata.h b/gst/mxf/mxfmetadata.h
index 1917f7af..72e4e9e5 100644
--- a/gst/mxf/mxfmetadata.h
+++ b/gst/mxf/mxfmetadata.h
@@ -385,6 +385,9 @@ struct _MXFMetadataBaseClass {
gboolean (*handle_tag) (MXFMetadataBase *self, MXFPrimerPack *primer, guint16 tag, const guint8 *tag_data, guint tag_size);
gboolean (*resolve) (MXFMetadataBase *self, GHashTable *metadata);
+ GstStructure * (*to_structure) (MXFMetadataBase *self);
+
+ GQuark name_quark;
};
struct _MXFMetadata {
@@ -699,7 +702,7 @@ struct _MXFMetadataGenericSoundEssenceDescriptor {
struct _MXFMetadataGenericDataEssenceDescriptor {
MXFMetadataFileDescriptor parent;
- MXFUL data_essence_compression;
+ MXFUL data_essence_coding;
};
struct _MXFMetadataMultipleDescriptor {
@@ -747,6 +750,7 @@ struct _MXFDescriptiveMetadataFrameworkInterface {
gboolean mxf_metadata_base_parse (MXFMetadataBase *self, MXFPrimerPack *primer, const guint8 *data, guint size);
gboolean mxf_metadata_base_resolve (MXFMetadataBase *self, GHashTable *metadata);
+GstStructure * mxf_metadata_base_to_structure (MXFMetadataBase *self);
MXFMetadata *mxf_metadata_new (guint16 type, MXFPrimerPack *primer, guint64 offset, const guint8 *data, guint size);
void mxf_metadata_register (guint16 type_id, GType type);
diff --git a/gst/mxf/mxfmpeg.c b/gst/mxf/mxfmpeg.c
index 4719def2..da287de8 100644
--- a/gst/mxf/mxfmpeg.c
+++ b/gst/mxf/mxfmpeg.c
@@ -36,6 +36,7 @@
#include <string.h>
#include "mxfmpeg.h"
+#include "mxfquark.h"
#include <gst/base/gstbytereader.h>
@@ -210,6 +211,38 @@ error:
return FALSE;
}
+static GstStructure *
+mxf_metadata_mpeg_video_descriptor_to_structure (MXFMetadataBase * m)
+{
+ GstStructure *ret =
+ MXF_METADATA_BASE_CLASS
+ (mxf_metadata_mpeg_video_descriptor_parent_class)->to_structure (m);
+ MXFMetadataMPEGVideoDescriptor *self = MXF_METADATA_MPEG_VIDEO_DESCRIPTOR (m);
+
+ gst_structure_id_set (ret, MXF_QUARK (SINGLE_SEQUENCE), G_TYPE_BOOLEAN,
+ self->single_sequence, MXF_QUARK (CONST_B_FRAMES), G_TYPE_BOOLEAN,
+ self->const_b_frames, MXF_QUARK (CODED_CONTENT_TYPE), G_TYPE_UCHAR,
+ self->coded_content_type, MXF_QUARK (LOW_DELAY), G_TYPE_BOOLEAN,
+ self->low_delay, MXF_QUARK (CLOSED_GOP), G_TYPE_BOOLEAN, self->closed_gop,
+ MXF_QUARK (IDENTICAL_GOP), G_TYPE_BOOLEAN, self->identical_gop,
+ MXF_QUARK (PROFILE_AND_LEVEL), G_TYPE_UCHAR, self->profile_and_level,
+ NULL);
+
+ if (self->max_gop)
+ gst_structure_id_set (ret, MXF_QUARK (MAX_GOP), G_TYPE_UINT, self->max_gop,
+ NULL);
+
+ if (self->b_picture_count)
+ gst_structure_id_set (ret, MXF_QUARK (B_PICTURE_COUNT), G_TYPE_UINT,
+ self->b_picture_count, NULL);
+
+ if (self->bitrate)
+ gst_structure_id_set (ret, MXF_QUARK (BITRATE), G_TYPE_UINT, self->bitrate,
+ NULL);
+
+ return ret;
+}
+
static void
mxf_metadata_mpeg_video_descriptor_init (MXFMetadataMPEGVideoDescriptor * self)
{
@@ -224,6 +257,9 @@ static void
metadata_base_class->handle_tag =
mxf_metadata_mpeg_video_descriptor_handle_tag;
+ metadata_base_class->name_quark = MXF_QUARK (MPEG_VIDEO_DESCRIPTOR);
+ metadata_base_class->to_structure =
+ mxf_metadata_mpeg_video_descriptor_to_structure;
}
typedef enum
diff --git a/gst/mxf/mxfquark.c b/gst/mxf/mxfquark.c
new file mode 100644
index 00000000..9f350e7c
--- /dev/null
+++ b/gst/mxf/mxfquark.c
@@ -0,0 +1,211 @@
+/* GStreamer
+ * Copyright (C) <2009> 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 "mxfquark.h"
+
+static const gchar *_quark_strings[] = {
+ "instance-uid",
+ "generation-uid",
+ "other-tags",
+ "tag",
+ "data",
+ "preface",
+ "last-modified-date",
+ "version",
+ "object-model-version",
+ "primary-package",
+ "identifications",
+ "content-storage",
+ "operational-pattern",
+ "essence-containers",
+ "dm-schemes",
+ "identification",
+ "this-generation-uid",
+ "company-name",
+ "product-name",
+ "product-version",
+ "version-string",
+ "product-uid",
+ "modification-date",
+ "toolkit-version",
+ "platform",
+ "packages",
+ "essence-container-data",
+ "linked-package",
+ "index-sid",
+ "body-sid",
+ "package-uid",
+ "name",
+ "package-creation-date",
+ "package-modified-date",
+ "tracks",
+ "material-package",
+ "source-package",
+ "descriptor",
+ "track-id",
+ "track-number",
+ "track-name",
+ "sequence",
+ "timeline-track",
+ "edit-rate",
+ "origin",
+ "event-track",
+ "event-edit-rate",
+ "event-origin",
+ "static-track",
+ "data-definition",
+ "duration",
+ "structural-components",
+ "timecode-component",
+ "start-timecode",
+ "rounded-timecode-base",
+ "drop-frame",
+ "source-clip",
+ "start-position",
+ "source-track-id",
+ "dm-source-clip",
+ "track-ids",
+ "dm-segment",
+ "event-start-position",
+ "event-comment",
+ "dm-framework",
+ "locators",
+ "file-descriptor",
+ "linked-track-id",
+ "sample-rate",
+ "container-duration",
+ "essence-container",
+ "codec",
+ "generic-picture-essence-descriptor",
+ "signal-standard",
+ "frame-layout",
+ "stored-width",
+ "stored-height",
+ "stored-f2-offset",
+ "sampled-width",
+ "sampled-height",
+ "sampled-x-offset",
+ "sampled-y-offset",
+ "display-height",
+ "display-width",
+ "display-x-offset",
+ "display-y-offset",
+ "display-f2-offset",
+ "aspect-ratio",
+ "active-format-descriptor",
+ "video-line-map-0",
+ "video-line-map-1",
+ "alpha-transparency",
+ "capture-gamma",
+ "image-alignment-offset",
+ "image-start-offset",
+ "image-end-offset",
+ "field-dominance",
+ "picture-essence-coding",
+ "cdci-picture-essence-descriptor",
+ "component-depth",
+ "horizontal-subsampling",
+ "vertical-subsampling",
+ "color-siting",
+ "reversed-byte-order",
+ "padding-bits",
+ "alpha-sample-depth",
+ "black-ref-level",
+ "white-ref-level",
+ "color-range",
+ "rgba-picture-essence-descriptor",
+ "component-max-ref",
+ "component-min-ref",
+ "alpha-max-ref",
+ "alpha-min-ref",
+ "scanning-direction",
+ "pixel-layout",
+ "generic-sound-essence-descriptor",
+ "audio-sampling-rate",
+ "locked",
+ "audio-ref-level",
+ "electro-spatial-formulation",
+ "channel-count",
+ "quantization-bits",
+ "dial-norm",
+ "sound-essence-compression",
+ "generic-data-essence-descriptor",
+ "data-essence-coding",
+ "multiple-descriptor",
+ "sub-descriptors",
+ "text-locator",
+ "locator-name",
+ "network-locator",
+ "url-string",
+ "wave-audio-essence-descriptor",
+ "block-align",
+ "sequence-offset",
+ "avg-bps",
+ "channel-assignment",
+ "peak-envelope-version",
+ "peak-envelope-format",
+ "points-per-peak-value",
+ "peak-envelope-block-size",
+ "peak-channels",
+ "peak-frames",
+ "peak-of-peaks-position",
+ "peak-envelope-timestamp",
+ "peak-envelope-data",
+ "aes3-audio-essence-descriptor",
+ "emphasis",
+ "block-start-offset",
+ "auxiliary-bits-mode",
+ "channel-status-mode",
+ "fixed-channel-status-data",
+ "user-data-mode",
+ "fixed-user-data",
+ "linked-timecode-track-id",
+ "stream-number",
+ "mpeg-video-descriptor",
+ "single-sequence",
+ "const-b-frames",
+ "coded-content-type",
+ "low-delay",
+ "closed-gop",
+ "identical-gop",
+ "max-gop",
+ "b-picture-count",
+ "bitrate",
+ "profile-and-level",
+};
+
+GQuark _mxf_quark_table[MXF_QUARK_MAX];
+
+void
+mxf_quark_initialize (void)
+{
+ gint i;
+
+ if (G_N_ELEMENTS (_quark_strings) != MXF_QUARK_MAX)
+ g_warning ("the quark table is not consistent! %d != %d",
+ (int) G_N_ELEMENTS (_quark_strings), MXF_QUARK_MAX);
+
+ for (i = 0; i < MXF_QUARK_MAX; i++) {
+ _mxf_quark_table[i] = g_quark_from_static_string (_quark_strings[i]);
+ }
+}
diff --git a/gst/mxf/mxfquark.h b/gst/mxf/mxfquark.h
new file mode 100644
index 00000000..6b61c69c
--- /dev/null
+++ b/gst/mxf/mxfquark.h
@@ -0,0 +1,204 @@
+/* GStreamer
+ * Copyright (C) <2009> 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.
+ */
+
+#ifndef __MXF_QUARK_H__
+#define __MXF_QUARK_H__
+
+#include <gst/gst.h>
+
+typedef enum {
+ MXF_QUARK_INSTANCE_UID = 0,
+ MXF_QUARK_GENERATION_UID = 1,
+ MXF_QUARK_OTHER_TAGS = 2,
+ MXF_QUARK_TAG = 3,
+ MXF_QUARK_DATA = 4,
+ MXF_QUARK_PREFACE = 5,
+ MXF_QUARK_LAST_MODIFIED_DATE = 6,
+ MXF_QUARK_VERSION = 7,
+ MXF_QUARK_OBJECT_MODEL_VERSION = 8,
+ MXF_QUARK_PRIMARY_PACKAGE = 9,
+ MXF_QUARK_IDENTIFICATIONS = 10,
+ MXF_QUARK_CONTENT_STORAGE = 11,
+ MXF_QUARK_OPERATIONAL_PATTERN = 12,
+ MXF_QUARK_ESSENCE_CONTAINERS = 13,
+ MXF_QUARK_DM_SCHEMES = 14,
+ MXF_QUARK_IDENTIFICATION = 15,
+ MXF_QUARK_THIS_GENERATION_UID = 16,
+ MXF_QUARK_COMPANY_NAME = 17,
+ MXF_QUARK_PRODUCT_NAME = 18,
+ MXF_QUARK_PRODUCT_VERSION = 19,
+ MXF_QUARK_VERSION_STRING = 20,
+ MXF_QUARK_PRODUCT_UID = 21,
+ MXF_QUARK_MODIFICATION_DATE = 22,
+ MXF_QUARK_TOOLKIT_VERSION = 23,
+ MXF_QUARK_PLATFORM = 24,
+ MXF_QUARK_PACKAGES = 25,
+ MXF_QUARK_ESSENCE_CONTAINER_DATA = 26,
+ MXF_QUARK_LINKED_PACKAGE = 27,
+ MXF_QUARK_INDEX_SID = 28,
+ MXF_QUARK_BODY_SID = 29,
+ MXF_QUARK_PACKAGE_UID = 30,
+ MXF_QUARK_NAME = 31,
+ MXF_QUARK_PACKAGE_CREATION_DATE = 32,
+ MXF_QUARK_PACKAGE_MODIFIED_DATE = 33,
+ MXF_QUARK_TRACKS = 34,
+ MXF_QUARK_MATERIAL_PACKAGE = 35,
+ MXF_QUARK_SOURCE_PACKAGE = 36,
+ MXF_QUARK_DESCRIPTOR = 37,
+ MXF_QUARK_TRACK_ID = 38,
+ MXF_QUARK_TRACK_NUMBER = 39,
+ MXF_QUARK_TRACK_NAME = 40,
+ MXF_QUARK_SEQUENCE = 41,
+ MXF_QUARK_TIMELINE_TRACK = 42,
+ MXF_QUARK_EDIT_RATE = 43,
+ MXF_QUARK_ORIGIN = 44,
+ MXF_QUARK_EVENT_TRACK = 45,
+ MXF_QUARK_EVENT_EDIT_RATE = 46,
+ MXF_QUARK_EVENT_ORIGIN = 47,
+ MXF_QUARK_STATIC_TRACK = 48,
+ MXF_QUARK_DATA_DEFINITION = 49,
+ MXF_QUARK_DURATION = 50,
+ MXF_QUARK_STRUCTURAL_COMPONENTS = 51,
+ MXF_QUARK_TIMECODE_COMPONENT = 52,
+ MXF_QUARK_START_TIMECODE = 53,
+ MXF_QUARK_ROUNDED_TIMECODE_BASE = 54,
+ MXF_QUARK_DROP_FRAME = 55,
+ MXF_QUARK_SOURCE_CLIP = 56,
+ MXF_QUARK_START_POSITION = 57,
+ MXF_QUARK_SOURCE_TRACK_ID = 58,
+ MXF_QUARK_DM_SOURCE_CLIP = 59,
+ MXF_QUARK_TRACK_IDS = 60,
+ MXF_QUARK_DM_SEGMENT = 61,
+ MXF_QUARK_EVENT_START_POSITION = 62,
+ MXF_QUARK_EVENT_COMMENT = 63,
+ MXF_QUARK_DM_FRAMEWORK = 64,
+ MXF_QUARK_LOCATORS = 65,
+ MXF_QUARK_FILE_DESCRIPTOR = 66,
+ MXF_QUARK_LINKED_TRACK_ID = 67,
+ MXF_QUARK_SAMPLE_RATE = 68,
+ MXF_QUARK_CONTAINER_DURATION = 69,
+ MXF_QUARK_ESSENCE_CONTAINER = 70,
+ MXF_QUARK_CODEC = 71,
+ MXF_QUARK_GENERIC_PICTURE_ESSENCE_DESCRIPTOR = 72,
+ MXF_QUARK_SIGNAL_STANDARD = 73,
+ MXF_QUARK_FRAME_LAYOUT = 74,
+ MXF_QUARK_STORED_WIDTH = 75,
+ MXF_QUARK_STORED_HEIGHT = 76,
+ MXF_QUARK_STORED_F2_OFFSET = 77,
+ MXF_QUARK_SAMPLED_WIDTH = 78,
+ MXF_QUARK_SAMPLED_HEIGHT = 79,
+ MXF_QUARK_SAMPLED_X_OFFSET = 80,
+ MXF_QUARK_SAMPLED_Y_OFFSET = 81,
+ MXF_QUARK_DISPLAY_HEIGHT = 82,
+ MXF_QUARK_DISPLAY_WIDTH = 83,
+ MXF_QUARK_DISPLAY_X_OFFSET = 84,
+ MXF_QUARK_DISPLAY_Y_OFFSET = 85,
+ MXF_QUARK_DISPLAY_F2_OFFSET = 86,
+ MXF_QUARK_ASPECT_RATIO = 87,
+ MXF_QUARK_ACTIVE_FORMAT_DESCRIPTOR = 88,
+ MXF_QUARK_VIDEO_LINE_MAP_0 = 89,
+ MXF_QUARK_VIDEO_LINE_MAP_1 = 90,
+ MXF_QUARK_ALPHA_TRANSPARENCY = 91,
+ MXF_QUARK_CAPTURE_GAMMA = 92,
+ MXF_QUARK_IMAGE_ALIGNMENT_OFFSET = 93,
+ MXF_QUARK_IMAGE_START_OFFSET = 94,
+ MXF_QUARK_IMAGE_END_OFFSET = 95,
+ MXF_QUARK_FIELD_DOMINANCE = 96,
+ MXF_QUARK_PICTURE_ESSENCE_CODING = 97,
+ MXF_QUARK_CDCI_PICTURE_ESSENCE_DESCRIPTOR = 98,
+ MXF_QUARK_COMPONENT_DEPTH = 99,
+ MXF_QUARK_HORIZONTAL_SUBSAMPLING = 100,
+ MXF_QUARK_VERTICAL_SUBSAMPLING = 101,
+ MXF_QUARK_COLOR_SITING = 102,
+ MXF_QUARK_REVERSED_BYTE_ORDER = 103,
+ MXF_QUARK_PADDING_BITS = 104,
+ MXF_QUARK_ALPHA_SAMPLE_DEPTH = 105,
+ MXF_QUARK_BLACK_REF_LEVEL = 106,
+ MXF_QUARK_WHITE_REF_LEVEL = 107,
+ MXF_QUARK_COLOR_RANGE = 108,
+ MXF_QUARK_RGBA_PICTURE_ESSENCE_DESCRIPTOR = 109,
+ MXF_QUARK_COMPONENT_MAX_REF = 110,
+ MXF_QUARK_COMPONENT_MIN_REF = 111,
+ MXF_QUARK_ALPHA_MAX_REF = 112,
+ MXF_QUARK_ALPHA_MIN_REF = 113,
+ MXF_QUARK_SCANNING_DIRECTION = 114,
+ MXF_QUARK_PIXEL_LAYOUT = 115,
+ MXF_QUARK_GENERIC_SOUND_ESSENCE_DESCRIPTOR = 116,
+ MXF_QUARK_AUDIO_SAMPLING_RATE = 117,
+ MXF_QUARK_LOCKED = 118,
+ MXF_QUARK_AUDIO_REF_LEVEL = 119,
+ MXF_QUARK_ELECTRO_SPATIAL_FORMULATION = 120,
+ MXF_QUARK_CHANNEL_COUNT = 121,
+ MXF_QUARK_QUANTIZATION_BITS = 122,
+ MXF_QUARK_DIAL_NORM = 123,
+ MXF_QUARK_SOUND_ESSENCE_COMPRESSION = 124,
+ MXF_QUARK_GENERIC_DATA_ESSENCE_DESCRIPTOR = 125,
+ MXF_QUARK_DATA_ESSENCE_CODING = 126,
+ MXF_QUARK_MULTIPLE_DESCRIPTOR = 127,
+ MXF_QUARK_SUB_DESCRIPTORS = 128,
+ MXF_QUARK_TEXT_LOCATOR = 129,
+ MXF_QUARK_LOCATOR_NAME = 130,
+ MXF_QUARK_NETWORK_LOCATOR = 131,
+ MXF_QUARK_URL_STRING = 132,
+ MXF_QUARK_WAVE_AUDIO_ESSENCE_DESCRIPTOR = 133,
+ MXF_QUARK_BLOCK_ALIGN = 134,
+ MXF_QUARK_SEQUENCE_OFFSET = 135,
+ MXF_QUARK_AVG_BPS = 136,
+ MXF_QUARK_CHANNEL_ASSIGNMENT = 137,
+ MXF_QUARK_PEAK_ENVELOPE_VERSION = 138,
+ MXF_QUARK_PEAK_ENVELOPE_FORMAT = 139,
+ MXF_QUARK_POINTS_PER_PEAK_VALUE = 140,
+ MXF_QUARK_PEAK_ENVELOPE_BLOCK_SIZE = 141,
+ MXF_QUARK_PEAK_CHANNELS = 142,
+ MXF_QUARK_PEAK_FRAMES = 143,
+ MXF_QUARK_PEAK_OF_PEAKS_POSITION = 144,
+ MXF_QUARK_PEAK_ENVELOPE_TIMESTAMP = 145,
+ MXF_QUARK_PEAK_ENVELOPE_DATA = 146,
+ MXF_QUARK_AES3_AUDIO_ESSENCE_DESCRIPTOR = 147,
+ MXF_QUARK_EMPHASIS = 148,
+ MXF_QUARK_BLOCK_START_OFFSET = 149,
+ MXF_QUARK_AUXILIARY_BITS_MODE = 150,
+ MXF_QUARK_CHANNEL_STATUS_MODE = 151,
+ MXF_QUARK_FIXED_CHANNEL_STATUS_DATA = 152,
+ MXF_QUARK_USER_DATA_MODE = 153,
+ MXF_QUARK_FIXED_USER_DATA = 154,
+ MXF_QUARK_LINKED_TIMECODE_TRACK_ID = 155,
+ MXF_QUARK_STREAM_NUMBER = 156,
+ MXF_QUARK_MPEG_VIDEO_DESCRIPTOR = 157,
+ MXF_QUARK_SINGLE_SEQUENCE = 158,
+ MXF_QUARK_CONST_B_FRAMES = 159,
+ MXF_QUARK_CODED_CONTENT_TYPE = 160,
+ MXF_QUARK_LOW_DELAY = 161,
+ MXF_QUARK_CLOSED_GOP = 162,
+ MXF_QUARK_IDENTICAL_GOP = 163,
+ MXF_QUARK_MAX_GOP = 164,
+ MXF_QUARK_B_PICTURE_COUNT = 165,
+ MXF_QUARK_BITRATE = 166,
+ MXF_QUARK_PROFILE_AND_LEVEL = 167,
+
+ MXF_QUARK_MAX
+} MXFQuarkId;
+
+extern GQuark _mxf_quark_table[MXF_QUARK_MAX];
+
+#define MXF_QUARK(q) _mxf_quark_table[MXF_QUARK_##q]
+
+void mxf_quark_initialize (void);
+
+#endif /* __MXF_QUARK_H__ */
diff --git a/gst/mxf/mxftypes.h b/gst/mxf/mxftypes.h
index d56499ad..dcbbd28d 100644
--- a/gst/mxf/mxftypes.h
+++ b/gst/mxf/mxftypes.h
@@ -155,5 +155,7 @@ typedef struct {
} MXFIndexTableSegment;
#define GST_TAG_MXF_UMID "mxf-umid"
+#define GST_TAG_MXF_STRUCTURE "mxf-structure"
+#define GST_TAG_MXF_DESCRIPTIVE_METADATA_FRAMEWORK "mxf-descriptive-metadata-framework"
#endif /* __MXF_TYPES_H__ */