← Back to branch summary

~ubuntu-branches/ubuntu/precise/gst-plugins-bad0.10/precise-proposed

« back to all changes in this revision

Viewing changes to gst/mxf/mxfmetadata.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2009-05-12 09:51:24 UTC
  • mto: (18.3.2 experimental) (1.3.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 31.
  • Revision ID: james.westby@ubuntu.com-20090512095124-ugy051q0n88kk9f8
Tags: upstream-0.10.11.2
Import upstream version 0.10.11.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst/mxf/mxfmetadata.c
24
24
#include <gst/gst.h>
25
25
#include <string.h>
26
26
 
27
 
#include "mxfparse.h"
 
27
#include "mxftypes.h"
28
28
#include "mxfmetadata.h"
29
29
#include "mxfquark.h"
30
30
 
82
82
 
83
83
  ret = gst_structure_id_empty_new (klass->name_quark);
84
84
 
85
 
  if (!mxf_ul_is_zero (&self->instance_uid)) {
86
 
    mxf_ul_to_string (&self->instance_uid, str);
 
85
  if (!mxf_uuid_is_zero (&self->instance_uid)) {
 
86
    mxf_uuid_to_string (&self->instance_uid, str);
87
87
    gst_structure_id_set (ret, MXF_QUARK (INSTANCE_UID), G_TYPE_STRING, str,
88
88
        NULL);
89
89
  }
90
90
 
91
 
  if (!mxf_ul_is_zero (&self->generation_uid)) {
92
 
    mxf_ul_to_string (&self->generation_uid, str);
 
91
  if (!mxf_uuid_is_zero (&self->generation_uid)) {
 
92
    mxf_uuid_to_string (&self->generation_uid, str);
93
93
    gst_structure_id_set (ret, MXF_QUARK (GENERATION_UID), G_TYPE_STRING, str,
94
94
        NULL);
95
95
  }
123
123
      g_value_init (&v, GST_TYPE_STRUCTURE);
124
124
      s = gst_structure_id_empty_new (MXF_QUARK (TAG));
125
125
 
126
 
      mxf_ul_to_string (&tag->key, str);
 
126
      mxf_ul_to_string (&tag->ul, str);
127
127
 
128
128
      buf = gst_buffer_new_and_alloc (tag->size);
129
129
      memcpy (GST_BUFFER_DATA (buf), tag->data, tag->size);
238
238
  return NULL;
239
239
}
240
240
 
 
241
GstBuffer *
 
242
mxf_metadata_base_to_buffer (MXFMetadataBase * self, MXFPrimerPack * primer)
 
243
{
 
244
  MXFMetadataBaseClass *klass;
 
245
  GstBuffer *ret;
 
246
  GList *tags, *l;
 
247
  guint size = 0, slen;
 
248
  guint8 ber[9];
 
249
  MXFLocalTag *t, *last;
 
250
  guint8 *data;
 
251
 
 
252
  g_return_val_if_fail (MXF_IS_METADATA_BASE (self), NULL);
 
253
  g_return_val_if_fail (primer != NULL, NULL);
 
254
 
 
255
  klass = MXF_METADATA_BASE_GET_CLASS (self);
 
256
  g_return_val_if_fail (klass->write_tags, NULL);
 
257
 
 
258
  tags = klass->write_tags (self, primer);
 
259
  g_return_val_if_fail (tags != NULL, NULL);
 
260
 
 
261
  /* Add unknown tags */
 
262
  if (self->other_tags) {
 
263
    MXFLocalTag *tmp;
 
264
#if GLIB_CHECK_VERSION (2, 16, 0)
 
265
    GHashTableIter iter;
 
266
 
 
267
    g_hash_table_iter_init (&iter, self->other_tags);
 
268
#else
 
269
    GList *l, *values;
 
270
 
 
271
    values = g_hash_table_get_values (self->other_tags);
 
272
#endif
 
273
 
 
274
#if GLIB_CHECK_VERSION (2, 16, 0)
 
275
    while (g_hash_table_iter_next (&iter, NULL, (gpointer) & t)) {
 
276
#else
 
277
    for (l = values; l; l = l->next) {
 
278
      t = l->data;
 
279
#endif
 
280
      tmp = g_slice_dup (MXFLocalTag, t);
 
281
      if (t->g_slice) {
 
282
        tmp->data = g_slice_alloc (t->size);
 
283
        mxf_primer_pack_add_mapping (primer, 0x0000, &t->ul);
 
284
        memcpy (tmp->data, t->data, t->size);
 
285
      } else {
 
286
        tmp->data = g_memdup (t->data, t->size);
 
287
      }
 
288
      tags = g_list_prepend (tags, tmp);
 
289
    }
 
290
 
 
291
#if !GLIB_CHECK_VERSION (2, 16, 0)
 
292
    g_list_free (values);
 
293
#endif
 
294
  }
 
295
 
 
296
  l = g_list_last (tags);
 
297
  last = l->data;
 
298
  tags = g_list_delete_link (tags, l);
 
299
  /* Last element contains the metadata UL */
 
300
  g_return_val_if_fail (last->size == 0, NULL);
 
301
 
 
302
  for (l = tags; l; l = l->next) {
 
303
    t = l->data;
 
304
    g_assert (G_MAXUINT - t->size >= size);
 
305
    size += 4 + t->size;
 
306
  }
 
307
 
 
308
  slen = mxf_ber_encode_size (size, ber);
 
309
  size += 16 + slen;
 
310
 
 
311
  ret = gst_buffer_new_and_alloc (size);
 
312
 
 
313
  memcpy (GST_BUFFER_DATA (ret), &last->ul, 16);
 
314
  mxf_local_tag_free (last);
 
315
  last = NULL;
 
316
  memcpy (GST_BUFFER_DATA (ret) + 16, ber, slen);
 
317
 
 
318
  data = GST_BUFFER_DATA (ret) + 16 + slen;
 
319
  size -= 16 + slen;
 
320
 
 
321
  for (l = tags; l; l = l->next) {
 
322
    guint16 local_tag;
 
323
 
 
324
    g_assert (size >= 4);
 
325
    t = l->data;
 
326
 
 
327
    local_tag =
 
328
        GPOINTER_TO_UINT (g_hash_table_lookup (primer->reverse_mappings,
 
329
            &t->ul));
 
330
    g_assert (local_tag != 0);
 
331
 
 
332
    GST_WRITE_UINT16_BE (data, local_tag);
 
333
    GST_WRITE_UINT16_BE (data + 2, t->size);
 
334
    data += 4;
 
335
    size -= 4;
 
336
    g_assert (size >= t->size);
 
337
 
 
338
    memcpy (data, t->data, t->size);
 
339
    data += t->size;
 
340
    size -= t->size;
 
341
 
 
342
    mxf_local_tag_free (t);
 
343
  }
 
344
 
 
345
  g_list_free (tags);
 
346
 
 
347
  return ret;
 
348
}
 
349
 
241
350
G_DEFINE_ABSTRACT_TYPE (MXFMetadata, mxf_metadata, MXF_TYPE_METADATA_BASE);
242
351
 
243
352
static gboolean
256
365
        goto error;
257
366
      memcpy (&self->parent.instance_uid, tag_data, 16);
258
367
      GST_DEBUG ("  instance uid = %s",
259
 
          mxf_ul_to_string (&self->parent.instance_uid, str));
 
368
          mxf_uuid_to_string (&self->parent.instance_uid, str));
260
369
      break;
261
370
    case 0x0102:
262
371
      if (tag_size != 16)
263
372
        goto error;
264
373
      memcpy (&self->parent.generation_uid, tag_data, 16);
265
374
      GST_DEBUG ("  generation uid = %s",
266
 
          mxf_ul_to_string (&self->parent.generation_uid, str));
 
375
          mxf_uuid_to_string (&self->parent.generation_uid, str));
267
376
      break;
268
377
    default:
269
378
      ret =
281
390
  return FALSE;
282
391
}
283
392
 
 
393
static GList *
 
394
mxf_metadata_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
 
395
{
 
396
  MXFMetadata *self = MXF_METADATA (m);
 
397
  GList *ret = NULL;
 
398
  MXFLocalTag *t;
 
399
  MXFMetadataClass *klass;
 
400
 
 
401
  g_return_val_if_fail (MXF_IS_METADATA (self), NULL);
 
402
  klass = MXF_METADATA_GET_CLASS (self);
 
403
 
 
404
  /* Last element contains the metadata key */
 
405
  t = g_slice_new0 (MXFLocalTag);
 
406
  memcpy (&t->ul, MXF_UL (METADATA), 16);
 
407
  GST_WRITE_UINT16_BE (&t->ul.u[13], klass->type);
 
408
  ret = g_list_prepend (ret, t);
 
409
 
 
410
  t = g_slice_new0 (MXFLocalTag);
 
411
  memcpy (&t->ul, MXF_UL (INSTANCE_UID), 16);
 
412
  t->size = 16;
 
413
  t->data = g_slice_alloc (16);
 
414
  t->g_slice = TRUE;
 
415
  memcpy (t->data, &self->parent.instance_uid, 16);
 
416
  mxf_primer_pack_add_mapping (primer, 0x3c0a, &t->ul);
 
417
  ret = g_list_prepend (ret, t);
 
418
 
 
419
  if (!mxf_uuid_is_zero (&self->parent.generation_uid)) {
 
420
    t = g_slice_new0 (MXFLocalTag);
 
421
    memcpy (&t->ul, MXF_UL (GENERATION_UID), 16);
 
422
    t->size = 16;
 
423
    t->data = g_slice_alloc (16);
 
424
    t->g_slice = TRUE;
 
425
    memcpy (t->data, &self->parent.generation_uid, 16);
 
426
    mxf_primer_pack_add_mapping (primer, 0x0102, &t->ul);
 
427
    ret = g_list_prepend (ret, t);
 
428
  }
 
429
 
 
430
  return ret;
 
431
}
 
432
 
284
433
static void
285
434
mxf_metadata_class_init (MXFMetadataClass * klass)
286
435
{
287
436
  MXFMetadataBaseClass *metadata_base_class = (MXFMetadataBaseClass *) klass;
288
437
 
289
438
  metadata_base_class->handle_tag = mxf_metadata_handle_tag;
 
439
  metadata_base_class->write_tags = mxf_metadata_write_tags;
290
440
}
291
441
 
292
442
static void
448
598
        goto error;
449
599
      memcpy (&self->primary_package_uid, tag_data, 16);
450
600
      GST_DEBUG ("  primary package = %s",
451
 
          mxf_ul_to_string (&self->primary_package_uid, str));
 
601
          mxf_uuid_to_string (&self->primary_package_uid, str));
452
602
      break;
453
603
    case 0x3b06:
454
 
      if (!mxf_ul_array_parse (&self->identifications_uids,
 
604
      if (!mxf_uuid_array_parse (&self->identifications_uids,
455
605
              &self->n_identifications, tag_data, tag_size))
456
606
        goto error;
457
607
 
461
611
        guint i;
462
612
        for (i = 0; i < self->n_identifications; i++) {
463
613
          GST_DEBUG ("  identification %u = %s", i,
464
 
              mxf_ul_to_string (&self->identifications_uids[i], str));
 
614
              mxf_uuid_to_string (&self->identifications_uids[i], str));
465
615
        }
466
616
      }
467
617
#endif
471
621
        goto error;
472
622
      memcpy (&self->content_storage_uid, tag_data, 16);
473
623
      GST_DEBUG ("  content storage = %s",
474
 
          mxf_ul_to_string (&self->content_storage_uid, str));
 
624
          mxf_uuid_to_string (&self->content_storage_uid, str));
475
625
      break;
476
626
    case 0x3b09:
477
627
      if (tag_size != 16)
537
687
  MXFMetadataBase *current = NULL;
538
688
  guint i;
539
689
 
