gst/mxf/mxfup.c

   1 /* GStreamer
   2  * Copyright (C) 2008-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 /* Implementation of SMPTE 384M - Mapping of Uncompressed Pictures into the MXF
  21  * Generic Container
  22  */
  23
  24 /* TODO:
  25  *   - Handle CDCI essence
  26  *   - Handle more formats with RGBA descriptor (4:4:4 / 4:4:4:4 YUV, RGB656, ...)
  27  *   - Handle all the dimensions and other properties in the picture
  28  *     essence descriptors correctly according to S377M Annex E
  29  *   - Handle interlaced correctly, i.e. weave until we support one-field-per-buffer
  30  */
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"
  34 #endif
  35
  36 #include <gst/gst.h>
  37 #include <string.h>
  38
  39 #include <gst/video/video.h>
  40
  41 #include "mxfup.h"
  42 #include "mxfessence.h"
  43
  44 GST_DEBUG_CATEGORY_EXTERN (mxf_debug);
  45 #define GST_CAT_DEFAULT mxf_debug
  46
  47 static const struct
  48 {
  49   const gchar *format;
  50   guint32 n_pixel_layout;
  51   guint8 pixel_layout[10];
  52   const gchar *caps_string;
  53 } _rgba_mapping_table[] = {
  54   {
  55     "RGB", 3, {
  56   'R', 8, 'G', 8, 'B', 8}, GST_VIDEO_CAPS_MAKE ("RGB")}, {
  57     "BGR", 3, {
  58   'B', 8, 'G', 8, 'R', 8}, GST_VIDEO_CAPS_MAKE ("BGR")}, {
  59     "v308", 3, {
  60   'Y', 8, 'U', 8, 'V', 8}, GST_VIDEO_CAPS_MAKE ("v308")}, {
  61     "xRGB", 4, {
  62   'F', 8, 'R', 8, 'G', 8, 'B', 8}, GST_VIDEO_CAPS_MAKE ("xRGB")}, {
  63     "RGBx", 4, {
  64   'R', 8, 'G', 8, 'B', 8, 'F', 8}, GST_VIDEO_CAPS_MAKE ("RGBx")}, {
  65     "xBGR", 4, {
  66   'F', 8, 'B', 8, 'G', 8, 'R', 8}, GST_VIDEO_CAPS_MAKE ("xBGR")}, {
  67     "BGRx", 4, {
  68   'B', 8, 'G', 8, 'R', 8, 'F', 8}, GST_VIDEO_CAPS_MAKE ("BGRx")}, {
  69     "RGBA", 4, {
  70   'R', 8, 'G', 8, 'B', 8, 'A', 8}, GST_VIDEO_CAPS_MAKE ("RGBA")}, {
  71     "ARGB", 4, {
  72   'A', 8, 'R', 8, 'G', 8, 'B', 8}, GST_VIDEO_CAPS_MAKE ("RGBA")}, {
  73     "BGRA", 4, {
  74   'B', 8, 'G', 8, 'R', 8, 'A', 8}, GST_VIDEO_CAPS_MAKE ("BGRA")}, {
  75     "ABGR", 4, {
  76   'A', 8, 'B', 8, 'G', 8, 'R', 8}, GST_VIDEO_CAPS_MAKE ("ABGR")}, {
  77     "AYUV", 4, {
  78   'A', 8, 'Y', 8, 'U', 8, 'V', 8}, GST_VIDEO_CAPS_MAKE ("AYUV")}
  79 };
  80
  81 static const struct
  82 {
  83   const gchar *format;
  84   guint bpp;
  85   guint horizontal_subsampling;
  86   guint vertical_subsampling;
  87   gboolean reversed_byte_order;
  88   const gchar *caps_string;
  89 } _cdci_mapping_table[] = {
  90   {
  91   "YUY2", 2, 1, 0, TRUE, GST_VIDEO_CAPS_MAKE ("YUY2")}, {
  92 "UYVY", 2, 1, 0, FALSE, GST_VIDEO_CAPS_MAKE ("UYVY")},};
  93
  94 typedef struct
  95 {
  96   const gchar *format;          /* video format string */
  97   gint width, height;
  98   guint bpp;
  99   guint32 image_start_offset;
 100   guint32 image_end_offset;
 101 } MXFUPMappingData;
 102
 103 static gboolean
 104 mxf_is_up_essence_track (const MXFMetadataTimelineTrack * track)
 105 {
 106   guint i;
 107
 108   g_return_val_if_fail (track != NULL, FALSE);
 109
 110   if (track->parent.descriptor == NULL)
 111     return FALSE;
 112
 113   for (i = 0; i < track->parent.n_descriptor; i++) {
 114     MXFMetadataFileDescriptor *d = track->parent.descriptor[i];
 115     MXFUL *key;
 116
 117     if (!d)
 118       continue;
 119
 120     key = &d->essence_container;
 121     /* SMPTE 384M 8 */
 122     if (mxf_is_generic_container_essence_container_label (key) &&
 123         key->u[12] == 0x02 && key->u[13] == 0x05 && key->u[15] <= 0x03)
 124       return TRUE;
 125   }
 126
 127   return FALSE;
 128 }
 129
 130 static GstFlowReturn
 131 mxf_up_handle_essence_element (const MXFUL * key, GstBuffer * buffer,
 132     GstCaps * caps,
 133     MXFMetadataTimelineTrack * track,
 134     gpointer mapping_data, GstBuffer ** outbuf)
 135 {
 136   MXFUPMappingData *data = mapping_data;
 137
 138   /* SMPTE 384M 7.1 */
 139   if (key->u[12] != 0x15 || (key->u[14] != 0x01 && key->u[14] != 0x02
 140           && key->u[14] != 0x03 && key->u[14] != 0x04)) {
 141     GST_ERROR ("Invalid uncompressed picture essence element");
 142     gst_buffer_unref (buffer);
 143     return GST_FLOW_ERROR;
 144   }
 145
 146   if (!data) {
 147     GST_ERROR ("Invalid mapping data");
 148     gst_buffer_unref (buffer);
 149     return GST_FLOW_ERROR;
 150   }
 151
 152   if (data->image_start_offset == 0 && data->image_end_offset == 0) {
 153   } else {
 154     if (data->image_start_offset + data->image_end_offset
 155         > gst_buffer_get_size (buffer)) {
 156       gst_buffer_unref (buffer);
 157       GST_ERROR ("Invalid buffer size");
 158       return GST_FLOW_ERROR;
 159     } else {
 160       gst_buffer_resize (buffer, data->image_start_offset,
 161           data->image_end_offset - data->image_start_offset);
 162     }
 163   }
 164
 165   if (gst_buffer_get_size (buffer) != data->bpp * data->width * data->height) {
 166     GST_ERROR ("Invalid buffer size");
 167     gst_buffer_unref (buffer);
 168     return GST_FLOW_ERROR;
 169   }
 170
 171   if (data->bpp != 4
 172       || GST_ROUND_UP_4 (data->width * data->bpp) != data->width * data->bpp) {
 173     guint y;
 174     GstBuffer *ret;
 175     GstMapInfo inmap, outmap;
 176     guint8 *indata, *outdata;
 177
 178     ret =
 179         gst_buffer_new_and_alloc (GST_ROUND_UP_4 (data->width * data->bpp) *
 180         data->height);
 181     gst_buffer_map (buffer, &inmap, GST_MAP_READ);
 182     gst_buffer_map (ret, &outmap, GST_MAP_WRITE);
 183     indata = inmap.data;
 184     outdata = outmap.data;
 185
 186     for (y = 0; y < data->height; y++) {
 187       memcpy (outdata, indata, data->width * data->bpp);
 188       outdata += GST_ROUND_UP_4 (data->width * data->bpp);
 189       indata += data->width * data->bpp;
 190     }
 191
 192     gst_buffer_unmap (buffer, &inmap);
 193     gst_buffer_unmap (ret, &outmap);
 194
 195     gst_buffer_unref (buffer);
 196     *outbuf = ret;
 197   } else {
 198     *outbuf = buffer;
 199   }
 200
 201   return GST_FLOW_OK;
 202 }
 203
 204 static MXFEssenceWrapping
 205 mxf_up_get_track_wrapping (const MXFMetadataTimelineTrack * track)
 206 {
 207   guint i;
 208
 209   g_return_val_if_fail (track != NULL, MXF_ESSENCE_WRAPPING_CUSTOM_WRAPPING);
 210
 211   if (track->parent.descriptor == NULL) {
 212     GST_ERROR ("No descriptor found for this track");
 213     return MXF_ESSENCE_WRAPPING_CUSTOM_WRAPPING;
 214   }
 215
 216   for (i = 0; i < track->parent.n_descriptor; i++) {
 217     if (!track->parent.descriptor[i])
 218       continue;
 219
 220     if (!MXF_IS_METADATA_GENERIC_PICTURE_ESSENCE_DESCRIPTOR (track->
 221             parent.descriptor[i]))
 222       continue;
 223
 224     switch (track->parent.descriptor[i]->essence_container.u[15]) {
 225       case 0x01:
 226         return MXF_ESSENCE_WRAPPING_FRAME_WRAPPING;
 227         break;
 228       case 0x02:
 229         return MXF_ESSENCE_WRAPPING_CLIP_WRAPPING;
 230         break;
 231       default:
 232         return MXF_ESSENCE_WRAPPING_CUSTOM_WRAPPING;
 233         break;
 234     }
 235   }
 236
 237   return MXF_ESSENCE_WRAPPING_CUSTOM_WRAPPING;
 238 }
 239
 240 static GstCaps *
 241 mxf_up_rgba_create_caps (MXFMetadataTimelineTrack * track,
 242     MXFMetadataRGBAPictureEssenceDescriptor * d, GstTagList ** tags,
 243     MXFEssenceElementHandleFunc * handler, gpointer * mapping_data)
 244 {
 245   GstCaps *caps = NULL;
 246   guint i;
 247   const gchar *format = NULL;
 248   guint bpp;
 249
 250   if (!d->pixel_layout) {
 251     GST_ERROR ("No pixel layout");
 252     return NULL;
 253   }
 254
 255   for (i = 0; i < G_N_ELEMENTS (_rgba_mapping_table); i++) {
 256     if (d->n_pixel_layout != _rgba_mapping_table[i].n_pixel_layout)
 257       continue;
 258
 259     if (memcmp (d->pixel_layout, &_rgba_mapping_table[i].pixel_layout,
 260             _rgba_mapping_table[i].n_pixel_layout * 2) == 0) {
 261       caps = gst_caps_from_string (_rgba_mapping_table[i].caps_string);
 262       format = _rgba_mapping_table[i].format;
 263       bpp = _rgba_mapping_table[i].n_pixel_layout;
 264       break;
 265     }
 266   }
 267
 268   if (caps) {
 269     MXFUPMappingData *data = g_new0 (MXFUPMappingData, 1);
 270
 271     mxf_metadata_generic_picture_essence_descriptor_set_caps (&d->parent, caps);
 272
 273     data->width = d->parent.stored_width;
 274     data->height = d->parent.stored_height;
 275     data->format = format;
 276     data->bpp = bpp;
 277     data->image_start_offset =
 278         ((MXFMetadataGenericPictureEssenceDescriptor *) d)->image_start_offset;
 279     data->image_end_offset =
 280         ((MXFMetadataGenericPictureEssenceDescriptor *) d)->image_end_offset;
 281
 282     *mapping_data = data;
 283   } else {
 284     GST_WARNING ("Unsupported pixel layout");
 285   }
 286
 287   return caps;
 288 }
 289
 290 static GstCaps *
 291 mxf_up_cdci_create_caps (MXFMetadataTimelineTrack * track,
 292     MXFMetadataCDCIPictureEssenceDescriptor * d, GstTagList ** tags,
 293     MXFEssenceElementHandleFunc * handler, gpointer * mapping_data)
 294 {
 295   GstCaps *caps = NULL;
 296   guint i;
 297   const gchar *format;
 298   guint bpp;
 299
 300   for (i = 0; i < G_N_ELEMENTS (_cdci_mapping_table); i++) {
 301     if (_cdci_mapping_table[i].horizontal_subsampling ==
 302         d->horizontal_subsampling
 303         && _cdci_mapping_table[i].vertical_subsampling ==
 304         d->vertical_subsampling
 305         && _cdci_mapping_table[i].reversed_byte_order ==
 306         d->reversed_byte_order) {
 307       caps = gst_caps_from_string (_cdci_mapping_table[i].caps_string);
 308       format = _cdci_mapping_table[i].format;
 309       bpp = _cdci_mapping_table[i].bpp;
 310       break;
 311     }
 312   }
 313
 314   if (caps) {
 315     MXFUPMappingData *data = g_new0 (MXFUPMappingData, 1);
 316
 317     mxf_metadata_generic_picture_essence_descriptor_set_caps (&d->parent, caps);
 318
 319     data->width = d->parent.stored_width;
 320     data->height = d->parent.stored_height;
 321     data->format = format;
 322     data->bpp = bpp;
 323     data->image_start_offset =
 324         ((MXFMetadataGenericPictureEssenceDescriptor *) d)->image_start_offset;
 325     data->image_end_offset =
 326         ((MXFMetadataGenericPictureEssenceDescriptor *) d)->image_end_offset;
 327
 328     *mapping_data = data;
 329   } else {
 330     GST_WARNING ("Unsupported CDCI format");
 331   }
 332
 333   return caps;
 334 }
 335
 336 static GstCaps *
 337 mxf_up_create_caps (MXFMetadataTimelineTrack * track, GstTagList ** tags,
 338     MXFEssenceElementHandleFunc * handler, gpointer * mapping_data)
 339 {
 340   MXFMetadataGenericPictureEssenceDescriptor *p = NULL;
 341   MXFMetadataCDCIPictureEssenceDescriptor *c = NULL;
 342   MXFMetadataRGBAPictureEssenceDescriptor *r = NULL;
 343   guint i;
 344   GstCaps *caps = NULL;
 345
 346   g_return_val_if_fail (track != NULL, NULL);
 347
 348   if (track->parent.descriptor == NULL) {
 349     GST_ERROR ("No descriptor found for this track");
 350     return NULL;
 351   }
 352
 353   for (i = 0; i < track->parent.n_descriptor; i++) {
 354     if (!track->parent.descriptor[i])
 355       continue;
 356
 357     if (MXF_IS_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR (track->parent.
 358             descriptor[i])) {
 359       p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
 360           descriptor[i];
 361       r = (MXFMetadataRGBAPictureEssenceDescriptor *) track->parent.
 362           descriptor[i];
 363       break;
 364     } else if (MXF_IS_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR (track->
 365             parent.descriptor[i])) {
 366       p = (MXFMetadataGenericPictureEssenceDescriptor *) track->parent.
 367           descriptor[i];
 368       c = (MXFMetadataCDCIPictureEssenceDescriptor *) track->parent.
 369           descriptor[i];
 370     }
 371   }
 372
 373   if (!p) {
 374     GST_ERROR ("No picture essence descriptor found for this track");
 375     return NULL;
 376   }
 377
 378   *handler = mxf_up_handle_essence_element;
 379
 380   if (r) {
 381     caps = mxf_up_rgba_create_caps (track, r, tags, handler, mapping_data);
 382   } else if (c) {
 383     caps = mxf_up_cdci_create_caps (track, c, tags, handler, mapping_data);
 384   } else {
 385     return NULL;
 386   }
 387
 388   return caps;
 389 }
 390
 391 static const MXFEssenceElementHandler mxf_up_essence_element_handler = {
 392   mxf_is_up_essence_track,
 393   mxf_up_get_track_wrapping,
 394   mxf_up_create_caps
 395 };
 396
 397 static GstFlowReturn
 398 mxf_up_write_func (GstBuffer * buffer, gpointer mapping_data,
 399     GstAdapter * adapter, GstBuffer ** outbuf, gboolean flush)
 400 {
 401   MXFUPMappingData *data = mapping_data;
 402
 403   if (!buffer)
 404     return GST_FLOW_OK;
 405
 406   if (gst_buffer_get_size (buffer) !=
 407       GST_ROUND_UP_4 (data->bpp * data->width) * data->height) {
 408     GST_ERROR ("Invalid buffer size");
 409     return GST_FLOW_ERROR;
 410   }
 411
 412   if (data->bpp != 4
 413       || GST_ROUND_UP_4 (data->width * data->bpp) != data->width * data->bpp) {
 414     guint y;
 415     GstBuffer *ret;
 416     GstMapInfo inmap, outmap;
 417     guint8 *indata, *outdata;
 418
 419     ret = gst_buffer_new_and_alloc (data->width * data->bpp * data->height);
 420     gst_buffer_map (buffer, &inmap, GST_MAP_READ);
 421     gst_buffer_map (ret, &outmap, GST_MAP_WRITE);
 422     indata = inmap.data;
 423     outdata = outmap.data;
 424
 425     for (y = 0; y < data->height; y++) {
 426       memcpy (outdata, indata, data->width * data->bpp);
 427       indata += GST_ROUND_UP_4 (data->width * data->bpp);
 428       outdata += data->width * data->bpp;
 429     }
 430
 431     gst_buffer_unmap (buffer, &inmap);
 432     gst_buffer_unmap (ret, &outmap);
 433     gst_buffer_unref (buffer);
 434
 435     *outbuf = ret;
 436   } else {
 437     *outbuf = buffer;
 438   }
 439
 440   return GST_FLOW_OK;
 441 }
 442
 443 static const guint8 up_essence_container_ul[] = {
 444   0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x01,
 445   0x0D, 0x01, 0x03, 0x01, 0x02, 0x05, 0x7F, 0x01
 446 };
 447
 448 static MXFMetadataFileDescriptor *
 449 mxf_up_get_rgba_descriptor (GstPadTemplate * tmpl, GstCaps * caps,
 450     MXFEssenceElementWriteFunc * handler, gpointer * mapping_data)
 451 {
 452   MXFMetadataRGBAPictureEssenceDescriptor *ret;
 453   guint i;
 454   GstCaps *tmp, *intersection;
 455   MXFUPMappingData *md = g_new0 (MXFUPMappingData, 1);
 456
 457   *mapping_data = md;
 458
 459   ret = (MXFMetadataRGBAPictureEssenceDescriptor *)
 460       g_object_new (MXF_TYPE_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR, NULL);
 461
 462   for (i = 0; i < G_N_ELEMENTS (_rgba_mapping_table); i++) {
 463     tmp = gst_caps_from_string (_rgba_mapping_table[i].caps_string);
 464     intersection = gst_caps_intersect (caps, tmp);
 465     gst_caps_unref (tmp);
 466
 467     if (!gst_caps_is_empty (intersection)) {
 468       gst_caps_unref (intersection);
 469       ret->n_pixel_layout = _rgba_mapping_table[i].n_pixel_layout;
 470       ret->pixel_layout = g_new0 (guint8, ret->n_pixel_layout * 2);
 471       md->format = _rgba_mapping_table[i].format;
 472       md->bpp = _rgba_mapping_table[i].n_pixel_layout;
 473       memcpy (ret->pixel_layout, _rgba_mapping_table[i].pixel_layout,
 474           ret->n_pixel_layout * 2);
 475       break;
 476     }
 477     gst_caps_unref (intersection);
 478   }
 479
 480   if (md->format == NULL) {
 481     GST_ERROR ("Invalid caps %" GST_PTR_FORMAT, caps);
 482     g_object_unref (ret);
 483     return NULL;
 484   }
 485
 486
 487   memcpy (&ret->parent.parent.essence_container, &up_essence_container_ul, 16);
 488
 489   if (!mxf_metadata_generic_picture_essence_descriptor_from_caps (&ret->parent,
 490           caps)) {
 491     g_object_unref (ret);
 492     return NULL;
 493   }
 494
 495   md->width = ret->parent.stored_width;
 496   md->height = ret->parent.stored_height;
 497
 498   *handler = mxf_up_write_func;
 499
 500   return (MXFMetadataFileDescriptor *) ret;
 501 }
 502
 503 static MXFMetadataFileDescriptor *
 504 mxf_up_get_cdci_descriptor (GstPadTemplate * tmpl, GstCaps * caps,
 505     MXFEssenceElementWriteFunc * handler, gpointer * mapping_data)
 506 {
 507   MXFMetadataCDCIPictureEssenceDescriptor *ret;
 508   guint i;
 509   GstCaps *tmp, *intersection;
 510   MXFUPMappingData *md = g_new0 (MXFUPMappingData, 1);
 511
 512   *mapping_data = md;
 513
 514   ret = (MXFMetadataCDCIPictureEssenceDescriptor *)
 515       g_object_new (MXF_TYPE_METADATA_CDCI_PICTURE_ESSENCE_DESCRIPTOR, NULL);
 516
 517   for (i = 0; i < G_N_ELEMENTS (_cdci_mapping_table); i++) {
 518     tmp = gst_caps_from_string (_cdci_mapping_table[i].caps_string);
 519     intersection = gst_caps_intersect (caps, tmp);
 520     gst_caps_unref (tmp);
 521
 522     if (!gst_caps_is_empty (intersection)) {
 523       gst_caps_unref (intersection);
 524       ret->horizontal_subsampling =
 525           _cdci_mapping_table[i].horizontal_subsampling;
 526       ret->vertical_subsampling = _cdci_mapping_table[i].vertical_subsampling;
 527       ret->reversed_byte_order = _cdci_mapping_table[i].reversed_byte_order;
 528       md->format = _cdci_mapping_table[i].format;
 529       md->bpp = _cdci_mapping_table[i].bpp;
 530       break;
 531     }
 532     gst_caps_unref (intersection);
 533   }
 534
 535   if (md->format == NULL) {
 536     GST_ERROR ("Invalid caps %" GST_PTR_FORMAT, caps);
 537     g_object_unref (ret);
 538     return NULL;
 539   }
 540
 541   memcpy (&ret->parent.parent.essence_container, &up_essence_container_ul, 16);
 542
 543   if (!mxf_metadata_generic_picture_essence_descriptor_from_caps (&ret->parent,
 544           caps)) {
 545     g_object_unref (ret);
 546     return NULL;
 547   }
 548
 549   md->width = ret->parent.stored_width;
 550   md->height = ret->parent.stored_height;
 551
 552   *handler = mxf_up_write_func;
 553
 554   return (MXFMetadataFileDescriptor *) ret;
 555 }
 556
 557 static MXFMetadataFileDescriptor *
 558 mxf_up_get_descriptor (GstPadTemplate * tmpl, GstCaps * caps,
 559     MXFEssenceElementWriteFunc * handler, gpointer * mapping_data)
 560 {
 561   GstStructure *s;
 562
 563   s = gst_caps_get_structure (caps, 0);
 564   if (strcmp (gst_structure_get_name (s), "video/x-raw") == 0) {
 565     const gchar *format;
 566
 567     format = gst_structure_get_string (s, "format");
 568     if (format == NULL)
 569       return NULL;
 570
 571     if (g_str_equal (format, "YUY2") || g_str_equal (format, "UYVY"))
 572       return mxf_up_get_cdci_descriptor (tmpl, caps, handler, mapping_data);
 573     else
 574       return mxf_up_get_rgba_descriptor (tmpl, caps, handler, mapping_data);
 575   }
 576
 577   g_assert_not_reached ();
 578   return NULL;
 579 }
 580
 581 static void
 582 mxf_up_update_descriptor (MXFMetadataFileDescriptor * d, GstCaps * caps,
 583     gpointer mapping_data, GstBuffer * buf)
 584 {
 585   return;
 586 }
 587
 588 static void
 589 mxf_up_get_edit_rate (MXFMetadataFileDescriptor * a, GstCaps * caps,
 590     gpointer mapping_data, GstBuffer * buf, MXFMetadataSourcePackage * package,
 591     MXFMetadataTimelineTrack * track, MXFFraction * edit_rate)
 592 {
 593   edit_rate->n = a->sample_rate.n;
 594   edit_rate->d = a->sample_rate.d;
 595 }
 596
 597 static guint32
 598 mxf_up_get_track_number_template (MXFMetadataFileDescriptor * a,
 599     GstCaps * caps, gpointer mapping_data)
 600 {
 601   return (0x15 << 24) | (0x02 << 8);
 602 }
 603
 604 static MXFEssenceElementWriter mxf_up_essence_element_writer = {
 605   mxf_up_get_descriptor,
 606   mxf_up_update_descriptor,
 607   mxf_up_get_edit_rate,
 608   mxf_up_get_track_number_template,
 609   NULL,
 610   {{0,}}
 611 };
 612
 613 void
 614 mxf_up_init (void)
 615 {
 616   GstCaps *tmp = NULL;
 617   mxf_essence_element_handler_register (&mxf_up_essence_element_handler);
 618   mxf_up_essence_element_writer.pad_template =
 619       gst_pad_template_new ("up_video_sink_%u", GST_PAD_SINK, GST_PAD_REQUEST,
 620       tmp = gst_caps_from_string (GST_VIDEO_CAPS_MAKE ("RGB") "; "
 621           GST_VIDEO_CAPS_MAKE ("BGR") "; "
 622           GST_VIDEO_CAPS_MAKE ("RGBx") "; "
 623           GST_VIDEO_CAPS_MAKE ("xRGB") "; "
 624           GST_VIDEO_CAPS_MAKE ("BGRx") "; "
 625           GST_VIDEO_CAPS_MAKE ("xBGR") "; "
 626           GST_VIDEO_CAPS_MAKE ("ARGB") "; "
 627           GST_VIDEO_CAPS_MAKE ("RGBA") "; "
 628           GST_VIDEO_CAPS_MAKE ("ABGR") "; "
 629           GST_VIDEO_CAPS_MAKE ("BGRA") "; "
 630           GST_VIDEO_CAPS_MAKE ("AYUV") "; "
 631           GST_VIDEO_CAPS_MAKE ("v308") "; "
 632           GST_VIDEO_CAPS_MAKE ("UYVY") "; " GST_VIDEO_CAPS_MAKE ("YUY2")));
 633   gst_caps_unref (tmp);
 634
 635   memcpy (&mxf_up_essence_element_writer.data_definition,
 636       mxf_metadata_track_identifier_get (MXF_METADATA_TRACK_PICTURE_ESSENCE),
 637       16);
 638   mxf_essence_element_writer_register (&mxf_up_essence_element_writer);
 639 }