540
 
  if (!mxf_ul_is_zero (&self->primary_package_uid)) {
 
690
  if (!mxf_uuid_is_zero (&self->primary_package_uid)) {
541
691
    current = g_hash_table_lookup (metadata, &self->primary_package_uid);
542
692
    if (!current || !MXF_IS_METADATA_GENERIC_PACKAGE (current)) {
543
693
      GST_ERROR ("Primary package not found");
607
757
    gst_structure_id_set (ret, MXF_QUARK (OBJECT_MODEL_VERSION), G_TYPE_UINT,
608
758
        self->object_model_version, NULL);
609
759
 
610
 
  if (!mxf_ul_is_zero (&self->primary_package_uid)) {
611
 
    mxf_ul_to_string (&self->primary_package_uid, str);
 
760
  if (!mxf_uuid_is_zero (&self->primary_package_uid)) {
 
761
    mxf_uuid_to_string (&self->primary_package_uid, str);
612
762
    gst_structure_id_set (ret, MXF_QUARK (PRIMARY_PACKAGE), G_TYPE_STRING, str,
613
763
        NULL);
614
764
  }
712
862
  return ret;
713
863
}
714
864
 
 
865
static GList *
 
866
mxf_metadata_preface_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
 
867
{
 
868
  MXFMetadataPreface *self = MXF_METADATA_PREFACE (m);
 
869
  GList *ret =
 
870
      MXF_METADATA_BASE_CLASS (mxf_metadata_preface_parent_class)->write_tags
 
871
      (m, primer);
 
872
  MXFLocalTag *t;
 
873
  guint i;
 
874
 
 
875
  t = g_slice_new0 (MXFLocalTag);
 
876
  memcpy (&t->ul, MXF_UL (LAST_MODIFIED_DATE), 16);
 
877
  t->size = 8;
 
878
  t->data = g_slice_alloc (8);
 
879
  t->g_slice = TRUE;
 
880
  mxf_timestamp_write (&self->last_modified_date, t->data);
 
881
  mxf_primer_pack_add_mapping (primer, 0x3b02, &t->ul);
 
882
  ret = g_list_prepend (ret, t);
 
883
 
 
884
  t = g_slice_new0 (MXFLocalTag);
 
885
  memcpy (&t->ul, MXF_UL (VERSION), 16);
 
886
  t->size = 2;
 
887
  t->data = g_slice_alloc (2);
 
888
  t->g_slice = TRUE;
 
889
  GST_WRITE_UINT16_BE (t->data, self->version);
 
890
  mxf_primer_pack_add_mapping (primer, 0x3b05, &t->ul);
 
891
  ret = g_list_prepend (ret, t);
 
892
 
 
893
  if (self->object_model_version) {
 
894
    t = g_slice_new0 (MXFLocalTag);
 
895
    memcpy (&t->ul, MXF_UL (OBJECT_MODEL_VERSION), 16);
 
896
    t->size = 4;
 
897
    t->data = g_slice_alloc (4);
 
898
    t->g_slice = TRUE;
 
899
    GST_WRITE_UINT32_BE (t->data, self->object_model_version);
 
900
    mxf_primer_pack_add_mapping (primer, 0x3b07, &t->ul);
 
901
    ret = g_list_prepend (ret, t);
 
902
  }
 
903
 
 
904
  if (!mxf_uuid_is_zero (&self->primary_package_uid)) {
 
905
    t = g_slice_new0 (MXFLocalTag);
 
906
    memcpy (&t->ul, MXF_UL (PRIMARY_PACKAGE), 16);
 
907
    t->size = 16;
 
908
    t->data = g_slice_alloc (16);
 
909
    t->g_slice = TRUE;
 
910
    memcpy (t->data, &self->primary_package_uid, 16);
 
911
    mxf_primer_pack_add_mapping (primer, 0x3b08, &t->ul);
 
912
    ret = g_list_prepend (ret, t);
 
913
  }
 
914
 
 
915
  t = g_slice_new0 (MXFLocalTag);
 
916
  memcpy (&t->ul, MXF_UL (IDENTIFICATIONS), 16);
 
917
  t->size = 8 + 16 * self->n_identifications;
 
918
  t->data = g_slice_alloc0 (t->size);
 
919
  t->g_slice = TRUE;
 
920
  mxf_primer_pack_add_mapping (primer, 0x3b06, &t->ul);
 
921
  GST_WRITE_UINT32_BE (t->data, self->n_identifications);
 
922
  GST_WRITE_UINT32_BE (t->data + 4, 16);
 
923
  for (i = 0; i < self->n_identifications; i++) {
 
924
    if (!self->identifications[i])
 
925
      continue;
 
926
 
 
927
    memcpy (t->data + 8 + 16 * i,
 
928
        &MXF_METADATA_BASE (self->identifications[i])->instance_uid, 16);
 
929
  }
 
930
  ret = g_list_prepend (ret, t);
 
931
 
 
932
  t = g_slice_new0 (MXFLocalTag);
 
933
  memcpy (&t->ul, MXF_UL (CONTENT_STORAGE), 16);
 
934
  t->size = 16;
 
935
  t->data = g_slice_alloc (t->size);
 
936
  t->g_slice = TRUE;
 
937
  mxf_primer_pack_add_mapping (primer, 0x3b03, &t->ul);
 
938
  memcpy (t->data, &MXF_METADATA_BASE (self->content_storage)->instance_uid,
 
939
      16);
 
940
  ret = g_list_prepend (ret, t);
 
941
 
 
942
  t = g_slice_new0 (MXFLocalTag);
 
943
  memcpy (&t->ul, MXF_UL (OPERATIONAL_PATTERN), 16);
 
944
  t->size = 16;
 
945
  t->data = g_slice_alloc (t->size);
 
946
  t->g_slice = TRUE;
 
947
  mxf_primer_pack_add_mapping (primer, 0x3b09, &t->ul);
 
948
  memcpy (t->data, &self->operational_pattern, 16);
 
949
  ret = g_list_prepend (ret, t);
 
950
 
 
951
  t = g_slice_new0 (MXFLocalTag);
 
952
  memcpy (&t->ul, MXF_UL (ESSENCE_CONTAINERS), 16);
 
953
  t->size = 8 + 16 * self->n_essence_containers;
 
954
  t->data = g_slice_alloc0 (t->size);
 
955
  t->g_slice = TRUE;
 
956
  mxf_primer_pack_add_mapping (primer, 0x3b0a, &t->ul);
 
957
  GST_WRITE_UINT32_BE (t->data, self->n_essence_containers);
 
958
  GST_WRITE_UINT32_BE (t->data + 4, 16);
 
959
  for (i = 0; i < self->n_essence_containers; i++) {
 
960
    memcpy (t->data + 8 + 16 * i, &self->essence_containers[i], 16);
 
961
  }
 
962
  ret = g_list_prepend (ret, t);
 
963
 
 
964
  if (self->dm_schemes) {
 
965
    t = g_slice_new0 (MXFLocalTag);
 
966
    memcpy (&t->ul, MXF_UL (DM_SCHEMES), 16);
 
967
    t->size = 8 + 16 * self->n_dm_schemes;
 
968
    t->data = g_slice_alloc0 (t->size);
 
969
    t->g_slice = TRUE;
 
970
    mxf_primer_pack_add_mapping (primer, 0x3b0b, &t->ul);
 
971
    GST_WRITE_UINT32_BE (t->data, self->n_dm_schemes);
 
972
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
973
    for (i = 0; i < self->n_dm_schemes; i++) {
 
974
      memcpy (t->data + 8 + 16 * i, &self->dm_schemes[i], 16);
 
975
    }
 
976
    ret = g_list_prepend (ret, t);
 
977
  }
 
978
 
 
979
  return ret;
 
980
}
 
981
 
715
982
static void
716
983
mxf_metadata_preface_init (MXFMetadataPreface * self)
717
984
{
729
996
  metadata_base_class->handle_tag = mxf_metadata_preface_handle_tag;
730
997
  metadata_base_class->resolve = mxf_metadata_preface_resolve;
731
998
  metadata_base_class->to_structure = mxf_metadata_preface_to_structure;
 
999
  metadata_base_class->write_tags = mxf_metadata_preface_write_tags;
732
1000
  metadata_base_class->name_quark = MXF_QUARK (PREFACE);
733
1001
  metadata_class->type = 0x012f;
734
1002
}
774
1042
        goto error;
775
1043
      memcpy (&self->this_generation_uid, tag_data, 16);
776
1044
      GST_DEBUG ("  this generation uid = %s",
777
 
          mxf_ul_to_string (&self->this_generation_uid, str));
 
1045
          mxf_uuid_to_string (&self->this_generation_uid, str));
778
1046
      break;
779
1047
    case 0x3c01:
780
1048
      self->company_name = mxf_utf16_to_utf8 (tag_data, tag_size);
803
1071
        goto error;
804
1072
      memcpy (&self->product_uid, tag_data, 16);
805
1073
      GST_DEBUG ("  product uid = %s",
806
 
          mxf_ul_to_string (&self->product_uid, str));
 
1074
          mxf_uuid_to_string (&self->product_uid, str));
807
1075
      break;
808
1076
    case 0x3c06:
809
1077
      if (!mxf_timestamp_parse (&self->modification_date, tag_data, tag_size))
851
1119
  MXFMetadataIdentification *self = MXF_METADATA_IDENTIFICATION (m);
852
1120
  gchar str[48];
853
1121
 
854
 
  if (!mxf_ul_is_zero (&self->this_generation_uid)) {
855
 
    mxf_ul_to_string (&self->this_generation_uid, str);
 
1122
  if (!mxf_uuid_is_zero (&self->this_generation_uid)) {
 
1123
    mxf_uuid_to_string (&self->this_generation_uid, str);
856
1124
    gst_structure_id_set (ret, MXF_QUARK (THIS_GENERATION_UID), G_TYPE_STRING,
857
1125
        str, NULL);
858
1126
  }
881
1149
    gst_structure_id_set (ret, MXF_QUARK (VERSION_STRING), G_TYPE_STRING,
882
1150
        self->version_string, NULL);
883
1151
 
884
 
  if (!mxf_ul_is_zero (&self->product_uid)) {
885
 
    mxf_ul_to_string (&self->product_uid, str);
 
1152
  if (!mxf_uuid_is_zero (&self->product_uid)) {
 
1153
    mxf_uuid_to_string (&self->product_uid, str);
886
1154
    gst_structure_id_set (ret, MXF_QUARK (PRODUCT_UID), G_TYPE_STRING, str,
887
1155
        NULL);
888
1156
  }
912
1180
  return ret;
913
1181
}
914
1182
 
 
1183
static GList *
 
1184
mxf_metadata_identification_write_tags (MXFMetadataBase * m,
 
1185
    MXFPrimerPack * primer)
 
1186
{
 
1187
  MXFMetadataIdentification *self = MXF_METADATA_IDENTIFICATION (m);
 
1188
  GList *ret =
 
1189
      MXF_METADATA_BASE_CLASS
 
1190
      (mxf_metadata_identification_parent_class)->write_tags (m, primer);
 
1191
  MXFLocalTag *t;
 
1192
 
 
1193
  if (self->company_name) {
 
1194
    t = g_slice_new0 (MXFLocalTag);
 
1195
    memcpy (&t->ul, MXF_UL (COMPANY_NAME), 16);
 
1196
    t->data = mxf_utf8_to_utf16 (self->company_name, &t->size);
 
1197
    mxf_primer_pack_add_mapping (primer, 0x3c01, &t->ul);
 
1198
    ret = g_list_prepend (ret, t);
 
1199
  }
 
1200
 
 
1201
  if (self->product_name) {
 
1202
    t = g_slice_new0 (MXFLocalTag);
 
1203
    memcpy (&t->ul, MXF_UL (PRODUCT_NAME), 16);
 
1204
    t->data = mxf_utf8_to_utf16 (self->product_name, &t->size);
 
1205
    mxf_primer_pack_add_mapping (primer, 0x3c02, &t->ul);
 
1206
    ret = g_list_prepend (ret, t);
 
1207
  }
 
1208
 
 
1209
  if (!mxf_product_version_is_valid (&self->product_version)) {
 
1210
    t = g_slice_new0 (MXFLocalTag);
 
1211
    memcpy (&t->ul, MXF_UL (PRODUCT_VERSION), 16);
 
1212
    t->size = 10;
 
1213
    t->data = g_slice_alloc (t->size);
 
1214
    t->g_slice = TRUE;
 
1215
    mxf_product_version_write (&self->product_version, t->data);
 
1216
    mxf_primer_pack_add_mapping (primer, 0x3c03, &t->ul);
 
1217
    ret = g_list_prepend (ret, t);
 
1218
  }
 
1219
 
 
1220
  if (self->version_string) {
 
1221
    t = g_slice_new0 (MXFLocalTag);
 
1222
    memcpy (&t->ul, MXF_UL (VERSION_STRING), 16);
 
1223
    t->data = mxf_utf8_to_utf16 (self->version_string, &t->size);
 
1224
    mxf_primer_pack_add_mapping (primer, 0x3c04, &t->ul);
 
1225
    ret = g_list_prepend (ret, t);
 
1226
  }
 
1227
 
 
1228
  if (!mxf_uuid_is_zero (&self->product_uid)) {
 
1229
    t = g_slice_new0 (MXFLocalTag);
 
1230
    memcpy (&t->ul, MXF_UL (PRODUCT_UID), 16);
 
1231
    t->size = 16;
 
1232
    t->data = g_slice_alloc (t->size);
 
1233
    t->g_slice = TRUE;
 
1234
    memcpy (t->data, &self->product_uid, 16);
 
1235
    mxf_primer_pack_add_mapping (primer, 0x3c05, &t->ul);
 
1236
    ret = g_list_prepend (ret, t);
 
1237
  }
 
1238
 
 
1239
  if (!mxf_timestamp_is_unknown (&self->modification_date)) {
 
1240
    t = g_slice_new0 (MXFLocalTag);
 
1241
    memcpy (&t->ul, MXF_UL (MODIFICATION_DATE), 16);
 
1242
    t->size = 8;
 
1243
    t->data = g_slice_alloc (t->size);
 
1244
    t->g_slice = TRUE;
 
1245
    mxf_timestamp_write (&self->modification_date, t->data);
 
1246
    mxf_primer_pack_add_mapping (primer, 0x3c06, &t->ul);
 
1247
    ret = g_list_prepend (ret, t);
 
1248
  }
 
1249
 
 
1250
  if (!mxf_product_version_is_valid (&self->toolkit_version)) {
 
1251
    t = g_slice_new0 (MXFLocalTag);
 
1252
    memcpy (&t->ul, MXF_UL (TOOLKIT_VERSION), 16);
 
1253
    t->size = 10;
 
1254
    t->data = g_slice_alloc (t->size);
 
1255
    t->g_slice = TRUE;
 
1256
    mxf_product_version_write (&self->toolkit_version, t->data);
 
1257
    mxf_primer_pack_add_mapping (primer, 0x3c07, &t->ul);
 
1258
    ret = g_list_prepend (ret, t);
 
1259
  }
 
1260
 
 
1261
  if (self->platform) {
 
1262
    t = g_slice_new0 (MXFLocalTag);
 
1263
    memcpy (&t->ul, MXF_UL (PLATFORM), 16);
 
1264
    t->data = mxf_utf8_to_utf16 (self->platform, &t->size);
 
1265
    mxf_primer_pack_add_mapping (primer, 0x3c08, &t->ul);
 
1266
    ret = g_list_prepend (ret, t);
 
1267
  }
 
1268
 
 
1269
  return ret;
 
1270
}
 
1271
 
915
1272
static void
916
1273
mxf_metadata_identification_init (MXFMetadataIdentification * self)
917
1274
{
929
1286
  metadata_base_class->handle_tag = mxf_metadata_identification_handle_tag;
930
1287
  metadata_base_class->name_quark = MXF_QUARK (IDENTIFICATION);
931
1288
  metadata_base_class->to_structure = mxf_metadata_identification_to_structure;
 
1289
  metadata_base_class->write_tags = mxf_metadata_identification_write_tags;
932
1290
  metadata_class->type = 0x0130;
933
1291
}
934
1292
 
966
1324
 
967
1325
  switch (tag) {
968
1326
    case 0x1901:
969
 
      if (!mxf_ul_array_parse (&self->packages_uids, &self->n_packages,
 
1327
      if (!mxf_uuid_array_parse (&self->packages_uids, &self->n_packages,
970
1328
              tag_data, tag_size))
971
1329
        goto error;
972
1330
      GST_DEBUG ("  number of packages = %u", self->n_packages);
975
1333
        guint i;
976
1334
        for (i = 0; i < self->n_packages; i++) {
977
1335
          GST_DEBUG ("  package %u = %s", i,
978
 
              mxf_ul_to_string (&self->packages_uids[i], str));
 
1336
              mxf_uuid_to_string (&self->packages_uids[i], str));
979
1337
        }
980
1338
      }
981
1339
#endif
982
1340
      break;
983
1341
    case 0x1902:
984
 
      if (!mxf_ul_array_parse (&self->essence_container_data_uids,
 
1342
      if (!mxf_uuid_array_parse (&self->essence_container_data_uids,
985
1343
              &self->n_essence_container_data, tag_data, tag_size))
986
1344
        goto error;
987
1345
 
992
1350
        guint i;
993
1351
        for (i = 0; i < self->n_essence_container_data; i++) {
994
1352
          GST_DEBUG ("  essence container data %u = %s", i,
995
 
              mxf_ul_to_string (&self->essence_container_data_uids[i], str));
 
1353
              mxf_uuid_to_string (&self->essence_container_data_uids[i], str));
996
1354
        }
997
1355
      }
998
1356
#endif
1151
1509
  return ret;
1152
1510
}
1153
1511
 
 
1512
static GList *
 
1513
mxf_metadata_content_storage_write_tags (MXFMetadataBase * m,
 
1514
    MXFPrimerPack * primer)
 
1515
{
 
1516
  MXFMetadataContentStorage *self = MXF_METADATA_CONTENT_STORAGE (m);
 
1517
  GList *ret =
 
1518
      MXF_METADATA_BASE_CLASS
 
1519
      (mxf_metadata_content_storage_parent_class)->write_tags (m, primer);
 
1520
  MXFLocalTag *t;
 
1521
  guint i;
 
1522
 
 
1523
  if (self->packages) {
 
1524
    t = g_slice_new0 (MXFLocalTag);
 
1525
    memcpy (&t->ul, MXF_UL (PACKAGES), 16);
 
1526
    t->size = 8 + 16 * self->n_packages;
 
1527
    t->data = g_slice_alloc0 (t->size);
 
1528
    t->g_slice = TRUE;
 
1529
    GST_WRITE_UINT32_BE (t->data, self->n_packages);
 
1530
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
1531
    for (i = 0; i < self->n_packages; i++) {
 
1532
      if (!self->packages[i])
 
1533
        continue;
 
1534
 
 
1535
      memcpy (t->data + 8 + i * 16,
 
1536
          &MXF_METADATA_BASE (self->packages[i])->instance_uid, 16);
 
1537
    }
 
1538
 
 
1539
    mxf_primer_pack_add_mapping (primer, 0x1901, &t->ul);
 
1540
    ret = g_list_prepend (ret, t);
 
1541
  }
 
1542
 
 
1543
  if (self->essence_container_data) {
 
1544
    t = g_slice_new0 (MXFLocalTag);
 
1545
    memcpy (&t->ul, MXF_UL (ESSENCE_CONTAINER_DATA), 16);
 
1546
    t->size = 8 + 16 * self->n_essence_container_data;
 
1547
    t->data = g_slice_alloc0 (t->size);
 
1548
    t->g_slice = TRUE;
 
1549
    GST_WRITE_UINT32_BE (t->data, self->n_essence_container_data);
 
1550
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
1551
    for (i = 0; i < self->n_essence_container_data; i++) {
 
1552
      if (!self->essence_container_data[i])
 
1553
        continue;
 
1554
 
 
1555
      memcpy (t->data + 8 + i * 16,
 
1556
          &MXF_METADATA_BASE (self->essence_container_data[i])->instance_uid,
 
1557
          16);
 
1558
    }
 
1559
 
 
1560
    mxf_primer_pack_add_mapping (primer, 0x1902, &t->ul);
 
1561
    ret = g_list_prepend (ret, t);
 
1562
  }
 
1563
 
 
1564
  return ret;
 
1565
}
 
1566
 
1154
1567
static void
1155
1568
mxf_metadata_content_storage_init (MXFMetadataContentStorage * self)
1156
1569
{
1169
1582
  metadata_base_class->resolve = mxf_metadata_content_storage_resolve;
1170
1583
  metadata_base_class->name_quark = MXF_QUARK (CONTENT_STORAGE);
1171
1584
  metadata_base_class->to_structure = mxf_metadata_content_storage_to_structure;
 
1585
  metadata_base_class->write_tags = mxf_metadata_content_storage_write_tags;
1172
1586
  metadata_class->type = 0x0118;
1173
1587
}
1174
1588
 
1298
1712
  return ret;
1299
1713
}
1300
1714
 
 
1715
static GList *
 
1716
mxf_metadata_essence_container_data_write_tags (MXFMetadataBase * m,
 
1717
    MXFPrimerPack * primer)
 
1718
{
 
1719
  MXFMetadataEssenceContainerData *self =
 
1720
      MXF_METADATA_ESSENCE_CONTAINER_DATA (m);
 
1721
  GList *ret =
 
1722
      MXF_METADATA_BASE_CLASS
 
1723
      (mxf_metadata_essence_container_data_parent_class)->write_tags (m,
 
1724
      primer);
 
1725
  MXFLocalTag *t;
 
1726
 
 
1727
  t = g_slice_new0 (MXFLocalTag);
 
1728
  memcpy (&t->ul, MXF_UL (LINKED_PACKAGE_UID), 16);
 
1729
  t->size = 32;
 
1730
  t->data = g_slice_alloc0 (32);
 
1731
  t->g_slice = TRUE;
 
1732
  if (self->linked_package)
 
1733
    memcpy (t->data, &self->linked_package->parent.package_uid, 32);
 
1734
  mxf_primer_pack_add_mapping (primer, 0x2701, &t->ul);
 
1735
  ret = g_list_prepend (ret, t);
 
1736
 
 
1737
  t = g_slice_new0 (MXFLocalTag);
 
1738
  memcpy (&t->ul, MXF_UL (BODY_SID), 16);
 
1739
  t->size = 4;
 
1740
  t->data = g_slice_alloc (4);
 
1741
  t->g_slice = TRUE;
 
1742
  GST_WRITE_UINT32_BE (t->data, self->body_sid);
 
1743
  mxf_primer_pack_add_mapping (primer, 0x3f07, &t->ul);
 
1744
  ret = g_list_prepend (ret, t);
 
1745
 
 
1746
  if (self->index_sid) {
 
1747
    t = g_slice_new0 (MXFLocalTag);
 
1748
    memcpy (&t->ul, MXF_UL (INDEX_SID), 16);
 
1749
    t->size = 4;
 
1750
    t->data = g_slice_alloc (4);
 
1751
    t->g_slice = TRUE;
 
1752
    GST_WRITE_UINT32_BE (t->data, self->index_sid);
 
1753
    mxf_primer_pack_add_mapping (primer, 0x3f07, &t->ul);
 
1754
    ret = g_list_prepend (ret, t);
 
1755
  }
 
1756
 
 
1757
  return ret;
 
1758
}
 
1759
 
1301
1760
static void
1302
1761
mxf_metadata_essence_container_data_init (MXFMetadataEssenceContainerData *
1303
1762
    self)
1318
1777
  metadata_base_class->name_quark = MXF_QUARK (ESSENCE_CONTAINER_DATA);
1319
1778
  metadata_base_class->to_structure =
1320
1779
      mxf_metadata_essence_container_data_to_structure;
 
1780
  metadata_base_class->write_tags =
 
1781
      mxf_metadata_essence_container_data_write_tags;
1321
1782
  metadata_class->type = 0x0123;
1322
1783
}
1323
1784
 
1378
1839
          mxf_timestamp_to_string (&self->package_modified_date, str));
1379
1840
      break;
1380
1841
    case 0x4403:
1381
 
      if (!mxf_ul_array_parse (&self->tracks_uids, &self->n_tracks, tag_data,
 
1842
      if (!mxf_uuid_array_parse (&self->tracks_uids, &self->n_tracks, tag_data,
1382
1843
              tag_size))
1383
1844
        goto error;
1384
1845
 
1388
1849
        guint i;
1389
1850
        for (i = 0; i < self->n_tracks; i++) {
1390
1851
          GST_DEBUG ("  track %u = %s", i,
1391
 
              mxf_ul_to_string (&self->tracks_uids[i], str));
 
1852
              mxf_uuid_to_string (&self->tracks_uids[i], str));
1392
1853
        }
1393
1854
      }
1394
1855
#endif
1518
1979
  return ret;
1519
1980
}
1520
1981
 
 
1982
static GList *
 
1983
mxf_metadata_generic_package_write_tags (MXFMetadataBase * m,
 
1984
    MXFPrimerPack * primer)
 
1985
{
 
1986
  MXFMetadataGenericPackage *self = MXF_METADATA_GENERIC_PACKAGE (m);
 
1987
  GList *ret =
 
1988
      MXF_METADATA_BASE_CLASS
 
1989
      (mxf_metadata_generic_package_parent_class)->write_tags (m, primer);
 
1990
  MXFLocalTag *t;
 
1991
 
 
1992
  t = g_slice_new0 (MXFLocalTag);
 
1993
  memcpy (&t->ul, MXF_UL (PACKAGE_UID), 16);
 
1994
  t->size = 32;
 
1995
  t->data = g_slice_alloc (t->size);
 
1996
  t->g_slice = TRUE;
 
1997
  memcpy (t->data, &self->package_uid, 32);
 
1998
  mxf_primer_pack_add_mapping (primer, 0x4401, &t->ul);
 
1999
  ret = g_list_prepend (ret, t);
 
2000
 
 
2001
  if (self->name) {
 
2002
    t = g_slice_new0 (MXFLocalTag);
 
2003
    memcpy (&t->ul, MXF_UL (PACKAGE_NAME), 16);
 
2004
    t->data = mxf_utf8_to_utf16 (self->name, &t->size);
 
2005
    mxf_primer_pack_add_mapping (primer, 0x4402, &t->ul);
 
2006
    ret = g_list_prepend (ret, t);
 
2007
  }
 
2008
 
 
2009
  t = g_slice_new0 (MXFLocalTag);
 
2010
  memcpy (&t->ul, MXF_UL (PACKAGE_CREATION_DATE), 16);
 
2011
  t->size = 8;
 
2012
  t->data = g_slice_alloc (t->size);
 
2013
  t->g_slice = TRUE;
 
2014
  mxf_timestamp_write (&self->package_creation_date, t->data);
 
2015
  mxf_primer_pack_add_mapping (primer, 0x4405, &t->ul);
 
2016
  ret = g_list_prepend (ret, t);
 
2017
 
 
2018
  t = g_slice_new0 (MXFLocalTag);
 
2019
  memcpy (&t->ul, MXF_UL (PACKAGE_MODIFIED_DATE), 16);
 
2020
  t->size = 8;
 
2021
  t->data = g_slice_alloc (t->size);
 
2022
  t->g_slice = TRUE;
 
2023
  mxf_timestamp_write (&self->package_modified_date, t->data);
 
2024
  mxf_primer_pack_add_mapping (primer, 0x4404, &t->ul);
 
2025
  ret = g_list_prepend (ret, t);
 
2026
 
 
2027
  if (self->tracks) {
 
2028
    guint i;
 
2029
 
 
2030
    t = g_slice_new0 (MXFLocalTag);
 
2031
    memcpy (&t->ul, MXF_UL (TRACKS), 16);
 
2032
    t->size = 8 + 16 * self->n_tracks;
 
2033
    t->data = g_slice_alloc0 (t->size);
 
2034
    t->g_slice = TRUE;
 
2035
    GST_WRITE_UINT32_BE (t->data, self->n_tracks);
 
2036
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
2037
    for (i = 0; i < self->n_tracks; i++) {
 
2038
      if (!self->tracks[i])
 
2039
        continue;
 
2040
 
 
2041
      memcpy (t->data + 8 + 16 * i,
 
2042
          &MXF_METADATA_BASE (self->tracks[i])->instance_uid, 16);
 
2043
    }
 
2044
    mxf_primer_pack_add_mapping (primer, 0x4403, &t->ul);
 
2045
    ret = g_list_prepend (ret, t);
 
2046
  }
 
2047
 
 
2048
  return ret;
 
2049
}
 
2050
 
1521
2051
static void
1522
2052
mxf_metadata_generic_package_init (MXFMetadataGenericPackage * self)
1523
2053
{
1534
2064
  metadata_base_class->handle_tag = mxf_metadata_generic_package_handle_tag;
1535
2065
  metadata_base_class->resolve = mxf_metadata_generic_package_resolve;
1536
2066
  metadata_base_class->to_structure = mxf_metadata_generic_package_to_structure;
 
2067
  metadata_base_class->write_tags = mxf_metadata_generic_package_write_tags;
1537
2068
}
1538
2069
 
1539
2070
G_DEFINE_TYPE (MXFMetadataMaterialPackage, mxf_metadata_material_package,
1669
2200
 
1670
2201
      memcpy (&self->descriptor_uid, tag_data, 16);
1671
2202
      GST_DEBUG ("  descriptor = %s",
1672
 
          mxf_ul_to_string (&self->descriptor_uid, str));
 
2203
          mxf_uuid_to_string (&self->descriptor_uid, str));
1673
2204
      break;
1674
2205
    default:
1675
2206
      ret =
1699
2230
  gboolean ret;
1700
2231
  MXFMetadataFileDescriptor *d;
1701
2232
 
1702
 
  if (mxf_ul_is_zero (&self->descriptor_uid))
 
2233
  if (mxf_uuid_is_zero (&self->descriptor_uid))
1703
2234
    return
1704
2235
        MXF_METADATA_BASE_CLASS
1705
2236
        (mxf_metadata_source_package_parent_class)->resolve (m, metadata);
1802
2333
  return ret;
1803
2334
}
1804
2335
 
 
2336
static GList *
 
2337
mxf_metadata_source_package_write_tags (MXFMetadataBase * m,
 
2338
    MXFPrimerPack * primer)
 
2339
{
 
2340
  MXFMetadataSourcePackage *self = MXF_METADATA_SOURCE_PACKAGE (m);
 
2341
  GList *ret =
 
2342
      MXF_METADATA_BASE_CLASS
 
2343
      (mxf_metadata_source_package_parent_class)->write_tags (m, primer);
 
2344
  MXFLocalTag *t;
 
2345
 
 
2346
  if (self->descriptor) {
 
2347
    t = g_slice_new0 (MXFLocalTag);
 
2348
    memcpy (&t->ul, MXF_UL (DESCRIPTOR), 16);
 
2349
    t->size = 16;
 
2350
    t->data = g_slice_alloc (t->size);
 
2351
    t->g_slice = TRUE;
 
2352
    memcpy (t->data, &MXF_METADATA_BASE (self->descriptor)->instance_uid, 16);
 
2353
    mxf_primer_pack_add_mapping (primer, 0x4701, &t->ul);
 
2354
    ret = g_list_prepend (ret, t);
 
2355
  }
 
2356
 
 
2357
  return ret;
 
2358
}
 
2359
 
1805
2360
static void
1806
2361
mxf_metadata_source_package_init (MXFMetadataSourcePackage * self)
1807
2362
{
1818
2373
  metadata_base_class->resolve = mxf_metadata_source_package_resolve;
1819
2374
  metadata_base_class->name_quark = MXF_QUARK (SOURCE_PACKAGE);
1820
2375
  metadata_base_class->to_structure = mxf_metadata_source_package_to_structure;
 
2376
  metadata_base_class->write_tags = mxf_metadata_source_package_write_tags;
1821
2377
  metadata_class->type = 0x0137;
1822
2378
}
1823
2379
 
1870
2426
        goto error;
1871
2427
      memcpy (&self->sequence_uid, tag_data, 16);
1872
2428
      GST_DEBUG ("  sequence uid = %s",
1873
 
          mxf_ul_to_string (&self->sequence_uid, str));
 
2429
          mxf_uuid_to_string (&self->sequence_uid, str));
1874
2430
      break;
1875
2431
    default:
1876
2432
      ret =
1959
2515
  return ret;
1960
2516
}
1961
2517
 
 
2518
static GList *
 
2519
mxf_metadata_track_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
 
2520
{
 
2521
  MXFMetadataTrack *self = MXF_METADATA_TRACK (m);
 
2522
  GList *ret =
 
2523
      MXF_METADATA_BASE_CLASS (mxf_metadata_track_parent_class)->write_tags (m,
 
2524
      primer);
 
2525
  MXFLocalTag *t;
 
2526
 
 
2527
  t = g_slice_new0 (MXFLocalTag);
 
2528
  memcpy (&t->ul, MXF_UL (TRACK_ID), 16);
 
2529
  t->size = 4;
 
2530
  t->data = g_slice_alloc (t->size);
 
2531
  t->g_slice = TRUE;
 
2532
  GST_WRITE_UINT32_BE (t->data, self->track_id);
 
2533
  mxf_primer_pack_add_mapping (primer, 0x4801, &t->ul);
 
2534
  ret = g_list_prepend (ret, t);
 
2535
 
 
2536
  t = g_slice_new0 (MXFLocalTag);
 
2537
  memcpy (&t->ul, MXF_UL (TRACK_NUMBER), 16);
 
2538
  t->size = 4;
 
2539
  t->data = g_slice_alloc (t->size);
 
2540
  t->g_slice = TRUE;
 
2541
  GST_WRITE_UINT32_BE (t->data, self->track_number);
 
2542
  mxf_primer_pack_add_mapping (primer, 0x4804, &t->ul);
 
2543
  ret = g_list_prepend (ret, t);
 
2544
 
 
2545
  if (self->track_name) {
 
2546
    t = g_slice_new0 (MXFLocalTag);
 
2547
    memcpy (&t->ul, MXF_UL (TRACK_NAME), 16);
 
2548
    t->data = mxf_utf8_to_utf16 (self->track_name, &t->size);
 
2549
    mxf_primer_pack_add_mapping (primer, 0x4802, &t->ul);
 
2550
    ret = g_list_prepend (ret, t);
 
2551
  }
 
2552
 
 
2553
  t = g_slice_new0 (MXFLocalTag);
 
2554
  memcpy (&t->ul, MXF_UL (SEQUENCE), 16);
 
2555
  t->size = 16;
 
2556
  t->data = g_slice_alloc (t->size);
 
2557
  t->g_slice = TRUE;
 
2558
  memcpy (t->data, &MXF_METADATA_BASE (self->sequence)->instance_uid, 16);
 
2559
  mxf_primer_pack_add_mapping (primer, 0x4803, &t->ul);
 
2560
  ret = g_list_prepend (ret, t);
 
2561
 
 
2562
  return ret;
 
2563
}
 
2564
 
1962
2565
static void
1963
2566
mxf_metadata_track_init (MXFMetadataTrack * self)
1964
2567
{
1975
2578
  metadata_base_class->handle_tag = mxf_metadata_track_handle_tag;
1976
2579
  metadata_base_class->resolve = mxf_metadata_track_resolve;
1977
2580
  metadata_base_class->to_structure = mxf_metadata_track_to_structure;
 
2581
  metadata_base_class->write_tags = mxf_metadata_track_write_tags;
1978
2582
}
1979
2583
 
1980
2584
/* SMPTE RP224 */
1981
2585
static const struct
1982
2586
{
1983
 
  guint8 ul[16];
1984
 
  MXFMetadataTrackType type;
 
2587
  const MXFUL *ul;
 
2588
  const MXFMetadataTrackType type;
1985
2589
} mxf_metadata_track_identifier[] = {
1986
 
  { {
1987
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
1988
 
          0x01, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00},
1989
 
      MXF_METADATA_TRACK_TIMECODE_12M_INACTIVE}, { {
1990
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01,
1991
 
          0x02, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_TIMECODE_12M_ACTIVE}, { {
1992
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01,
1993
 
          0x03, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_TIMECODE_309M}, { {
1994
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01,
1995
 
          0x10, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_METADATA}, { {
1996
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02,
1997
 
          0x01, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_PICTURE_ESSENCE}, { {
1998
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02,
1999
 
          0x02, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_SOUND_ESSENCE}, { {
2000
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02,
2001
 
          0x03, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_DATA_ESSENCE}, { {
2002
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03,
2003
 
          0x01, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_AUXILIARY_DATA}, { {
2004
 
  0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03,
2005
 
          0x02, 0x00, 0x00, 0x00}, MXF_METADATA_TRACK_PARSED_TEXT},
 
2590
  {
 
2591
  MXF_UL (TRACK_TIMECODE_12M_INACTIVE),
 
2592
        MXF_METADATA_TRACK_TIMECODE_12M_INACTIVE}, {
 
2593
  MXF_UL (TRACK_TIMECODE_12M_ACTIVE), MXF_METADATA_TRACK_TIMECODE_12M_ACTIVE}, {
 
2594
  MXF_UL (TRACK_TIMECODE_309M), MXF_METADATA_TRACK_TIMECODE_309M}, {
 
2595
  MXF_UL (TRACK_METADATA), MXF_METADATA_TRACK_METADATA}, {
 
2596
  MXF_UL (TRACK_PICTURE_ESSENCE), MXF_METADATA_TRACK_PICTURE_ESSENCE}, {
 
2597
  MXF_UL (TRACK_SOUND_ESSENCE), MXF_METADATA_TRACK_SOUND_ESSENCE}, {
 
2598
  MXF_UL (TRACK_DATA_ESSENCE), MXF_METADATA_TRACK_DATA_ESSENCE}, {
 
2599
  MXF_UL (TRACK_AUXILIARY_DATA), MXF_METADATA_TRACK_AUXILIARY_DATA}, {
 
2600
  MXF_UL (TRACK_PARSED_TEXT), MXF_METADATA_TRACK_PARSED_TEXT},
2006
2601
      /* Avid video? */
2007
 
  { {
2008
 
  0x80, 0x7d, 0x00, 0x60, 0x08, 0x14, 0x3e, 0x6f, 0x6f, 0x3c, 0x8c, 0xe1,
2009
 
          0x6c, 0xef, 0x11, 0xd2}, MXF_METADATA_TRACK_PICTURE_ESSENCE}
 
2602
  {
 
2603
  MXF_UL (TRACK_AVID_PICTURE_ESSENCE), MXF_METADATA_TRACK_PICTURE_ESSENCE}
2010
2604
};
2011
2605
 
2012
2606
MXFMetadataTrackType
2015
2609
  guint i;
2016
2610
 
2017
2611
  for (i = 0; i < G_N_ELEMENTS (mxf_metadata_track_identifier); i++)
2018
 
    if (memcmp (&mxf_metadata_track_identifier[i].ul, &track_identifier->u,
2019
 
            16) == 0)
 
2612
    if (mxf_ul_is_equal (mxf_metadata_track_identifier[i].ul, track_identifier))
2020
2613
      return mxf_metadata_track_identifier[i].type;
2021
2614
 
2022
2615
  return MXF_METADATA_TRACK_UNKNOWN;
2023
2616
}
2024
2617
 
 
2618
const MXFUL *
 
2619
mxf_metadata_track_identifier_get (MXFMetadataTrackType type)
 
2620
{
 
2621
  guint i;
 
2622
 
 
2623
  for (i = 0; i < G_N_ELEMENTS (mxf_metadata_track_identifier); i++)
 
2624
    if (mxf_metadata_track_identifier[i].type == type)
 
2625
      return mxf_metadata_track_identifier[i].ul;
 
2626
 
 
2627
  return NULL;
 
2628
}
 
2629
 
2025
2630
G_DEFINE_TYPE (MXFMetadataTimelineTrack, mxf_metadata_timeline_track,
2026
2631
    MXF_TYPE_METADATA_TRACK);
2027
2632
 
2078
2683
  return ret;
2079
2684
}
2080
2685
 
 
2686
static GList *
 
2687
mxf_metadata_timeline_track_write_tags (MXFMetadataBase * m,
 
2688
    MXFPrimerPack * primer)
 
2689
{
 
2690
  MXFMetadataTimelineTrack *self = MXF_METADATA_TIMELINE_TRACK (m);
 
2691
  GList *ret =
 
2692
      MXF_METADATA_BASE_CLASS
 
2693
      (mxf_metadata_timeline_track_parent_class)->write_tags (m, primer);
 
2694
  MXFLocalTag *t;
 
2695
 
 
2696
  t = g_slice_new0 (MXFLocalTag);
 
2697
  memcpy (&t->ul, MXF_UL (EDIT_RATE), 16);
 
2698
  t->size = 8;
 
2699
  t->data = g_slice_alloc (t->size);
 
2700
  t->g_slice = TRUE;
 
2701
  GST_WRITE_UINT32_BE (t->data, self->edit_rate.n);
 
2702
  GST_WRITE_UINT32_BE (t->data + 4, self->edit_rate.d);
 
2703
  mxf_primer_pack_add_mapping (primer, 0x4b01, &t->ul);
 
2704
  ret = g_list_prepend (ret, t);
 
2705
 
 
2706
  t = g_slice_new0 (MXFLocalTag);
 
2707
  memcpy (&t->ul, MXF_UL (ORIGIN), 16);
 
2708
  t->size = 8;
 
2709
  t->data = g_slice_alloc (t->size);
 
2710
  t->g_slice = TRUE;
 
2711
  GST_WRITE_UINT64_BE (t->data, self->origin);
 
2712
  mxf_primer_pack_add_mapping (primer, 0x4b02, &t->ul);
 
2713
  ret = g_list_prepend (ret, t);
 
2714
 
 
2715
  return ret;
 
2716
}
 
2717
 
2081
2718
static void
2082
2719
mxf_metadata_timeline_track_init (MXFMetadataTimelineTrack * self)
2083
2720
{
2093
2730
  metadata_base_class->handle_tag = mxf_metadata_timeline_track_handle_tag;
2094
2731
  metadata_base_class->name_quark = MXF_QUARK (TIMELINE_TRACK);
2095
2732
  metadata_base_class->to_structure = mxf_metadata_timeline_track_to_structure;
 
2733
  metadata_base_class->write_tags = mxf_metadata_timeline_track_write_tags;
2096
2734
  metadata_class->type = 0x013b;
2097
2735
}
2098
2736
 
2152
2790
  return ret;
2153
2791
}
2154
2792
 
 
2793
static GList *
 
2794
mxf_metadata_event_track_write_tags (MXFMetadataBase * m,
 
2795
    MXFPrimerPack * primer)
 
2796
{
 
2797
  MXFMetadataEventTrack *self = MXF_METADATA_EVENT_TRACK (m);
 
2798
  GList *ret =
 
2799
      MXF_METADATA_BASE_CLASS
 
2800
      (mxf_metadata_event_track_parent_class)->write_tags (m, primer);
 
2801
  MXFLocalTag *t;
 
2802
 
 
2803
  t = g_slice_new0 (MXFLocalTag);
 
2804
  memcpy (&t->ul, MXF_UL (EVENT_EDIT_RATE), 16);
 
2805
  t->size = 8;
 
2806
  t->data = g_slice_alloc (t->size);
 
2807
  t->g_slice = TRUE;
 
2808
  GST_WRITE_UINT32_BE (t->data, self->event_edit_rate.n);
 
2809
  GST_WRITE_UINT32_BE (t->data + 4, self->event_edit_rate.d);
 
2810
  mxf_primer_pack_add_mapping (primer, 0x4901, &t->ul);
 
2811
  ret = g_list_prepend (ret, t);
 
2812
 
 
2813
  t = g_slice_new0 (MXFLocalTag);
 
2814
  memcpy (&t->ul, MXF_UL (EVENT_ORIGIN), 16);
 
2815
  t->size = 8;
 
2816
  t->data = g_slice_alloc (t->size);
 
2817
  t->g_slice = TRUE;
 
2818
  GST_WRITE_UINT64_BE (t->data, self->event_origin);
 
2819
  mxf_primer_pack_add_mapping (primer, 0x4902, &t->ul);
 
2820
  ret = g_list_prepend (ret, t);
 
2821
 
 
2822
  return ret;
 
2823
}
 
2824
 
2155
2825
static void
2156
2826
mxf_metadata_event_track_init (MXFMetadataEventTrack * self)
2157
2827
{
2167
2837
  metadata_base_class->handle_tag = mxf_metadata_event_track_handle_tag;
2168
2838
  metadata_base_class->name_quark = MXF_QUARK (EVENT_TRACK);
2169
2839
  metadata_base_class->to_structure = mxf_metadata_event_track_to_structure;
 
2840
  metadata_base_class->write_tags = mxf_metadata_event_track_write_tags;
2170
2841
  metadata_class->type = 0x0139;
2171
2842
}
2172
2843
 
2229
2900
      GST_DEBUG ("  duration = %" G_GINT64_FORMAT, self->duration);
2230
2901
      break;
2231
2902
    case 0x1001:
2232
 
      if (!mxf_ul_array_parse (&self->structural_components_uids,
 
2903
      if (!mxf_uuid_array_parse (&self->structural_components_uids,
2233
2904
              &self->n_structural_components, tag_data, tag_size))
2234
2905
        goto error;
2235
2906
 
2240
2911
        guint i;
2241
2912
        for (i = 0; i < self->n_structural_components; i++) {
2242
2913
          GST_DEBUG ("  structural component %u = %s", i,
2243
 
              mxf_ul_to_string (&self->structural_components_uids[i], str));
 
2914
              mxf_uuid_to_string (&self->structural_components_uids[i], str));
2244
2915
        }
2245
2916
      }
2246
2917
#endif
2345
3016
  return ret;
2346
3017
}
2347
3018
 
 
3019
static GList *
 
3020
mxf_metadata_sequence_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
 
3021
{
 
3022
  MXFMetadataSequence *self = MXF_METADATA_SEQUENCE (m);
 
3023
  GList *ret =
 
3024
      MXF_METADATA_BASE_CLASS (mxf_metadata_sequence_parent_class)->write_tags
 
3025
      (m, primer);
 
3026
  MXFLocalTag *t;
 
3027
 
 
3028
  t = g_slice_new0 (MXFLocalTag);
 
3029
  memcpy (&t->ul, MXF_UL (DATA_DEFINITION), 16);
 
3030
  t->size = 16;
 
3031
  t->data = g_slice_alloc (t->size);
 
3032
  t->g_slice = TRUE;
 
3033
  memcpy (t->data, &self->data_definition, 16);
 
3034
  mxf_primer_pack_add_mapping (primer, 0x0201, &t->ul);
 
3035
  ret = g_list_prepend (ret, t);
 
3036
 
 
3037
  t = g_slice_new0 (MXFLocalTag);
 
3038
  memcpy (&t->ul, MXF_UL (DURATION), 16);
 
3039
  t->size = 8;
 
3040
  t->data = g_slice_alloc (t->size);
 
3041
  t->g_slice = TRUE;
 
3042
  GST_WRITE_UINT64_BE (t->data, self->duration);
 
3043
  mxf_primer_pack_add_mapping (primer, 0x0202, &t->ul);
 
3044
  ret = g_list_prepend (ret, t);
 
3045
 
 
3046
  if (self->structural_components) {
 
3047
    guint i;
 
3048
    t = g_slice_new0 (MXFLocalTag);
 
3049
    memcpy (&t->ul, MXF_UL (STRUCTURAL_COMPONENTS), 16);
 
3050
    t->size = 8 + 16 * self->n_structural_components;
 
3051
    t->data = g_slice_alloc0 (t->size);
 
3052
    t->g_slice = TRUE;
 
3053
 
 
3054
    GST_WRITE_UINT32_BE (t->data, self->n_structural_components);
 
3055
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
3056
    for (i = 0; i < self->n_structural_components; i++) {
 
3057
      if (!self->structural_components[i])
 
3058
        continue;
 
3059
 
 
3060
      memcpy (t->data + 8 + i * 16,
 
3061
          &MXF_METADATA_BASE (self->structural_components[i])->instance_uid,
 
3062
          16);
 
3063
    }
 
3064
 
 
3065
    mxf_primer_pack_add_mapping (primer, 0x1001, &t->ul);
 
3066
    ret = g_list_prepend (ret, t);
 
3067
  }
 
3068
 
 
3069
  return ret;
 
3070
}
 
3071
 
2348
3072
static void
2349
3073
mxf_metadata_sequence_init (MXFMetadataSequence * self)
2350
3074
{
2363
3087
  metadata_base_class->resolve = mxf_metadata_sequence_resolve;
2364
3088
  metadata_base_class->name_quark = MXF_QUARK (SEQUENCE);
2365
3089
  metadata_base_class->to_structure = mxf_metadata_sequence_to_structure;
 
3090
  metadata_base_class->write_tags = mxf_metadata_sequence_write_tags;
2366
3091
  metadata_class->type = 0x010f;
2367
3092
}
2368
3093
 
2429
3154
  return ret;
2430
3155
}
2431
3156
 
 
3157
static GList *
 
3158
mxf_metadata_structural_component_write_tags (MXFMetadataBase * m,
 
3159
    MXFPrimerPack * primer)
 
3160
{
 
3161
  MXFMetadataStructuralComponent *self = MXF_METADATA_STRUCTURAL_COMPONENT (m);
 
3162
  GList *ret =
 
3163
      MXF_METADATA_BASE_CLASS
 
3164
      (mxf_metadata_structural_component_parent_class)->write_tags (m, primer);
 
3165
  MXFLocalTag *t;
 
3166
 
 
3167
  t = g_slice_new0 (MXFLocalTag);
 
3168
  memcpy (&t->ul, MXF_UL (DATA_DEFINITION), 16);
 
3169
  t->size = 16;
 
3170
  t->data = g_slice_alloc (t->size);
 
3171
  t->g_slice = TRUE;
 
3172
  memcpy (t->data, &self->data_definition, 16);
 
3173
  mxf_primer_pack_add_mapping (primer, 0x0201, &t->ul);
 
3174
  ret = g_list_prepend (ret, t);
 
3175
 
 
3176
  t = g_slice_new0 (MXFLocalTag);
 
3177
  memcpy (&t->ul, MXF_UL (DURATION), 16);
 
3178
  t->size = 8;
 
3179
  t->data = g_slice_alloc (t->size);
 
3180
  t->g_slice = TRUE;
 
3181
  GST_WRITE_UINT64_BE (t->data, self->duration);
 
3182
  mxf_primer_pack_add_mapping (primer, 0x0202, &t->ul);
 
3183
  ret = g_list_prepend (ret, t);
 
3184
 
 
3185
  return ret;
 
3186
}
 
3187
 
2432
3188
static void
2433
3189
mxf_metadata_structural_component_init (MXFMetadataStructuralComponent * self)
2434
3190
{
2445
3201
      mxf_metadata_structural_component_handle_tag;
2446
3202
  metadata_base_class->to_structure =
2447
3203
      mxf_metadata_structural_component_to_structure;
 
3204
  metadata_base_class->write_tags =
 
3205
      mxf_metadata_structural_component_write_tags;
2448
3206
}
2449
3207
 
2450
3208
G_DEFINE_TYPE (MXFMetadataTimecodeComponent, mxf_metadata_timecode_component,
2512
3270
  return ret;
2513
3271
}
2514
3272
 
 
3273
static GList *
 
3274
mxf_metadata_timecode_component_write_tags (MXFMetadataBase * m,
 
3275
    MXFPrimerPack * primer)
 
3276
{
 
3277
  MXFMetadataTimecodeComponent *self = MXF_METADATA_TIMECODE_COMPONENT (m);
 
3278
  GList *ret =
 
3279
      MXF_METADATA_BASE_CLASS
 
3280
      (mxf_metadata_timecode_component_parent_class)->write_tags (m, primer);
 
3281
  MXFLocalTag *t;
 
3282
 
 
3283
  t = g_slice_new0 (MXFLocalTag);
 
3284
  memcpy (&t->ul, MXF_UL (ROUNDED_TIMECODE_BASE), 16);
 
3285
  t->size = 2;
 
3286
  t->data = g_slice_alloc (t->size);
 
3287
  t->g_slice = TRUE;
 
3288
  GST_WRITE_UINT16_BE (t->data, self->rounded_timecode_base);
 
3289
  mxf_primer_pack_add_mapping (primer, 0x1502, &t->ul);
 
3290
  ret = g_list_prepend (ret, t);
 
3291
 
 
3292
  t = g_slice_new0 (MXFLocalTag);
 
3293
  memcpy (&t->ul, MXF_UL (START_TIMECODE), 16);
 
3294
  t->size = 8;
 
3295
  t->data = g_slice_alloc (t->size);
 
3296
  t->g_slice = TRUE;
 
3297
  GST_WRITE_UINT64_BE (t->data, self->start_timecode);
 
3298
  mxf_primer_pack_add_mapping (primer, 0x1501, &t->ul);
 
3299
  ret = g_list_prepend (ret, t);
 
3300
 
 
3301
  t = g_slice_new0 (MXFLocalTag);
 
3302
  memcpy (&t->ul, MXF_UL (DROP_FRAME), 16);
 
3303
  t->size = 1;
 
3304
  t->data = g_slice_alloc (t->size);
 
3305
  t->g_slice = TRUE;
 
3306
  GST_WRITE_UINT8 (t->data, (self->drop_frame) ? 1 : 0);
 
3307
  mxf_primer_pack_add_mapping (primer, 0x1503, &t->ul);
 
3308
  ret = g_list_prepend (ret, t);
 
3309
 
 
3310
  return ret;
 
3311
}
 
3312
 
2515
3313
static void
2516
3314
mxf_metadata_timecode_component_init (MXFMetadataTimecodeComponent * self)
2517
3315
{
2529
3327
  metadata_base_class->name_quark = MXF_QUARK (TIMECODE_COMPONENT);
2530
3328
  metadata_base_class->to_structure =
2531
3329
      mxf_metadata_timecode_component_to_structure;
 
3330
  metadata_base_class->write_tags = mxf_metadata_timecode_component_write_tags;
2532
3331
  metadata_class->type = 0x0114;
2533
3332
}
2534
3333
 
2643
3442
  return ret;
2644
3443
}
2645
3444
 
 
3445
static GList *
 
3446
mxf_metadata_source_clip_write_tags (MXFMetadataBase * m,
 
3447
    MXFPrimerPack * primer)
 
3448
{
 
3449
  MXFMetadataSourceClip *self = MXF_METADATA_SOURCE_CLIP (m);
 
3450
  GList *ret =
 
3451
      MXF_METADATA_BASE_CLASS
 
3452
      (mxf_metadata_source_clip_parent_class)->write_tags (m, primer);
 
3453
  MXFLocalTag *t;
 
3454
 
 
3455
  t = g_slice_new0 (MXFLocalTag);
 
3456
  memcpy (&t->ul, MXF_UL (START_POSITION), 16);
 
3457
  t->size = 8;
 
3458
  t->data = g_slice_alloc (t->size);
 
3459
  t->g_slice = TRUE;
 
3460
  GST_WRITE_UINT64_BE (t->data, self->start_position);
 
3461
  mxf_primer_pack_add_mapping (primer, 0x1201, &t->ul);
 
3462
  ret = g_list_prepend (ret, t);
 
3463
 
 
3464
  t = g_slice_new0 (MXFLocalTag);
 
3465
  memcpy (&t->ul, MXF_UL (SOURCE_PACKAGE_ID), 16);
 
3466
  t->size = 32;
 
3467
  t->data = g_slice_alloc (t->size);
 
3468
  t->g_slice = TRUE;
 
3469
  memcpy (t->data, &self->source_package_id, 32);
 
3470
  mxf_primer_pack_add_mapping (primer, 0x1101, &t->ul);
 
3471
  ret = g_list_prepend (ret, t);
 
3472
 
 
3473
  t = g_slice_new0 (MXFLocalTag);
 
3474
  memcpy (&t->ul, MXF_UL (SOURCE_TRACK_ID), 16);
 
3475
  t->size = 4;
 
3476
  t->data = g_slice_alloc (t->size);
 
3477
  t->g_slice = TRUE;
 
3478
  GST_WRITE_UINT32_BE (t->data, self->source_track_id);
 
3479
  mxf_primer_pack_add_mapping (primer, 0x1102, &t->ul);
 
3480
  ret = g_list_prepend (ret, t);
 
3481
 
 
3482
  return ret;
 
3483
}
2646
3484
 
2647
3485
static void
2648
3486
mxf_metadata_source_clip_init (MXFMetadataSourceClip * self)
2660
3498
  metadata_base_class->resolve = mxf_metadata_source_clip_resolve;
2661
3499
  metadata_base_class->name_quark = MXF_QUARK (SOURCE_CLIP);
2662
3500
  metadata_base_class->to_structure = mxf_metadata_source_clip_to_structure;
 
3501
  metadata_base_class->write_tags = mxf_metadata_source_clip_write_tags;
2663
3502
  metadata_class->type = 0x0111;
2664
3503
}
2665
3504
 
2771
3610
  return ret;
2772
3611
}
2773
3612
 
 
3613
static GList *
 
3614
mxf_metadata_dm_source_clip_write_tags (MXFMetadataBase * m,
 
3615
    MXFPrimerPack * primer)
 
3616
{
 
3617
  MXFMetadataDMSourceClip *self = MXF_METADATA_DM_SOURCE_CLIP (m);
 
3618
  GList *ret =
 
3619
      MXF_METADATA_BASE_CLASS
 
3620
      (mxf_metadata_dm_source_clip_parent_class)->write_tags (m, primer);
 
3621
  MXFLocalTag *t;
 
3622
 
 
3623
  if (self->track_ids) {
 
3624
    guint i;
 
3625
 
 
3626
    t = g_slice_new0 (MXFLocalTag);
 
3627
    memcpy (&t->ul, MXF_UL (DM_SOURCECLIP_TRACK_IDS), 16);
 
3628
    t->size = 8 + 4 * self->n_track_ids;
 
3629
    t->data = g_slice_alloc (t->size);
 
3630
    t->g_slice = TRUE;
 
3631
    GST_WRITE_UINT32_BE (t->data, self->n_track_ids);
 
3632
    GST_WRITE_UINT32_BE (t->data + 4, 4);
 
3633
    for (i = 0; i < self->n_track_ids; i++)
 
3634
      GST_WRITE_UINT32_BE (t->data + 8 + i * 4, self->track_ids[i]);
 
3635
    mxf_primer_pack_add_mapping (primer, 0x6103, &t->ul);
 
3636
    ret = g_list_prepend (ret, t);
 
3637
  }
 
3638
 
 
3639
  return ret;
 
3640
}
 
3641
 
2774
3642
static void
2775
3643
mxf_metadata_dm_source_clip_init (MXFMetadataDMSourceClip * self)
2776
3644
{
2788
3656
  metadata_base_class->handle_tag = mxf_metadata_dm_source_clip_handle_tag;
2789
3657
  metadata_base_class->name_quark = MXF_QUARK (DM_SOURCE_CLIP);
2790
3658
  metadata_base_class->to_structure = mxf_metadata_dm_source_clip_to_structure;
 
3659
  metadata_base_class->write_tags = mxf_metadata_dm_source_clip_write_tags;
2791
3660
  metadata_class->type = 0x0145;
2792
3661
}
2793
3662
 
2870
3739
 
2871
3740
      memcpy (&self->dm_framework_uid, tag_data, 16);
2872
3741
      GST_DEBUG ("  DM framework = %s",
2873
 
          mxf_ul_to_string (&self->dm_framework_uid, str));
 
3742
          mxf_uuid_to_string (&self->dm_framework_uid, str));
2874
3743
      break;
2875
3744
    default:
2876
3745
      ret =
2965
3834
  return ret;
2966
3835
}
2967
3836
 
 
3837
static GList *
 
3838
mxf_metadata_dm_segment_write_tags (MXFMetadataBase * m, MXFPrimerPack * primer)
 
3839
{
 
3840
  MXFMetadataDMSegment *self = MXF_METADATA_DM_SEGMENT (m);
 
3841
  GList *ret =
 
3842
      MXF_METADATA_BASE_CLASS (mxf_metadata_dm_segment_parent_class)->write_tags
 
3843
      (m, primer);
 
3844
  MXFLocalTag *t;
 
3845
 
 
3846
  if (self->event_start_position != -1) {
 
3847
    t = g_slice_new0 (MXFLocalTag);
 
3848
    memcpy (&t->ul, MXF_UL (EVENT_START_POSITION), 16);
 
3849
    t->size = 8;
 
3850
    t->data = g_slice_alloc (t->size);
 
3851
    t->g_slice = TRUE;
 
3852
    GST_WRITE_UINT64_BE (t->data, self->event_start_position);
 
3853
    mxf_primer_pack_add_mapping (primer, 0x0601, &t->ul);
 
3854
    ret = g_list_prepend (ret, t);
 
3855
  }
 
3856
 
 
3857
  if (self->event_comment) {
 
3858
    t = g_slice_new0 (MXFLocalTag);
 
3859
    memcpy (&t->ul, MXF_UL (EVENT_COMMENT), 16);
 
3860
    t->data = mxf_utf8_to_utf16 (self->event_comment, &t->size);
 
3861
    mxf_primer_pack_add_mapping (primer, 0x0602, &t->ul);
 
3862
    ret = g_list_prepend (ret, t);
 
3863
  }
 
3864
 
 
3865
  if (self->track_ids) {
 
3866
    guint i;
 
3867
 
 
3868
    t = g_slice_new0 (MXFLocalTag);
 
3869
    memcpy (&t->ul, MXF_UL (DM_SEGMENT_TRACK_IDS), 16);
 
3870
    t->size = 8 + 4 * self->n_track_ids;
 
3871
    t->data = g_slice_alloc (t->size);
 
3872
    t->g_slice = TRUE;
 
3873
    GST_WRITE_UINT32_BE (t->data, self->n_track_ids);
 
3874
    GST_WRITE_UINT32_BE (t->data + 4, 4);
 
3875
    for (i = 0; i < self->n_track_ids; i++)
 
3876
      GST_WRITE_UINT32_BE (t->data + 8 + i * 4, self->track_ids[i]);
 
3877
    mxf_primer_pack_add_mapping (primer, 0x6102, &t->ul);
 
3878
    ret = g_list_prepend (ret, t);
 
3879
  }
 
3880
 
 
3881
  if (self->dm_framework) {
 
3882
    t = g_slice_new0 (MXFLocalTag);
 
3883
    memcpy (&t->ul, MXF_UL (DM_FRAMEWORK), 16);
 
3884
    t->size = 16;
 
3885
    t->data = g_slice_alloc (t->size);
 
3886
    t->g_slice = TRUE;
 
3887
    memcpy (t->data, &MXF_METADATA_BASE (self->dm_framework)->instance_uid, 16);
 
3888
    mxf_primer_pack_add_mapping (primer, 0x6101, &t->ul);
 
3889
    ret = g_list_prepend (ret, t);
 
3890
  }
 
3891
 
 
3892
  return ret;
 
3893
}
 
3894
 
2968
3895
static void
2969
3896
mxf_metadata_dm_segment_init (MXFMetadataDMSegment * self)
2970
3897
{
2971
 
 
 
3898
  self->event_start_position = -1;
2972
3899
}
2973
3900
 
2974
3901
static void
2983
3910
  metadata_base_class->resolve = mxf_metadata_dm_segment_resolve;
2984
3911
  metadata_base_class->name_quark = MXF_QUARK (DM_SEGMENT);
2985
3912
  metadata_base_class->to_structure = mxf_metadata_dm_segment_to_structure;
 
3913
  metadata_base_class->write_tags = mxf_metadata_dm_segment_write_tags;
2986
3914
  metadata_class->type = 0x0141;
2987
3915
}
2988
3916
 
3018
3946
 
3019
3947
  switch (tag) {
3020
3948
    case 0x2f01:
3021
 
      if (!mxf_ul_array_parse (&self->locators_uids, &self->n_locators,
 
3949
      if (!mxf_uuid_array_parse (&self->locators_uids, &self->n_locators,
3022
3950
              tag_data, tag_size))
3023
3951
        goto error;
3024
3952
 
3028
3956
        guint i;
3029
3957
        for (i = 0; i < self->n_locators; i++) {
3030
3958
          GST_DEBUG ("  locator %u = %s", i,
3031
 
              mxf_ul_to_string (&self->locators_uids[i], str));
 
3959
              mxf_uuid_to_string (&self->locators_uids[i], str));
3032
3960
        }
3033
3961
      }
3034
3962
#endif
3129
4057
  return ret;
3130
4058
}
3131
4059
 
 
4060
static GList *
 
4061
mxf_metadata_generic_descriptor_write_tags (MXFMetadataBase * m,
 
4062
    MXFPrimerPack * primer)
 
4063
{
 
4064
  MXFMetadataGenericDescriptor *self = MXF_METADATA_GENERIC_DESCRIPTOR (m);
 
4065
  GList *ret =
 
4066
      MXF_METADATA_BASE_CLASS
 
4067
      (mxf_metadata_generic_descriptor_parent_class)->write_tags (m, primer);
 
4068
  MXFLocalTag *t;
 
4069
 
 
4070
  if (self->locators) {
 
4071
    guint i;
 
4072
 
 
4073
    t = g_slice_new0 (MXFLocalTag);
 
4074
    memcpy (&t->ul, MXF_UL (LOCATORS), 16);
 
4075
    t->size = 8 + 16 * self->n_locators;;
 
4076
    t->data = g_slice_alloc0 (t->size);
 
4077
    t->g_slice = TRUE;
 
4078
    GST_WRITE_UINT32_BE (t->data, self->n_locators);
 
4079
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
4080
    for (i = 0; i < self->n_locators; i++) {
 
4081
      if (!self->locators[i])
 
4082
        continue;
 
4083
      memcpy (t->data + 8 + 16 * i,
 
4084
          &MXF_METADATA_BASE (self->locators[i])->instance_uid, 16);
 
4085
    }
 
4086
    mxf_primer_pack_add_mapping (primer, 0x2f01, &t->ul);
 
4087
    ret = g_list_prepend (ret, t);
 
4088
  }
 
4089
 
 
4090
  return ret;
 
4091
}
 
4092
 
3132
4093
static void
3133
4094
mxf_metadata_generic_descriptor_init (MXFMetadataGenericDescriptor * self)
3134
4095
{
3147
4108
  metadata_base_class->resolve = mxf_metadata_generic_descriptor_resolve;
3148
4109
  metadata_base_class->to_structure =
3149
4110
      mxf_metadata_generic_descriptor_to_structure;
 
4111
  metadata_base_class->write_tags = mxf_metadata_generic_descriptor_write_tags;
3150
4112
}
3151
4113
 
3152
4114
G_DEFINE_TYPE (MXFMetadataFileDescriptor, mxf_metadata_file_descriptor,
3247
4209
  return ret;
3248
4210
}
3249
4211
 
 
4212
static GList *
 
4213
mxf_metadata_file_descriptor_write_tags (MXFMetadataBase * m,
 
4214
    MXFPrimerPack * primer)
 
4215
{
 
4216
  MXFMetadataFileDescriptor *self = MXF_METADATA_FILE_DESCRIPTOR (m);
 
4217
  GList *ret =
 
4218
      MXF_METADATA_BASE_CLASS
 
4219
      (mxf_metadata_file_descriptor_parent_class)->write_tags (m, primer);
 
4220
  MXFLocalTag *t;
 
4221
 
 
4222
  if (self->linked_track_id) {
 
4223
    t = g_slice_new0 (MXFLocalTag);
 
4224
    memcpy (&t->ul, MXF_UL (LINKED_TRACK_ID), 16);
 
4225
    t->size = 4;
 
4226
    t->data = g_slice_alloc (t->size);
 
4227
    t->g_slice = TRUE;
 
4228
    GST_WRITE_UINT32_BE (t->data, self->linked_track_id);
 
4229
    mxf_primer_pack_add_mapping (primer, 0x3006, &t->ul);
 
4230
    ret = g_list_prepend (ret, t);
 
4231
  }
 
4232
 
 
4233
  t = g_slice_new0 (MXFLocalTag);
 
4234
  memcpy (&t->ul, MXF_UL (SAMPLE_RATE), 16);
 
4235
  t->size = 8;
 
4236
  t->data = g_slice_alloc (t->size);
 
4237
  t->g_slice = TRUE;
 
4238
  GST_WRITE_UINT32_BE (t->data, self->sample_rate.n);
 
4239
  GST_WRITE_UINT32_BE (t->data + 4, self->sample_rate.d);
 
4240
  mxf_primer_pack_add_mapping (primer, 0x3001, &t->ul);
 
4241
  ret = g_list_prepend (ret, t);
 
4242
 
 
4243
  if (self->container_duration > 0) {
 
4244
    t = g_slice_new0 (MXFLocalTag);
 
4245
    memcpy (&t->ul, MXF_UL (CONTAINER_DURATION), 16);
 
4246
    t->size = 8;
 
4247
    t->data = g_slice_alloc (t->size);
 
4248
    t->g_slice = TRUE;
 
4249
    GST_WRITE_UINT64_BE (t->data, self->container_duration);
 
4250
    mxf_primer_pack_add_mapping (primer, 0x3002, &t->ul);
 
4251
    ret = g_list_prepend (ret, t);
 
4252
  }
 
4253
 
 
4254
  t = g_slice_new0 (MXFLocalTag);
 
4255
  memcpy (&t->ul, MXF_UL (ESSENCE_CONTAINER), 16);
 
4256
  t->size = 16;
 
4257
  t->data = g_slice_alloc (t->size);
 
4258
  t->g_slice = TRUE;
 
4259
  memcpy (t->data, &self->essence_container, 16);
 
4260
  mxf_primer_pack_add_mapping (primer, 0x3004, &t->ul);
 
4261
  ret = g_list_prepend (ret, t);
 
4262
 
 
4263
  if (!mxf_ul_is_zero (&self->codec)) {
 
4264
    t = g_slice_new0 (MXFLocalTag);
 
4265
    memcpy (&t->ul, MXF_UL (CODEC), 16);
 
4266
    t->size = 16;
 
4267
    t->data = g_slice_alloc (t->size);
 
4268
    t->g_slice = TRUE;
 
4269
    memcpy (t->data, &self->codec, 16);
 
4270
    mxf_primer_pack_add_mapping (primer, 0x3005, &t->ul);
 
4271
    ret = g_list_prepend (ret, t);
 
4272
  }
 
4273
 
 
4274
  return ret;
 
4275
}
 
4276
 
3250
4277
static void
3251
4278
mxf_metadata_file_descriptor_init (MXFMetadataFileDescriptor * self)
3252
4279
{
3262
4289
  metadata_base_class->handle_tag = mxf_metadata_file_descriptor_handle_tag;
3263
4290
  metadata_base_class->name_quark = MXF_QUARK (FILE_DESCRIPTOR);
3264
4291
  metadata_base_class->to_structure = mxf_metadata_file_descriptor_to_structure;
 
4292
  metadata_base_class->write_tags = mxf_metadata_file_descriptor_write_tags;
3265
4293
  metadata_class->type = 0x0125;
3266
4294
}
3267
4295
 
3567
4595
  return ret;
3568
4596
}
3569
4597
 
 
4598
static GList *
 
4599
mxf_metadata_generic_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
 
4600
    MXFPrimerPack * primer)
 
4601
{
 
4602
  MXFMetadataGenericPictureEssenceDescriptor *self =
 
4603
      MXF_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (m);
 
4604
  GList *ret =
 
4605
      MXF_METADATA_BASE_CLASS
 
4606
      (mxf_metadata_generic_picture_essence_descriptor_parent_class)->write_tags
 
4607
      (m, primer);
 
4608
  MXFLocalTag *t;
 
4609
 
 
4610
  if (self->signal_standard != 1) {
 
4611
    t = g_slice_new0 (MXFLocalTag);
 
4612
    memcpy (&t->ul, MXF_UL (SIGNAL_STANDARD), 16);
 
4613
    t->size = 1;
 
4614
    t->data = g_slice_alloc (t->size);
 
4615
    t->g_slice = TRUE;
 
4616
    GST_WRITE_UINT8 (t->data, self->signal_standard);
 
4617
    mxf_primer_pack_add_mapping (primer, 0x3215, &t->ul);
 
4618
    ret = g_list_prepend (ret, t);
 
4619
  }
 
4620
 
 
4621
  if (self->frame_layout != 255) {
 
4622
    t = g_slice_new0 (MXFLocalTag);
 
4623
    memcpy (&t->ul, MXF_UL (FRAME_LAYOUT), 16);
 
4624
    t->size = 1;
 
4625
    t->data = g_slice_alloc (t->size);
 
4626
    t->g_slice = TRUE;
 
4627
    GST_WRITE_UINT8 (t->data, self->frame_layout);
 
4628
    mxf_primer_pack_add_mapping (primer, 0x320c, &t->ul);
 
4629
    ret = g_list_prepend (ret, t);
 
4630
  }
 
4631
 
 
4632
  if (self->stored_width != 0) {
 
4633
    t = g_slice_new0 (MXFLocalTag);
 
4634
    memcpy (&t->ul, MXF_UL (STORED_WIDTH), 16);
 
4635
    t->size = 4;
 
4636
    t->data = g_slice_alloc (t->size);
 
4637
    t->g_slice = TRUE;
 
4638
    GST_WRITE_UINT32_BE (t->data, self->stored_width);
 
4639
    mxf_primer_pack_add_mapping (primer, 0x3203, &t->ul);
 
4640
    ret = g_list_prepend (ret, t);
 
4641
  }
 
4642
 
 
4643
  if (self->stored_height != 0) {
 
4644
    t = g_slice_new0 (MXFLocalTag);
 
4645
    memcpy (&t->ul, MXF_UL (STORED_HEIGHT), 16);
 
4646
    t->size = 4;
 
4647
    t->data = g_slice_alloc (t->size);
 
4648
    t->g_slice = TRUE;
 
4649
    GST_WRITE_UINT32_BE (t->data, self->stored_height);
 
4650
    mxf_primer_pack_add_mapping (primer, 0x3202, &t->ul);
 
4651
    ret = g_list_prepend (ret, t);
 
4652
  }
 
4653
 
 
4654
  if (self->stored_f2_offset != 0) {
 
4655
    t = g_slice_new0 (MXFLocalTag);
 
4656
    memcpy (&t->ul, MXF_UL (STORED_F2_OFFSET), 16);
 
4657
    t->size = 4;
 
4658
    t->data = g_slice_alloc (t->size);
 
4659
    t->g_slice = TRUE;
 
4660
    GST_WRITE_UINT32_BE (t->data, self->stored_f2_offset);
 
4661
    mxf_primer_pack_add_mapping (primer, 0x3216, &t->ul);
 
4662
    ret = g_list_prepend (ret, t);
 
4663
  }
 
4664
 
 
4665
  if (self->sampled_width != 0) {
 
4666
    t = g_slice_new0 (MXFLocalTag);
 
4667
    memcpy (&t->ul, MXF_UL (SAMPLED_WIDTH), 16);
 
4668
    t->size = 4;
 
4669
    t->data = g_slice_alloc (t->size);
 
4670
    t->g_slice = TRUE;
 
4671
    GST_WRITE_UINT32_BE (t->data, self->sampled_width);
 
4672
    mxf_primer_pack_add_mapping (primer, 0x3205, &t->ul);
 
4673
    ret = g_list_prepend (ret, t);
 
4674
  }
 
4675
 
 
4676
  if (self->sampled_height != 0) {
 
4677
    t = g_slice_new0 (MXFLocalTag);
 
4678
    memcpy (&t->ul, MXF_UL (SAMPLED_HEIGHT), 16);
 
4679
    t->size = 4;
 
4680
    t->data = g_slice_alloc (t->size);
 
4681
    t->g_slice = TRUE;
 
4682
    GST_WRITE_UINT32_BE (t->data, self->sampled_height);
 
4683
    mxf_primer_pack_add_mapping (primer, 0x3204, &t->ul);
 
4684
    ret = g_list_prepend (ret, t);
 
4685
  }
 
4686
 
 
4687
  if (self->sampled_x_offset != 0) {
 
4688
    t = g_slice_new0 (MXFLocalTag);
 
4689
    memcpy (&t->ul, MXF_UL (SAMPLED_X_OFFSET), 16);
 
4690
    t->size = 4;
 
4691
    t->data = g_slice_alloc (t->size);
 
4692
    t->g_slice = TRUE;
 
4693
    GST_WRITE_UINT32_BE (t->data, self->sampled_x_offset);
 
4694
    mxf_primer_pack_add_mapping (primer, 0x3206, &t->ul);
 
4695
    ret = g_list_prepend (ret, t);
 
4696
  }
 
4697
 
 
4698
  if (self->sampled_y_offset != 0) {
 
4699
    t = g_slice_new0 (MXFLocalTag);
 
4700
    memcpy (&t->ul, MXF_UL (SAMPLED_Y_OFFSET), 16);
 
4701
    t->size = 4;
 
4702
    t->data = g_slice_alloc (t->size);
 
4703
    t->g_slice = TRUE;
 
4704
    GST_WRITE_UINT32_BE (t->data, self->sampled_y_offset);
 
4705
    mxf_primer_pack_add_mapping (primer, 0x3207, &t->ul);
 
4706
    ret = g_list_prepend (ret, t);
 
4707
  }
 
4708
 
 
4709
  if (self->display_height != 0) {
 
4710
    t = g_slice_new0 (MXFLocalTag);
 
4711
    memcpy (&t->ul, MXF_UL (DISPLAY_HEIGHT), 16);
 
4712
    t->size = 4;
 
4713
    t->data = g_slice_alloc (t->size);
 
4714
    t->g_slice = TRUE;
 
4715
    GST_WRITE_UINT32_BE (t->data, self->display_height);
 
4716
    mxf_primer_pack_add_mapping (primer, 0x3208, &t->ul);
 
4717
    ret = g_list_prepend (ret, t);
 
4718
  }
 
4719
 
 
4720
  if (self->display_width != 0) {
 
4721
    t = g_slice_new0 (MXFLocalTag);
 
4722
    memcpy (&t->ul, MXF_UL (DISPLAY_WIDTH), 16);
 
4723
    t->size = 4;
 
4724
    t->data = g_slice_alloc (t->size);
 
4725
    t->g_slice = TRUE;
 
4726
    GST_WRITE_UINT32_BE (t->data, self->display_width);
 
4727
    mxf_primer_pack_add_mapping (primer, 0x3209, &t->ul);
 
4728
    ret = g_list_prepend (ret, t);
 
4729
  }
 
4730
 
 
4731
  if (self->display_x_offset != 0) {
 
4732
    t = g_slice_new0 (MXFLocalTag);
 
4733
    memcpy (&t->ul, MXF_UL (DISPLAY_X_OFFSET), 16);
 
4734
    t->size = 4;
 
4735
    t->data = g_slice_alloc (t->size);
 
4736
    t->g_slice = TRUE;
 
4737
    GST_WRITE_UINT32_BE (t->data, self->display_x_offset);
 
4738
    mxf_primer_pack_add_mapping (primer, 0x320a, &t->ul);
 
4739
    ret = g_list_prepend (ret, t);
 
4740
  }
 
4741
 
 
4742
  if (self->display_y_offset != 0) {
 
4743
    t = g_slice_new0 (MXFLocalTag);
 
4744
    memcpy (&t->ul, MXF_UL (DISPLAY_Y_OFFSET), 16);
 
4745
    t->size = 4;
 
4746
    t->data = g_slice_alloc (t->size);
 
4747
    t->g_slice = TRUE;
 
4748
    GST_WRITE_UINT32_BE (t->data, self->display_y_offset);
 
4749
    mxf_primer_pack_add_mapping (primer, 0x320b, &t->ul);
 
4750
    ret = g_list_prepend (ret, t);
 
4751
  }
 
4752
 
 
4753
  if (self->display_f2_offset != 0) {
 
4754
    t = g_slice_new0 (MXFLocalTag);
 
4755
    memcpy (&t->ul, MXF_UL (DISPLAY_F2_OFFSET), 16);
 
4756
    t->size = 4;
 
4757
    t->data = g_slice_alloc (t->size);
 
4758
    t->g_slice = TRUE;
 
4759
    GST_WRITE_UINT32_BE (t->data, self->display_f2_offset);
 
4760
    mxf_primer_pack_add_mapping (primer, 0x3217, &t->ul);
 
4761
    ret = g_list_prepend (ret, t);
 
4762
  }
 
4763
 
 
4764
  if (self->aspect_ratio.n != 0 && self->aspect_ratio.d != 0) {
 
4765
    t = g_slice_new0 (MXFLocalTag);
 
4766
    memcpy (&t->ul, MXF_UL (ASPECT_RATIO), 16);
 
4767
    t->size = 8;
 
4768
    t->data = g_slice_alloc (t->size);
 
4769
    t->g_slice = TRUE;
 
4770
    GST_WRITE_UINT32_BE (t->data, self->aspect_ratio.n);
 
4771
    GST_WRITE_UINT32_BE (t->data + 4, self->aspect_ratio.d);
 
4772
    mxf_primer_pack_add_mapping (primer, 0x320e, &t->ul);
 
4773
    ret = g_list_prepend (ret, t);
 
4774
  }
 
4775
 
 
4776
  if (self->active_format_descriptor != 0) {
 
4777
    t = g_slice_new0 (MXFLocalTag);
 
4778
    memcpy (&t->ul, MXF_UL (ACTIVE_FORMAT_DESCRIPTOR), 16);
 
4779
    t->size = 1;
 
4780
    t->data = g_slice_alloc (t->size);
 
4781
    t->g_slice = TRUE;
 
4782
    GST_WRITE_UINT8 (t->data, self->active_format_descriptor);
 
4783
    mxf_primer_pack_add_mapping (primer, 0x3218, &t->ul);
 
4784
    ret = g_list_prepend (ret, t);
 
4785
  }
 
4786
 
 
4787
  if (self->video_line_map[0] != 0 || self->video_line_map[1] != 0) {
 
4788
    t = g_slice_new0 (MXFLocalTag);
 
4789
    memcpy (&t->ul, MXF_UL (VIDEO_LINE_MAP), 16);
 
4790
    t->size = 16;
 
4791
    t->data = g_slice_alloc (t->size);
 
4792
    t->g_slice = TRUE;
 
4793
    GST_WRITE_UINT64_BE (t->data, self->video_line_map[0]);
 
4794
    GST_WRITE_UINT64_BE (t->data + 8, self->video_line_map[1]);
 
4795
    mxf_primer_pack_add_mapping (primer, 0x320d, &t->ul);
 
4796
    ret = g_list_prepend (ret, t);
 
4797
  }
 
4798
 
 
4799
  if (self->alpha_transparency != 0) {
 
4800
    t = g_slice_new0 (MXFLocalTag);
 
4801
    memcpy (&t->ul, MXF_UL (ALPHA_TRANSPARENCY), 16);
 
4802
    t->size = 1;
 
4803
    t->data = g_slice_alloc (t->size);
 
4804
    t->g_slice = TRUE;
 
4805
    GST_WRITE_UINT8 (t->data, self->alpha_transparency);
 
4806
    mxf_primer_pack_add_mapping (primer, 0x320f, &t->ul);
 
4807
    ret = g_list_prepend (ret, t);
 
4808
  }
 
4809
 
 
4810
  if (!mxf_ul_is_zero (&self->capture_gamma)) {
 
4811
    t = g_slice_new0 (MXFLocalTag);
 
4812
    memcpy (&t->ul, MXF_UL (CAPTURE_GAMMA), 16);
 
4813
    t->size = 16;
 
4814
    t->data = g_slice_alloc (t->size);
 
4815
    t->g_slice = TRUE;
 
4816
    memcpy (t->data, &self->capture_gamma, 16);
 
4817
    mxf_primer_pack_add_mapping (primer, 0x3210, &t->ul);
 
4818
    ret = g_list_prepend (ret, t);
 
4819
  }
 
4820
 
 
4821
  if (self->image_alignment_offset != 0) {
 
4822
    t = g_slice_new0 (MXFLocalTag);
 
4823
    memcpy (&t->ul, MXF_UL (IMAGE_ALIGNMENT_OFFSET), 16);
 
4824
    t->size = 4;
 
4825
    t->data = g_slice_alloc (t->size);
 
4826
    t->g_slice = TRUE;
 
4827
    GST_WRITE_UINT32_BE (t->data, self->image_alignment_offset);
 
4828
    mxf_primer_pack_add_mapping (primer, 0x3211, &t->ul);
 
4829
    ret = g_list_prepend (ret, t);
 
4830
  }
 
4831
 
 
4832
  if (self->image_start_offset != 0) {
 
4833
    t = g_slice_new0 (MXFLocalTag);
 
4834
    memcpy (&t->ul, MXF_UL (IMAGE_START_OFFSET), 16);
 
4835
    t->size = 4;
 
4836
    t->data = g_slice_alloc (t->size);
 
4837
    t->g_slice = TRUE;
 
4838
    GST_WRITE_UINT32_BE (t->data, self->image_start_offset);
 
4839
    mxf_primer_pack_add_mapping (primer, 0x3213, &t->ul);
 
4840
    ret = g_list_prepend (ret, t);
 
4841
  }
 
4842
 
 
4843
  if (self->image_end_offset != 0) {
 
4844
    t = g_slice_new0 (MXFLocalTag);
 
4845
    memcpy (&t->ul, MXF_UL (IMAGE_END_OFFSET), 16);
 
4846
    t->size = 4;
 
4847
    t->data = g_slice_alloc (t->size);
 
4848
    t->g_slice = TRUE;
 
4849
    GST_WRITE_UINT32_BE (t->data, self->image_end_offset);
 
4850
    mxf_primer_pack_add_mapping (primer, 0x3214, &t->ul);
 
4851
    ret = g_list_prepend (ret, t);
 
4852
  }
 
4853
 
 
4854
  if (self->field_dominance != 0) {
 
4855
    t = g_slice_new0 (MXFLocalTag);
 
4856
    memcpy (&t->ul, MXF_UL (FIELD_DOMINANCE), 16);
 
4857
    t->size = 1;
 
4858
    t->data = g_slice_alloc (t->size);
 
4859
    t->g_slice = TRUE;
 
4860
    GST_WRITE_UINT8 (t->data, self->field_dominance);
 
4861
    mxf_primer_pack_add_mapping (primer, 0x3212, &t->ul);
 
4862
    ret = g_list_prepend (ret, t);
 
4863
  }
 
4864
 
 
4865
  if (!mxf_ul_is_zero (&self->picture_essence_coding)) {
 
4866
    t = g_slice_new0 (MXFLocalTag);
 
4867
    memcpy (&t->ul, MXF_UL (PICTURE_ESSENCE_CODING), 16);
 
4868
    t->size = 16;
 
4869
    t->data = g_slice_alloc (t->size);
 
4870
    t->g_slice = TRUE;
 
4871
    memcpy (t->data, &self->picture_essence_coding, 16);
 
4872
    mxf_primer_pack_add_mapping (primer, 0x3201, &t->ul);
 
4873
    ret = g_list_prepend (ret, t);
 
4874
  }
 
4875
 
 
4876
  return ret;
 
4877
}
 
4878
 
3570
4879
static void
3571
4880
    mxf_metadata_generic_picture_essence_descriptor_init
3572
4881
    (MXFMetadataGenericPictureEssenceDescriptor * self)
3588
4897
      MXF_QUARK (GENERIC_PICTURE_ESSENCE_DESCRIPTOR);
3589
4898
  metadata_base_class->to_structure =
3590
4899
      mxf_metadata_generic_picture_essence_descriptor_to_structure;
 
4900
  metadata_base_class->write_tags =
 
4901
      mxf_metadata_generic_picture_essence_descriptor_write_tags;
3591
4902
  metadata_class->type = 0x0127;
3592
4903
}
3593
4904
 
3618
4929
   * See SMPTE 377M E2.2 and E1.2
3619
4930
   */
3620
4931
  if (self->frame_layout == 1 || self->frame_layout == 2
3621
 
      || self->frame_layout == 4)
 
4932
      || self->frame_layout == 4) {
3622
4933
    height *= 2;
 
4934
    gst_caps_set_simple (caps, "interlaced", G_TYPE_BOOLEAN, TRUE, NULL);
 
4935
  }
3623
4936
 
3624
4937
  if (width == 0 || height == 0) {
3625
4938
    GST_ERROR ("Invalid width/height");
3641
4954
      par_n, par_d, NULL);
3642
4955
}
3643
4956
 
 
4957
static gint
 
4958
gst_greatest_common_divisor (gint a, gint b)
 
4959
{
 
4960
  while (b != 0) {
 
4961
    int temp = a;
 
4962
 
 
4963
    a = b;
 
4964
    b = temp % b;
 
4965
  }
 
4966
 
 
4967
  return ABS (a);
 
4968
}
 
4969
 
 
4970
gboolean
 
4971
    mxf_metadata_generic_picture_essence_descriptor_from_caps
 
4972
    (MXFMetadataGenericPictureEssenceDescriptor * self, GstCaps * caps) {
 
4973
  gint par_n, par_d, gcd;
 
4974
  gint width, height;
 
4975
  gint fps_n, fps_d;
 
4976
  MXFMetadataFileDescriptor *f = (MXFMetadataFileDescriptor *) self;
 
4977
  GstStructure *s;
 
4978
  gboolean interlaced;
 
4979
 
 
4980
  g_return_val_if_fail (MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR
 
4981
      (self), FALSE);
 
4982
  g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
 
4983
 
 
4984
  s = gst_caps_get_structure (caps, 0);
 
4985
 
 
4986
  if (!gst_structure_get_boolean (s, "interlaced", &interlaced) || !interlaced)
 
4987
    self->frame_layout = 1;
 
4988
  else
 
4989
    self->frame_layout = 3;
 
4990
 
 
4991
  if (!gst_structure_get_fraction (s, "framerate", &fps_n, &fps_d)) {
 
4992
    GST_ERROR ("Invalid framerate");
 
4993
    return FALSE;
 
4994
  }
 
4995
  f->sample_rate.n = fps_n;
 
4996
  f->sample_rate.d = fps_d;
 
4997
 
 
4998
  if (!gst_structure_get_int (s, "width", &width) ||
 
4999
      !gst_structure_get_int (s, "height", &height)) {
 
5000
    GST_ERROR ("Invalid width/height");
 
5001
    return FALSE;
 
5002
  }
 
5003
 
 
5004
  self->stored_width = width;
 
5005
  self->stored_height = height;
 
5006
 
 
5007
  if (!gst_structure_get_fraction (s, "pixel-aspect-ratio", &par_n, &par_d)) {
 
5008
    par_n = 1;
 
5009
    par_d = 1;
 
5010
  }
 
5011
 
 
5012
  self->aspect_ratio.n = par_n * width;
 
5013
  self->aspect_ratio.d = par_d * height;
 
5014
  gcd =
 
5015
      gst_greatest_common_divisor (self->aspect_ratio.n, self->aspect_ratio.d);
 
5016
  self->aspect_ratio.n /= gcd;
 
5017
  self->aspect_ratio.d /= gcd;
 
5018
 
 
5019
  return TRUE;
 
5020
}
 
5021
 
 
5022
 
3644
5023
G_DEFINE_TYPE (MXFMetadataGenericSoundEssenceDescriptor,
3645
5024
    mxf_metadata_generic_sound_essence_descriptor,
3646
5025
    MXF_TYPE_METADATA_FILE_DESCRIPTOR);
3770
5149
  return ret;
3771
5150
}
3772
5151
 
 
5152
static GList *
 
5153
mxf_metadata_generic_sound_essence_descriptor_write_tags (MXFMetadataBase * m,
 
5154
    MXFPrimerPack * primer)
 
5155
{
 
5156
  MXFMetadataGenericSoundEssenceDescriptor *self =
 
5157
      MXF_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (m);
 
5158
  GList *ret =
 
5159
      MXF_METADATA_BASE_CLASS
 
5160
      (mxf_metadata_generic_sound_essence_descriptor_parent_class)->write_tags
 
5161
      (m, primer);
 
5162
  MXFLocalTag *t;
 
5163
 
 
5164
  if (self->audio_sampling_rate.d && self->audio_sampling_rate.n) {
 
5165
    t = g_slice_new0 (MXFLocalTag);
 
5166
    memcpy (&t->ul, MXF_UL (AUDIO_SAMPLING_RATE), 16);
 
5167
    t->size = 8;
 
5168
    t->data = g_slice_alloc (t->size);
 
5169
    t->g_slice = TRUE;
 
5170
    GST_WRITE_UINT32_BE (t->data, self->audio_sampling_rate.n);
 
5171
    GST_WRITE_UINT32_BE (t->data + 4, self->audio_sampling_rate.d);
 
5172
    mxf_primer_pack_add_mapping (primer, 0x3d03, &t->ul);
 
5173
    ret = g_list_prepend (ret, t);
 
5174
  }
 
5175
 
 
5176
  t = g_slice_new0 (MXFLocalTag);
 
5177
  memcpy (&t->ul, MXF_UL (LOCKED), 16);
 
5178
  t->size = 1;
 
5179
  t->data = g_slice_alloc (t->size);
 
5180
  t->g_slice = TRUE;
 
5181
  GST_WRITE_UINT8 (t->data, (self->locked) ? 1 : 0);
 
5182
  mxf_primer_pack_add_mapping (primer, 0x3d02, &t->ul);
 
5183
  ret = g_list_prepend (ret, t);
 
5184
 
 
5185
  if (self->audio_ref_level) {
 
5186
    t = g_slice_new0 (MXFLocalTag);
 
5187
    memcpy (&t->ul, MXF_UL (AUDIO_REF_LEVEL), 16);
 
5188
    t->size = 1;
 
5189
    t->data = g_slice_alloc (t->size);
 
5190
    t->g_slice = TRUE;
 
5191
    GST_WRITE_UINT8 (t->data, self->audio_ref_level);
 
5192
    mxf_primer_pack_add_mapping (primer, 0x3d04, &t->ul);
 
5193
    ret = g_list_prepend (ret, t);
 
5194
  }
 
5195
 
 
5196
  if (self->electro_spatial_formulation != 255) {
 
5197
    t = g_slice_new0 (MXFLocalTag);
 
5198
    memcpy (&t->ul, MXF_UL (ELECTRO_SPATIAL_FORMULATION), 16);
 
5199
    t->size = 1;
 
5200
    t->data = g_slice_alloc (t->size);
 
5201
    t->g_slice = TRUE;
 
5202
    GST_WRITE_UINT8 (t->data, self->electro_spatial_formulation);
 
5203
    mxf_primer_pack_add_mapping (primer, 0x3d05, &t->ul);
 
5204
    ret = g_list_prepend (ret, t);
 
5205
  }
 
5206
 
 
5207
  if (self->channel_count) {
 
5208
    t = g_slice_new0 (MXFLocalTag);
 
5209
    memcpy (&t->ul, MXF_UL (CHANNEL_COUNT), 16);
 
5210
    t->size = 4;
 
5211
    t->data = g_slice_alloc (t->size);
 
5212
    t->g_slice = TRUE;
 
5213
    GST_WRITE_UINT32_BE (t->data, self->channel_count);
 
5214
    mxf_primer_pack_add_mapping (primer, 0x3d07, &t->ul);
 
5215
    ret = g_list_prepend (ret, t);
 
5216
  }
 
5217
 
 
5218
  if (self->quantization_bits) {
 
5219
    t = g_slice_new0 (MXFLocalTag);
 
5220
    memcpy (&t->ul, MXF_UL (QUANTIZATION_BITS), 16);
 
5221
    t->size = 4;
 
5222
    t->data = g_slice_alloc (t->size);
 
5223
    t->g_slice = TRUE;
 
5224
    GST_WRITE_UINT32_BE (t->data, self->quantization_bits);
 
5225
    mxf_primer_pack_add_mapping (primer, 0x3d01, &t->ul);
 
5226
    ret = g_list_prepend (ret, t);
 
5227
  }
 
5228
 
 
5229
  if (self->dial_norm != 0) {
 
5230
    t = g_slice_new0 (MXFLocalTag);
 
5231
    memcpy (&t->ul, MXF_UL (DIAL_NORM), 16);
 
5232
    t->size = 1;
 
5233
    t->data = g_slice_alloc (t->size);
 
5234
    t->g_slice = TRUE;
 
5235
    GST_WRITE_UINT8 (t->data, self->dial_norm);
 
5236
    mxf_primer_pack_add_mapping (primer, 0x3d0c, &t->ul);
 
5237
    ret = g_list_prepend (ret, t);
 
5238
  }
 
5239
 
 
5240
  if (!mxf_ul_is_zero (&self->sound_essence_compression)) {
 
5241
    t = g_slice_new0 (MXFLocalTag);
 
5242
    memcpy (&t->ul, MXF_UL (SOUND_ESSENCE_COMPRESSION), 16);
 
5243
    t->size = 16;
 
5244
    t->data = g_slice_alloc (t->size);
 
5245
    t->g_slice = TRUE;
 
5246
    memcpy (t->data, &self->sound_essence_compression, 16);
 
5247
    mxf_primer_pack_add_mapping (primer, 0x3d06, &t->ul);
 
5248
    ret = g_list_prepend (ret, t);
 
5249
  }
 
5250
 
 
5251
  return ret;
 
5252
}
 
5253
 
3773
5254
static void
3774
5255
    mxf_metadata_generic_sound_essence_descriptor_init
3775
5256
    (MXFMetadataGenericSoundEssenceDescriptor * self)
3776
5257
{
3777
5258
  self->audio_sampling_rate.n = 48000;
3778
5259
  self->audio_sampling_rate.d = 1;
 
5260
  self->electro_spatial_formulation = 255;
3779
5261
}
3780
5262
 
3781
5263
static void
3791
5273
      MXF_QUARK (GENERIC_SOUND_ESSENCE_DESCRIPTOR);
3792
5274
  metadata_base_class->to_structure =
3793
5275
      mxf_metadata_generic_sound_essence_descriptor_to_structure;
 
5276
  metadata_base_class->write_tags =
 
5277
      mxf_metadata_generic_sound_essence_descriptor_write_tags;
3794
5278
  metadata_class->type = 0x0142;
3795
5279
}
3796
5280
 
3817
5301
  }
3818
5302
}
3819
5303
 
 
5304
gboolean
 
5305
    mxf_metadata_generic_sound_essence_descriptor_from_caps
 
5306
    (MXFMetadataGenericSoundEssenceDescriptor * self, GstCaps * caps) {
 
5307
  gint rate;
 
5308
  gint channels;
 
5309
  GstStructure *s;
 
5310
 
 
5311
  g_return_val_if_fail (MXF_IS_METADATA_GENERIC_SOUND_ESSENCE_DESCRIPTOR (self),
 
5312
      FALSE);
 
5313
  g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
 
5314
 
 
5315
  s = gst_caps_get_structure (caps, 0);
 
5316
 
 
5317
  if (!gst_structure_get_int (s, "rate", &rate) || rate == 0) {
 
5318
    GST_WARNING ("No samplerate");
 
5319
    return FALSE;
 
5320
  } else {
 
5321
    self->audio_sampling_rate.n = rate;
 
5322
    self->audio_sampling_rate.d = 1;
 
5323
  }
 
5324
 
 
5325
  if (!gst_structure_get_int (s, "channels", &channels) || channels == 0) {
 
5326
    GST_WARNING ("No channels");
 
5327
    return FALSE;
 
5328
  } else {
 
5329
    self->channel_count = channels;
 
5330
  }
 
5331
 
 
5332
  return TRUE;
 
5333
}
 
5334
 
 
5335
 
3820
5336
G_DEFINE_TYPE (MXFMetadataCDCIPictureEssenceDescriptor,
3821
5337
    mxf_metadata_cdci_picture_essence_descriptor,
3822
5338
    MXF_TYPE_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR);
3933
5449
    gst_structure_id_set (ret, MXF_QUARK (VERTICAL_SUBSAMPLING), G_TYPE_UINT,
3934
5450
        self->vertical_subsampling, NULL);
3935
5451
 
3936
 
  if (self->color_siting != 0)
 
5452
  if (self->color_siting != 255)
3937
5453
    gst_structure_id_set (ret, MXF_QUARK (COLOR_SITING), G_TYPE_UCHAR,
3938
5454
        self->color_siting, NULL);
3939
5455
 
3963
5479
  return ret;
3964
5480
}
3965
5481
 
 
5482
static GList *
 
5483
mxf_metadata_cdci_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
 
5484
    MXFPrimerPack * primer)
 
5485
{
 
5486
  MXFMetadataCDCIPictureEssenceDescriptor *self =
 
5487
      MXF_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR (m);
 
5488
  GList *ret =
 
5489
      MXF_METADATA_BASE_CLASS
 
5490
      (mxf_metadata_cdci_picture_essence_descriptor_parent_class)->write_tags
 
5491
      (m, primer);
 
5492
  MXFLocalTag *t;
 
5493
 
 
5494
  if (self->component_depth) {
 
5495
    t = g_slice_new0 (MXFLocalTag);
 
5496
    memcpy (&t->ul, MXF_UL (COMPONENT_DEPTH), 16);
 
5497
    t->size = 4;
 
5498
    t->data = g_slice_alloc (t->size);
 
5499
    t->g_slice = TRUE;
 
5500
    GST_WRITE_UINT32_BE (t->data, self->component_depth);
 
5501
    mxf_primer_pack_add_mapping (primer, 0x3301, &t->ul);
 
5502
    ret = g_list_prepend (ret, t);
 
5503
  }
 
5504
 
 
5505
  if (self->horizontal_subsampling) {
 
5506
    t = g_slice_new0 (MXFLocalTag);
 
5507
    memcpy (&t->ul, MXF_UL (HORIZONTAL_SUBSAMPLING), 16);
 
5508
    t->size = 4;
 
5509
    t->data = g_slice_alloc (t->size);
 
5510
    t->g_slice = TRUE;
 
5511
    GST_WRITE_UINT32_BE (t->data, self->horizontal_subsampling);
 
5512
    mxf_primer_pack_add_mapping (primer, 0x3302, &t->ul);
 
5513
    ret = g_list_prepend (ret, t);
 
5514
  }
 
5515
 
 
5516
  if (self->vertical_subsampling) {
 
5517
    t = g_slice_new0 (MXFLocalTag);
 
5518
    memcpy (&t->ul, MXF_UL (VERTICAL_SUBSAMPLING), 16);
 
5519
    t->size = 4;
 
5520
    t->data = g_slice_alloc (t->size);
 
5521
    t->g_slice = TRUE;
 
5522
    GST_WRITE_UINT32_BE (t->data, self->vertical_subsampling);
 
5523
    mxf_primer_pack_add_mapping (primer, 0x3308, &t->ul);
 
5524
    ret = g_list_prepend (ret, t);
 
5525
  }
 
5526
 
 
5527
  if (self->color_siting != 0xff) {
 
5528
    t = g_slice_new0 (MXFLocalTag);
 
5529
    memcpy (&t->ul, MXF_UL (COLOR_SITING), 16);
 
5530
    t->size = 1;
 
5531
    t->data = g_slice_alloc (t->size);
 
5532
    t->g_slice = TRUE;
 
5533
    GST_WRITE_UINT8 (t->data, self->color_siting);
 
5534
    mxf_primer_pack_add_mapping (primer, 0x3303, &t->ul);
 
5535
    ret = g_list_prepend (ret, t);
 
5536
  }
 
5537
 
 
5538
  if (self->reversed_byte_order) {
 
5539
    t = g_slice_new0 (MXFLocalTag);
 
5540
    memcpy (&t->ul, MXF_UL (REVERSED_BYTE_ORDER), 16);
 
5541
    t->size = 1;
 
5542
    t->data = g_slice_alloc (t->size);
 
5543
    t->g_slice = TRUE;
 
5544
    GST_WRITE_UINT8 (t->data, (self->reversed_byte_order) ? 1 : 0);
 
5545
    mxf_primer_pack_add_mapping (primer, 0x330b, &t->ul);
 
5546
    ret = g_list_prepend (ret, t);
 
5547
  }
 
5548
 
 
5549
  if (self->padding_bits) {
 
5550
    t = g_slice_new0 (MXFLocalTag);
 
5551
    memcpy (&t->ul, MXF_UL (PADDING_BITS), 16);
 
5552
    t->size = 2;
 
5553
    t->data = g_slice_alloc (t->size);
 
5554
    t->g_slice = TRUE;
 
5555
    GST_WRITE_UINT16_BE (t->data, self->padding_bits);
 
5556
    mxf_primer_pack_add_mapping (primer, 0x3307, &t->ul);
 
5557
    ret = g_list_prepend (ret, t);
 
5558
  }
 
5559
 
 
5560
  if (self->alpha_sample_depth) {
 
5561
    t = g_slice_new0 (MXFLocalTag);
 
5562
    memcpy (&t->ul, MXF_UL (ALPHA_SAMPLE_DEPTH), 16);
 
5563
    t->size = 4;
 
5564
    t->data = g_slice_alloc (t->size);
 
5565
    t->g_slice = TRUE;
 
5566
    GST_WRITE_UINT32_BE (t->data, self->alpha_sample_depth);
 
5567
    mxf_primer_pack_add_mapping (primer, 0x3309, &t->ul);
 
5568
    ret = g_list_prepend (ret, t);
 
5569
  }
 
5570
 
 
5571
  if (self->black_ref_level) {
 
5572
    t = g_slice_new0 (MXFLocalTag);
 
5573
    memcpy (&t->ul, MXF_UL (BLACK_REF_LEVEL), 16);
 
5574
    t->size = 4;
 
5575
    t->data = g_slice_alloc (t->size);
 
5576
    t->g_slice = TRUE;
 
5577
    GST_WRITE_UINT32_BE (t->data, self->black_ref_level);
 
5578
    mxf_primer_pack_add_mapping (primer, 0x3304, &t->ul);
 
5579
    ret = g_list_prepend (ret, t);
 
5580
  }
 
5581
 
 
5582
  if (self->white_ref_level) {
 
5583
    t = g_slice_new0 (MXFLocalTag);
 
5584
    memcpy (&t->ul, MXF_UL (WHITE_REF_LEVEL), 16);
 
5585
    t->size = 4;
 
5586
    t->data = g_slice_alloc (t->size);
 
5587
    t->g_slice = TRUE;
 
5588
    GST_WRITE_UINT32_BE (t->data, self->white_ref_level);
 
5589
    mxf_primer_pack_add_mapping (primer, 0x3305, &t->ul);
 
5590
    ret = g_list_prepend (ret, t);
 
5591
  }
 
5592
 
 
5593
  if (self->color_range) {
 
5594
    t = g_slice_new0 (MXFLocalTag);
 
5595
    memcpy (&t->ul, MXF_UL (COLOR_RANGE), 16);
 
5596
    t->size = 4;
 
5597
    t->data = g_slice_alloc (t->size);
 
5598
    t->g_slice = TRUE;
 
5599
    GST_WRITE_UINT32_BE (t->data, self->color_range);
 
5600
    mxf_primer_pack_add_mapping (primer, 0x3306, &t->ul);
 
5601
    ret = g_list_prepend (ret, t);
 
5602
  }
 
5603
 
 
5604
  return ret;
 
5605
}
 
5606
 
3966
5607
static void
3967
5608
    mxf_metadata_cdci_picture_essence_descriptor_init
3968
5609
    (MXFMetadataCDCIPictureEssenceDescriptor * self)
3969
5610
{
3970
 
 
 
5611
  self->color_siting = 0xff;
3971
5612
}
3972
5613
 
3973
5614
static void
3982
5623
  metadata_base_class->name_quark = MXF_QUARK (CDCI_PICTURE_ESSENCE_DESCRIPTOR);
3983
5624
  metadata_base_class->to_structure =
3984
5625
      mxf_metadata_cdci_picture_essence_descriptor_to_structure;
 
5626
  metadata_base_class->write_tags =
 
5627
      mxf_metadata_cdci_picture_essence_descriptor_write_tags;
3985
5628
  metadata_class->type = 0x0128;
3986
5629
}
3987
5630
 
4138
5781
  return ret;
4139
5782
}
4140
5783
 
 
5784
static GList *
 
5785
mxf_metadata_rgba_picture_essence_descriptor_write_tags (MXFMetadataBase * m,
 
5786
    MXFPrimerPack * primer)
 
5787
{
 
5788
  MXFMetadataRGBAPictureEssenceDescriptor *self =
 
5789
      MXF_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR (m);
 
5790
  GList *ret =
 
5791
      MXF_METADATA_BASE_CLASS
 
5792
      (mxf_metadata_rgba_picture_essence_descriptor_parent_class)->write_tags
 
5793
      (m, primer);
 
5794
  MXFLocalTag *t;
 
5795
 
 
5796
  if (self->component_max_ref != 255) {
 
5797
    t = g_slice_new0 (MXFLocalTag);
 
5798
    memcpy (&t->ul, MXF_UL (COMPONENT_MAX_REF), 16);
 
5799
    t->size = 4;
 
5800
    t->data = g_slice_alloc (t->size);
 
5801
    t->g_slice = TRUE;
 
5802
    GST_WRITE_UINT32_BE (t->data, self->component_max_ref);
 
5803
    mxf_primer_pack_add_mapping (primer, 0x3406, &t->ul);
 
5804
    ret = g_list_prepend (ret, t);
 
5805
  }
 
5806
 
 
5807
  if (self->component_min_ref) {
 
5808
    t = g_slice_new0 (MXFLocalTag);
 
5809
    memcpy (&t->ul, MXF_UL (COMPONENT_MIN_REF), 16);
 
5810
    t->size = 4;
 
5811
    t->data = g_slice_alloc (t->size);
 
5812
    t->g_slice = TRUE;
 
5813
    GST_WRITE_UINT32_BE (t->data, self->component_min_ref);
 
5814
    mxf_primer_pack_add_mapping (primer, 0x3407, &t->ul);
 
5815
    ret = g_list_prepend (ret, t);
 
5816
  }
 
5817
 
 
5818
  if (self->alpha_max_ref != 255) {
 
5819
    t = g_slice_new0 (MXFLocalTag);
 
5820
    memcpy (&t->ul, MXF_UL (ALPHA_MAX_REF), 16);
 
5821
    t->size = 4;
 
5822
    t->data = g_slice_alloc (t->size);
 
5823
    t->g_slice = TRUE;
 
5824
    GST_WRITE_UINT32_BE (t->data, self->alpha_max_ref);
 
5825
    mxf_primer_pack_add_mapping (primer, 0x3408, &t->ul);
 
5826
    ret = g_list_prepend (ret, t);
 
5827
  }
 
5828
 
 
5829
  if (self->alpha_min_ref) {
 
5830
    t = g_slice_new0 (MXFLocalTag);
 
5831
    memcpy (&t->ul, MXF_UL (ALPHA_MIN_REF), 16);
 
5832
    t->size = 4;
 
5833
    t->data = g_slice_alloc (t->size);
 
5834
    t->g_slice = TRUE;
 
5835
    GST_WRITE_UINT32_BE (t->data, self->alpha_min_ref);
 
5836
    mxf_primer_pack_add_mapping (primer, 0x3409, &t->ul);
 
5837
    ret = g_list_prepend (ret, t);
 
5838
  }
 
5839
 
 
5840
  if (self->scanning_direction) {
 
5841
    t = g_slice_new0 (MXFLocalTag);
 
5842
    memcpy (&t->ul, MXF_UL (SCANNING_DIRECTION), 16);
 
5843
    t->size = 1;
 
5844
    t->data = g_slice_alloc (t->size);
 
5845
    t->g_slice = TRUE;
 
5846
    GST_WRITE_UINT8 (t->data, self->scanning_direction);
 
5847
    mxf_primer_pack_add_mapping (primer, 0x3405, &t->ul);
 
5848
    ret = g_list_prepend (ret, t);
 
5849
  }
 
5850
 
 
5851
  if (self->pixel_layout) {
 
5852
    t = g_slice_new0 (MXFLocalTag);
 
5853
    memcpy (&t->ul, MXF_UL (PIXEL_LAYOUT), 16);
 
5854
    t->size = 2 * self->n_pixel_layout + 2;
 
5855
    t->data = g_slice_alloc0 (t->size);
 
5856
    t->g_slice = TRUE;
 
5857
    memcpy (t->data, self->pixel_layout, self->n_pixel_layout * 2);
 
5858
    mxf_primer_pack_add_mapping (primer, 0x3401, &t->ul);
 
5859
    ret = g_list_prepend (ret, t);
 
5860
 
 
5861
  }
 
5862
 
 
5863
  return ret;
 
5864
}
 
5865
 
4141
5866
static void
4142
5867
    mxf_metadata_rgba_picture_essence_descriptor_init
4143
5868
    (MXFMetadataRGBAPictureEssenceDescriptor * self)
4161
5886
  metadata_base_class->name_quark = MXF_QUARK (RGBA_PICTURE_ESSENCE_DESCRIPTOR);
4162
5887
  metadata_base_class->to_structure =
4163
5888
      mxf_metadata_rgba_picture_essence_descriptor_to_structure;
 
5889
  metadata_base_class->write_tags =
 
5890
      mxf_metadata_rgba_picture_essence_descriptor_write_tags;
4164
5891
  metadata_class->type = 0x0129;
4165
5892
}
4166
5893
 
4227
5954
  return ret;
4228
5955
}
4229
5956
 
 
5957
static GList *
 
5958
mxf_metadata_generic_data_essence_descriptor_write_tags (MXFMetadataBase * m,
 
5959
    MXFPrimerPack * primer)
 
5960
{
 
5961
  MXFMetadataGenericDataEssenceDescriptor *self =
 
5962
      MXF_METADATA_GENERIC_DATA_ESSENCE_DESCRIPTOR (m);
 
5963
  GList *ret =
 
5964
      MXF_METADATA_BASE_CLASS
 
5965
      (mxf_metadata_generic_data_essence_descriptor_parent_class)->write_tags
 
5966
      (m, primer);
 
5967
  MXFLocalTag *t;
 
5968
 
 
5969
  if (!mxf_ul_is_zero (&self->data_essence_coding)) {
 
5970
    t = g_slice_new0 (MXFLocalTag);
 
5971
    memcpy (&t->ul, MXF_UL (DATA_ESSENCE_CODING), 16);
 
5972
    t->size = 16;
 
5973
    t->data = g_slice_alloc (t->size);
 
5974
    t->g_slice = TRUE;
 
5975
    memcpy (t->data, &self->data_essence_coding, 16);
 
5976
    mxf_primer_pack_add_mapping (primer, 0x3e01, &t->ul);
 
5977
    ret = g_list_prepend (ret, t);
 
5978
  }
 
5979
 
 
5980
  return ret;
 
5981
}
 
5982
 
4230
5983
static void
4231
5984
    mxf_metadata_generic_data_essence_descriptor_init
4232
5985
    (MXFMetadataGenericDataEssenceDescriptor * self)
4246
5999
  metadata_base_class->name_quark = MXF_QUARK (GENERIC_DATA_ESSENCE_DESCRIPTOR);
4247
6000
  metadata_base_class->to_structure =
4248
6001
      mxf_metadata_generic_data_essence_descriptor_to_structure;
 
6002
  metadata_base_class->write_tags =
 
6003
      mxf_metadata_generic_data_essence_descriptor_write_tags;
4249
6004
  metadata_class->type = 0x0143;
4250
6005
}
4251
6006
 
4281
6036
 
4282
6037
  switch (tag) {
4283
6038
    case 0x3f01:
4284
 
      if (!mxf_ul_array_parse (&self->sub_descriptors_uids,
 
6039
      if (!mxf_uuid_array_parse (&self->sub_descriptors_uids,
4285
6040
              &self->n_sub_descriptors, tag_data, tag_size))
4286
6041
        goto error;
4287
6042
 
4291
6046
        guint i;
4292
6047
        for (i = 0; i < self->n_sub_descriptors; i++) {
4293
6048
          GST_DEBUG ("    sub descriptor %u = %s", i,
4294
 
              mxf_ul_to_string (&self->sub_descriptors_uids[i], str));
 
6049
              mxf_uuid_to_string (&self->sub_descriptors_uids[i], str));
4295
6050
        }
4296
6051
      }
4297
6052
#endif
4391
6146
  return ret;
4392
6147
}
4393
6148
 
 
6149
static GList *
 
6150
mxf_metadata_multiple_descriptor_write_tags (MXFMetadataBase * m,
 
6151
    MXFPrimerPack * primer)
 
6152
{
 
6153
  MXFMetadataMultipleDescriptor *self = MXF_METADATA_MULTIPLE_DESCRIPTOR (m);
 
6154
  GList *ret =
 
6155
      MXF_METADATA_BASE_CLASS
 
6156
      (mxf_metadata_multiple_descriptor_parent_class)->write_tags (m, primer);
 
6157
  MXFLocalTag *t;
 
6158
 
 
6159
  if (self->sub_descriptors) {
 
6160
    guint i;
 
6161
 
 
6162
    t = g_slice_new0 (MXFLocalTag);
 
6163
    memcpy (&t->ul, MXF_UL (SUB_DESCRIPTORS), 16);
 
6164
    t->size = 8 + 16 * self->n_sub_descriptors;
 
6165
    t->data = g_slice_alloc0 (t->size);
 
6166
    t->g_slice = TRUE;
 
6167
    GST_WRITE_UINT32_BE (t->data, self->n_sub_descriptors);
 
6168
    GST_WRITE_UINT32_BE (t->data + 4, 16);
 
6169
    for (i = 0; i < self->n_sub_descriptors; i++) {
 
6170
      if (!self->sub_descriptors[i])
 
6171
        continue;
 
6172
 
 
6173
      memcpy (t->data + 8 + 16 * i,
 
6174
          &MXF_METADATA_BASE (self->sub_descriptors[i])->instance_uid, 16);
 
6175
    }
 
6176
    mxf_primer_pack_add_mapping (primer, 0x3f01, &t->ul);
 
6177
    ret = g_list_prepend (ret, t);
 
6178
  }
 
6179
 
 
6180
  return ret;
 
6181
}
 
6182
 
4394
6183
static void
4395
6184
mxf_metadata_multiple_descriptor_init (MXFMetadataMultipleDescriptor * self)
4396
6185
{
4411
6200
  metadata_base_class->name_quark = MXF_QUARK (MULTIPLE_DESCRIPTOR);
4412
6201
  metadata_base_class->to_structure =
4413
6202
      mxf_metadata_multiple_descriptor_to_structure;
 
6203
  metadata_base_class->write_tags = mxf_metadata_multiple_descriptor_write_tags;
4414
6204
  metadata_class->type = 0x0144;
4415
6205
}
4416
6206
 
4480
6270
  return ret;
4481
6271
}
4482
6272
 
 
6273
static GList *
 
6274
mxf_metadata_text_locator_write_tags (MXFMetadataBase * m,
 
6275
    MXFPrimerPack * primer)
 
6276
{
 
6277
  MXFMetadataTextLocator *self = MXF_METADATA_TEXT_LOCATOR (m);
 
6278
  GList *ret =
 
6279
      MXF_METADATA_BASE_CLASS
 
6280
      (mxf_metadata_text_locator_parent_class)->write_tags (m, primer);
 
6281
  MXFLocalTag *t;
 
6282
 
 
6283
  if (self->locator_name) {
 
6284
    t = g_slice_new0 (MXFLocalTag);
 
6285
    memcpy (&t->ul, MXF_UL (LOCATOR_NAME), 16);
 
6286
    t->data = mxf_utf8_to_utf16 (self->locator_name, &t->size);
 
6287
    mxf_primer_pack_add_mapping (primer, 0x4101, &t->ul);
 
6288
    ret = g_list_prepend (ret, t);
 
6289
  }
 
6290
 
 
6291
  return ret;
 
6292
}
 
6293
 
4483
6294
static void
4484
6295
mxf_metadata_text_locator_init (MXFMetadataTextLocator * self)
4485
6296
{
4497
6308
  metadata_base_class->handle_tag = mxf_metadata_text_locator_handle_tag;
4498
6309
  metadata_base_class->name_quark = MXF_QUARK (TEXT_LOCATOR);
4499
6310
  metadata_base_class->to_structure = mxf_metadata_text_locator_to_structure;
 
6311
  metadata_base_class->write_tags = mxf_metadata_text_locator_write_tags;
4500
6312
  metadata_class->type = 0x0133;
4501
6313
}
4502
6314
 
4553
6365
  return ret;
4554
6366
}
4555
6367
 
 
6368
static GList *
 
6369
mxf_metadata_network_locator_write_tags (MXFMetadataBase * m,
 
6370
    MXFPrimerPack * primer)
 
6371
{
 
6372
  MXFMetadataNetworkLocator *self = MXF_METADATA_NETWORK_LOCATOR (m);
 
6373
  GList *ret =
 
6374
      MXF_METADATA_BASE_CLASS
 
6375
      (mxf_metadata_network_locator_parent_class)->write_tags (m, primer);
 
6376
  MXFLocalTag *t;
 
6377
 
 
6378
  if (self->url_string) {
 
6379
    t = g_slice_new0 (MXFLocalTag);
 
6380
    memcpy (&t->ul, MXF_UL (URL_STRING), 16);
 
6381
    t->data = mxf_utf8_to_utf16 (self->url_string, &t->size);
 
6382
    mxf_primer_pack_add_mapping (primer, 0x4001, &t->ul);
 
6383
    ret = g_list_prepend (ret, t);
 
6384
  }
 
6385
 
 
6386
  return ret;
 
6387
}
 
6388
 
4556
6389
static void
4557
6390
mxf_metadata_network_locator_init (MXFMetadataNetworkLocator * self)
4558
6391
{
4569
6402
  metadata_base_class->handle_tag = mxf_metadata_network_locator_handle_tag;
4570
6403
  metadata_base_class->name_quark = MXF_QUARK (NETWORK_LOCATOR);
4571
6404
  metadata_base_class->to_structure = mxf_metadata_network_locator_to_structure;
 
6405
  metadata_base_class->write_tags = mxf_metadata_network_locator_write_tags;
4572
6406
  metadata_class->type = 0x0133;
4573
6407
}
4574
6408
 
4672
6506
  return ret;
4673
6507
}
4674
6508
 
4675
 
/* TODO: Remove this once we depend on GLib 2.14 */
4676
 
#if GLIB_CHECK_VERSION (2, 14, 0)
4677
 
#define __gst_once_init_enter(val) (g_once_init_enter (val))
4678
 
#define __gst_once_init_leave(val,newval) (g_once_init_leave (val, newval))
4679
 
#endif
4680
 
 
4681
6509
GType
4682
6510
mxf_descriptive_metadata_framework_get_type (void)
4683
6511
{
4684
6512
  static volatile gsize type = 0;
4685
 
  if (__gst_once_init_enter (&type)) {
 
6513
  if (g_once_init_enter (&type)) {
4686
6514
    GType _type = 0;
4687
6515
    static const GTypeInfo info = {
4688
6516
      sizeof (MXFDescriptiveMetadataFrameworkInterface),
4700
6528
 
4701
6529
    g_type_interface_add_prerequisite (_type, MXF_TYPE_DESCRIPTIVE_METADATA);
4702
6530
 
4703
 
    __gst_once_init_leave (&type, (gsize) _type);
 
6531
    g_once_init_leave (&type, (gsize) _type);
4704
6532
  }
4705
6533
 
4706
6534
  return (GType) type;
4709
6537
GHashTable *
4710
6538
mxf_metadata_hash_table_new (void)
4711
6539
{
4712
 
  return g_hash_table_new_full ((GHashFunc) mxf_ul_hash,
4713
 
      (GEqualFunc) mxf_ul_is_equal, (GDestroyNotify) NULL,
 
6540
  return g_hash_table_new_full ((GHashFunc) mxf_uuid_hash,
 
6541
      (GEqualFunc) mxf_uuid_is_equal, (GDestroyNotify) NULL,
4714
6542
      (GDestroyNotify) gst_mini_object_unref);
4715
6543
}