FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  *
32  * Principle
33  * Search for Track numbers which will identify essence element KLV packets.
34  * Search for SourcePackage which define tracks which contains Track numbers.
35  * Material Package contains tracks with reference to SourcePackage tracks.
36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37  * Assign Descriptors to correct Tracks.
38  *
39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40  * Metadata parsing resolves Strong References to objects.
41  *
42  * Simple demuxer, only OP1A supported and some files might not work at all.
43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
44  */
45 
46 #include <inttypes.h>
47 
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/timecode.h"
55 #include "avformat.h"
56 #include "internal.h"
57 #include "mxf.h"
58 
59 #define MXF_MAX_CHUNK_SIZE (32 << 20)
60 
61 typedef enum {
66 
67 typedef enum {
68  OP1a = 1,
78  OPSONYOpt, /* FATE sample, violates the spec in places */
79 } MXFOP;
80 
81 typedef enum {
86 
87 typedef struct MXFPartition {
88  int closed;
89  int complete;
92  int index_sid;
93  int body_sid;
94  int64_t this_partition;
95  int64_t essence_offset; ///< absolute offset of essence
96  int64_t essence_length;
101  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
102  int64_t body_offset;
104 } MXFPartition;
105 
106 typedef struct MXFCryptoContext {
111 
112 typedef struct MXFStructuralComponent {
118  int64_t duration;
119  int64_t start_position;
122 
123 typedef struct MXFSequence {
129  int64_t duration;
131 } MXFSequence;
132 
133 typedef struct MXFTrack {
138  struct AVRational rate;
141 
142 typedef struct {
147 
148 typedef struct {
153  int64_t duration;
155 
156 typedef struct {
159  char *name;
160  char *value;
162 
163 typedef struct {
166  MXFSequence *sequence; /* mandatory, and only one */
168  int track_id;
169  char *name;
170  uint8_t track_number[4];
173  uint64_t sample_count;
174  int64_t original_duration; /* st->duration in SampleRate/EditRate units */
176  int body_sid;
178  int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
179 } MXFTrack;
180 
181 typedef struct MXFDescriptor {
189  int width;
190  int height; /* Field height, not frame height */
191  int frame_layout; /* See MXFFrameLayout enum */
193 #define MXF_FIELD_DOMINANCE_DEFAULT 0
194 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
195 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
197  int channels;
199  int64_t duration; /* ContainerDuration optional property */
200  unsigned int component_depth;
201  unsigned int horiz_subsampling;
202  unsigned int vert_subsampling;
209 } MXFDescriptor;
210 
211 typedef struct MXFIndexTableSegment {
216  int body_sid;
219  uint64_t index_duration;
225 
226 typedef struct MXFPackage {
233  MXFDescriptor *descriptor; /* only one */
235  char *name;
238 } MXFPackage;
239 
240 typedef struct MXFEssenceContainerData {
246  int body_sid;
248 
249 typedef struct MXFMetadataSet {
253 
254 /* decoded index table */
255 typedef struct MXFIndexTable {
257  int body_sid;
258  int nb_ptses; /* number of PTSes or total duration of index */
259  int64_t first_dts; /* DTS = EditUnit + first_dts */
260  int64_t *ptses; /* maps EditUnit -> PTS */
262  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
263  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
264  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
265 } MXFIndexTable;
266 
267 typedef struct MXFContext {
278  struct AVAES *aesc;
283  int run_in;
290 } MXFContext;
291 
292 /* NOTE: klv_offset is not set (-1) for local keys */
293 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
294 
296  const UID key;
298  int ctx_size;
301 
302 static int mxf_read_close(AVFormatContext *s);
303 
304 /* partial keys to match */
305 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
306 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
307 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
308 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
309 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
310 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
311 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
312 /* complete keys to match */
313 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
314 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
315 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
316 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
317 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
318 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
319 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
320 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
321 static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
322 
323 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
324 
325 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
326 {
328  switch ((*ctx)->type) {
329  case Descriptor:
330  av_freep(&((MXFDescriptor *)*ctx)->extradata);
331  break;
332  case MultipleDescriptor:
333  av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
334  break;
335  case Sequence:
336  av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
337  break;
338  case EssenceGroup:
339  av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
340  break;
341  case SourcePackage:
342  case MaterialPackage:
343  av_freep(&((MXFPackage *)*ctx)->tracks_refs);
344  av_freep(&((MXFPackage *)*ctx)->name);
345  av_freep(&((MXFPackage *)*ctx)->comment_refs);
346  break;
347  case TaggedValue:
348  av_freep(&((MXFTaggedValue *)*ctx)->name);
349  av_freep(&((MXFTaggedValue *)*ctx)->value);
350  break;
351  case Track:
352  av_freep(&((MXFTrack *)*ctx)->name);
353  break;
354  case IndexTableSegment:
355  seg = (MXFIndexTableSegment *)*ctx;
357  av_freep(&seg->flag_entries);
359  default:
360  break;
361  }
362  if (freectx)
363  av_freep(ctx);
364 }
365 
367 {
368  uint64_t size = avio_r8(pb);
369  if (size & 0x80) { /* long form */
370  int bytes_num = size & 0x7f;
371  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
372  if (bytes_num > 8)
373  return AVERROR_INVALIDDATA;
374  size = 0;
375  while (bytes_num--)
376  size = size << 8 | avio_r8(pb);
377  }
378  if (size > INT64_MAX)
379  return AVERROR_INVALIDDATA;
380  return size;
381 }
382 
383 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
384 {
385  int i, b;
386  for (i = 0; i < size && !avio_feof(pb); i++) {
387  b = avio_r8(pb);
388  if (b == key[0])
389  i = 0;
390  else if (b != key[i])
391  i = -1;
392  }
393  return i == size;
394 }
395 
396 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
397 {
398  int64_t length, pos;
399  if (!mxf_read_sync(pb, mxf_klv_key, 4))
400  return AVERROR_INVALIDDATA;
401  klv->offset = avio_tell(pb) - 4;
402  memcpy(klv->key, mxf_klv_key, 4);
403  avio_read(pb, klv->key + 4, 12);
404  length = klv_decode_ber_length(pb);
405  if (length < 0)
406  return length;
407  klv->length = length;
408  pos = avio_tell(pb);
409  if (pos > INT64_MAX - length)
410  return AVERROR_INVALIDDATA;
411  klv->next_klv = pos + length;
412  return 0;
413 }
414 
415 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
416 {
417  int i;
418 
419  for (i = 0; i < s->nb_streams; i++) {
420  MXFTrack *track = s->streams[i]->priv_data;
421  /* SMPTE 379M 7.3 */
422  if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
423  return i;
424  }
425  /* return 0 if only one stream, for OP Atom files with 0 as track number */
426  return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
427 }
428 
429 static int find_body_sid_by_offset(MXFContext *mxf, int64_t offset)
430 {
431  // we look for partition where the offset is placed
432  int a, b, m;
433  int64_t this_partition;
434 
435  a = -1;
436  b = mxf->partitions_count;
437 
438  while (b - a > 1) {
439  m = (a + b) >> 1;
440  this_partition = mxf->partitions[m].this_partition;
441  if (this_partition <= offset)
442  a = m;
443  else
444  b = m;
445  }
446 
447  if (a == -1)
448  return 0;
449  return mxf->partitions[a].body_sid;
450 }
451 
452 /* XXX: use AVBitStreamFilter */
454 {
455  const uint8_t *buf_ptr, *end_ptr;
456  uint8_t *data_ptr;
457  int i;
458 
459  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
460  return AVERROR_INVALIDDATA;
461  length = av_get_packet(pb, pkt, length);
462  if (length < 0)
463  return length;
464  data_ptr = pkt->data;
465  end_ptr = pkt->data + length;
466  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
467  for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
468  for (i = 0; i < st->codecpar->channels; i++) {
469  uint32_t sample = bytestream_get_le32(&buf_ptr);
470  if (st->codecpar->bits_per_coded_sample == 24)
471  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
472  else
473  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
474  }
475  buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
476  }
477  av_shrink_packet(pkt, data_ptr - pkt->data);
478  return 0;
479 }
480 
482 {
483  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
484  MXFContext *mxf = s->priv_data;
485  AVIOContext *pb = s->pb;
486  int64_t end = avio_tell(pb) + klv->length;
487  int64_t size;
488  uint64_t orig_size;
489  uint64_t plaintext_size;
490  uint8_t ivec[16];
491  uint8_t tmpbuf[16];
492  int index;
493  int body_sid;
494 
495  if (!mxf->aesc && s->key && s->keylen == 16) {
496  mxf->aesc = av_aes_alloc();
497  if (!mxf->aesc)
498  return AVERROR(ENOMEM);
499  av_aes_init(mxf->aesc, s->key, 128, 1);
500  }
501  // crypto context
502  size = klv_decode_ber_length(pb);
503  if (size < 0)
504  return size;
505  avio_skip(pb, size);
506  // plaintext offset
508  plaintext_size = avio_rb64(pb);
509  // source klv key
511  avio_read(pb, klv->key, 16);
513  return AVERROR_INVALIDDATA;
514 
515  body_sid = find_body_sid_by_offset(mxf, klv->offset);
516  index = mxf_get_stream_index(s, klv, body_sid);
517  if (index < 0)
518  return AVERROR_INVALIDDATA;
519  // source size
521  orig_size = avio_rb64(pb);
522  if (orig_size < plaintext_size)
523  return AVERROR_INVALIDDATA;
524  // enc. code
525  size = klv_decode_ber_length(pb);
526  if (size < 32 || size - 32 < orig_size)
527  return AVERROR_INVALIDDATA;
528  avio_read(pb, ivec, 16);
529  avio_read(pb, tmpbuf, 16);
530  if (mxf->aesc)
531  av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
532  if (memcmp(tmpbuf, checkv, 16))
533  av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
534  size -= 32;
535  size = av_get_packet(pb, pkt, size);
536  if (size < 0)
537  return size;
538  else if (size < plaintext_size)
539  return AVERROR_INVALIDDATA;
540  size -= plaintext_size;
541  if (mxf->aesc)
542  av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
543  &pkt->data[plaintext_size], size >> 4, ivec, 1);
544  av_shrink_packet(pkt, orig_size);
545  pkt->stream_index = index;
546  avio_skip(pb, end - avio_tell(pb));
547  return 0;
548 }
549 
550 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
551 {
552  MXFContext *mxf = arg;
553  int item_num = avio_rb32(pb);
554  int item_len = avio_rb32(pb);
555 
556  if (item_len != 18) {
557  avpriv_request_sample(pb, "Primer pack item length %d", item_len);
558  return AVERROR_PATCHWELCOME;
559  }
560  if (item_num > 65536 || item_num < 0) {
561  av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
562  return AVERROR_INVALIDDATA;
563  }
564  if (mxf->local_tags)
565  av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
566  av_free(mxf->local_tags);
567  mxf->local_tags_count = 0;
568  mxf->local_tags = av_calloc(item_num, item_len);
569  if (!mxf->local_tags)
570  return AVERROR(ENOMEM);
571  mxf->local_tags_count = item_num;
572  avio_read(pb, mxf->local_tags, item_num*item_len);
573  return 0;
574 }
575 
576 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
577 {
578  MXFContext *mxf = arg;
579  MXFPartition *partition, *tmp_part;
580  UID op;
581  uint64_t footer_partition;
582  uint32_t nb_essence_containers;
583 
584  if (mxf->partitions_count >= INT_MAX / 2)
585  return AVERROR_INVALIDDATA;
586 
587  tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
588  if (!tmp_part)
589  return AVERROR(ENOMEM);
590  mxf->partitions = tmp_part;
591 
592  if (mxf->parsing_backward) {
593  /* insert the new partition pack in the middle
594  * this makes the entries in mxf->partitions sorted by offset */
595  memmove(&mxf->partitions[mxf->last_forward_partition+1],
597  (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
598  partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
599  } else {
600  mxf->last_forward_partition++;
601  partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
602  }
603 
604  memset(partition, 0, sizeof(*partition));
605  mxf->partitions_count++;
606  partition->pack_length = avio_tell(pb) - klv_offset + size;
607  partition->pack_ofs = klv_offset;
608 
609  switch(uid[13]) {
610  case 2:
611  partition->type = Header;
612  break;
613  case 3:
614  partition->type = BodyPartition;
615  break;
616  case 4:
617  partition->type = Footer;
618  break;
619  default:
620  av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
621  return AVERROR_INVALIDDATA;
622  }
623 
624  /* consider both footers to be closed (there is only Footer and CompleteFooter) */
625  partition->closed = partition->type == Footer || !(uid[14] & 1);
626  partition->complete = uid[14] > 2;
627  avio_skip(pb, 4);
628  partition->kag_size = avio_rb32(pb);
629  partition->this_partition = avio_rb64(pb);
630  partition->previous_partition = avio_rb64(pb);
631  footer_partition = avio_rb64(pb);
632  partition->header_byte_count = avio_rb64(pb);
633  partition->index_byte_count = avio_rb64(pb);
634  partition->index_sid = avio_rb32(pb);
635  partition->body_offset = avio_rb64(pb);
636  partition->body_sid = avio_rb32(pb);
637  if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
638  av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
639  return AVERROR_INVALIDDATA;
640  }
641  nb_essence_containers = avio_rb32(pb);
642 
643  if (partition->this_partition &&
644  partition->previous_partition == partition->this_partition) {
645  av_log(mxf->fc, AV_LOG_ERROR,
646  "PreviousPartition equal to ThisPartition %"PRIx64"\n",
647  partition->previous_partition);
648  /* override with the actual previous partition offset */
649  if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
650  MXFPartition *prev =
651  mxf->partitions + mxf->last_forward_partition - 2;
652  partition->previous_partition = prev->this_partition;
653  }
654  /* if no previous body partition are found point to the header
655  * partition */
656  if (partition->previous_partition == partition->this_partition)
657  partition->previous_partition = 0;
658  av_log(mxf->fc, AV_LOG_ERROR,
659  "Overriding PreviousPartition with %"PRIx64"\n",
660  partition->previous_partition);
661  }
662 
663  /* some files don't have FooterPartition set in every partition */
664  if (footer_partition) {
665  if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
666  av_log(mxf->fc, AV_LOG_ERROR,
667  "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
668  mxf->footer_partition, footer_partition);
669  } else {
670  mxf->footer_partition = footer_partition;
671  }
672  }
673 
674  av_log(mxf->fc, AV_LOG_TRACE,
675  "PartitionPack: ThisPartition = 0x%"PRIX64
676  ", PreviousPartition = 0x%"PRIX64", "
677  "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
678  partition->this_partition,
679  partition->previous_partition, footer_partition,
680  partition->index_sid, partition->body_sid);
681 
682  /* sanity check PreviousPartition if set */
683  //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
684  if (partition->previous_partition &&
685  mxf->run_in + partition->previous_partition >= klv_offset) {
686  av_log(mxf->fc, AV_LOG_ERROR,
687  "PreviousPartition points to this partition or forward\n");
688  return AVERROR_INVALIDDATA;
689  }
690 
691  if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
692  else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
693  else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
694  else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
695  else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
696  else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
697  else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
698  else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
699  else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
700  else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
701  else if (op[12] == 0x10) {
702  /* SMPTE 390m: "There shall be exactly one essence container"
703  * The following block deals with files that violate this, namely:
704  * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
705  * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
706  if (nb_essence_containers != 1) {
707  MXFOP op = nb_essence_containers ? OP1a : OPAtom;
708 
709  /* only nag once */
710  if (!mxf->op)
711  av_log(mxf->fc, AV_LOG_WARNING,
712  "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
713  nb_essence_containers,
714  op == OP1a ? "OP1a" : "OPAtom");
715 
716  mxf->op = op;
717  } else
718  mxf->op = OPAtom;
719  } else {
720  av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
721  mxf->op = OP1a;
722  }
723 
724  if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
725  av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
726  partition->kag_size);
727 
728  if (mxf->op == OPSONYOpt)
729  partition->kag_size = 512;
730  else
731  partition->kag_size = 1;
732 
733  av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
734  }
735 
736  return 0;
737 }
738 
739 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
740 {
742 
743  tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
744  if (!tmp)
745  return AVERROR(ENOMEM);
746  mxf->metadata_sets = tmp;
747  mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
748  mxf->metadata_sets_count++;
749  return 0;
750 }
751 
752 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
753 {
754  MXFCryptoContext *cryptocontext = arg;
755  if (size != 16)
756  return AVERROR_INVALIDDATA;
758  avio_read(pb, cryptocontext->source_container_ul, 16);
759  return 0;
760 }
761 
762 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
763 {
764  *count = avio_rb32(pb);
765  *refs = av_calloc(*count, sizeof(UID));
766  if (!*refs) {
767  *count = 0;
768  return AVERROR(ENOMEM);
769  }
770  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
771  avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
772  return 0;
773 }
774 
775 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
776 {
777  int ret;
778  size_t buf_size;
779 
780  if (size < 0 || size > INT_MAX/2)
781  return AVERROR(EINVAL);
782 
783  buf_size = size + size / 2 + 1;
784  *str = av_malloc(buf_size);
785  if (!*str)
786  return AVERROR(ENOMEM);
787 
788  if (be)
789  ret = avio_get_str16be(pb, size, *str, buf_size);
790  else
791  ret = avio_get_str16le(pb, size, *str, buf_size);
792 
793  if (ret < 0) {
794  av_freep(str);
795  return ret;
796  }
797 
798  return ret;
799 }
800 
801 #define READ_STR16(type, big_endian) \
802 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
803 { \
804 return mxf_read_utf16_string(pb, size, str, big_endian); \
805 }
806 READ_STR16(be, 1)
807 READ_STR16(le, 0)
808 #undef READ_STR16
809 
810 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
811 {
812  MXFContext *mxf = arg;
813  switch (tag) {
814  case 0x1901:
815  if (mxf->packages_refs)
816  av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
817  av_free(mxf->packages_refs);
818  return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
819  case 0x1902:
822  }
823  return 0;
824 }
825 
826 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
827 {
828  MXFStructuralComponent *source_clip = arg;
829  switch(tag) {
830  case 0x0202:
831  source_clip->duration = avio_rb64(pb);
832  break;
833  case 0x1201:
834  source_clip->start_position = avio_rb64(pb);
835  break;
836  case 0x1101:
837  /* UMID, only get last 16 bytes */
838  avio_read(pb, source_clip->source_package_ul, 16);
839  avio_read(pb, source_clip->source_package_uid, 16);
840  break;
841  case 0x1102:
842  source_clip->source_track_id = avio_rb32(pb);
843  break;
844  }
845  return 0;
846 }
847 
848 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
849 {
850  MXFTimecodeComponent *mxf_timecode = arg;
851  switch(tag) {
852  case 0x1501:
853  mxf_timecode->start_frame = avio_rb64(pb);
854  break;
855  case 0x1502:
856  mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
857  break;
858  case 0x1503:
859  mxf_timecode->drop_frame = avio_r8(pb);
860  break;
861  }
862  return 0;
863 }
864 
865 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
866 {
867  MXFPulldownComponent *mxf_pulldown = arg;
868  switch(tag) {
869  case 0x0d01:
870  avio_read(pb, mxf_pulldown->input_segment_ref, 16);
871  break;
872  }
873  return 0;
874 }
875 
876 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
877 {
878  MXFTrack *track = arg;
879  switch(tag) {
880  case 0x4801:
881  track->track_id = avio_rb32(pb);
882  break;
883  case 0x4804:
884  avio_read(pb, track->track_number, 4);
885  break;
886  case 0x4802:
887  mxf_read_utf16be_string(pb, size, &track->name);
888  break;
889  case 0x4b01:
890  track->edit_rate.num = avio_rb32(pb);
891  track->edit_rate.den = avio_rb32(pb);
892  break;
893  case 0x4803:
894  avio_read(pb, track->sequence_ref, 16);
895  break;
896  }
897  return 0;
898 }
899 
900 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
901 {
902  MXFSequence *sequence = arg;
903  switch(tag) {
904  case 0x0202:
905  sequence->duration = avio_rb64(pb);
906  break;
907  case 0x0201:
908  avio_read(pb, sequence->data_definition_ul, 16);
909  break;
910  case 0x4b02:
911  sequence->origin = avio_r8(pb);
912  break;
913  case 0x1001:
915  &sequence->structural_components_count);
916  }
917  return 0;
918 }
919 
920 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
921 {
922  MXFEssenceGroup *essence_group = arg;
923  switch (tag) {
924  case 0x0202:
925  essence_group->duration = avio_rb64(pb);
926  break;
927  case 0x0501:
928  return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
929  &essence_group->structural_components_count);
930  }
931  return 0;
932 }
933 
934 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
935 {
936  MXFPackage *package = arg;
937  switch(tag) {
938  case 0x4403:
939  return mxf_read_strong_ref_array(pb, &package->tracks_refs,
940  &package->tracks_count);
941  case 0x4401:
942  /* UMID */
943  avio_read(pb, package->package_ul, 16);
944  avio_read(pb, package->package_uid, 16);
945  break;
946  case 0x4701:
947  avio_read(pb, package->descriptor_ref, 16);
948  break;
949  case 0x4402:
950  return mxf_read_utf16be_string(pb, size, &package->name);
951  case 0x4406:
952  return mxf_read_strong_ref_array(pb, &package->comment_refs,
953  &package->comment_count);
954  }
955  return 0;
956 }
957 
958 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
959 {
960  MXFEssenceContainerData *essence_data = arg;
961  switch(tag) {
962  case 0x2701:
963  /* linked package umid UMID */
964  avio_read(pb, essence_data->package_ul, 16);
965  avio_read(pb, essence_data->package_uid, 16);
966  break;
967  case 0x3f06:
968  essence_data->index_sid = avio_rb32(pb);
969  break;
970  case 0x3f07:
971  essence_data->body_sid = avio_rb32(pb);
972  break;
973  }
974  return 0;
975 }
976 
978 {
979  int i, length;
980 
981  segment->nb_index_entries = avio_rb32(pb);
982 
983  length = avio_rb32(pb);
984  if(segment->nb_index_entries && length < 11)
985  return AVERROR_INVALIDDATA;
986 
987  if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
988  !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
989  !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
991  av_freep(&segment->flag_entries);
992  return AVERROR(ENOMEM);
993  }
994 
995  for (i = 0; i < segment->nb_index_entries; i++) {
996  if(avio_feof(pb))
997  return AVERROR_INVALIDDATA;
998  segment->temporal_offset_entries[i] = avio_r8(pb);
999  avio_r8(pb); /* KeyFrameOffset */
1000  segment->flag_entries[i] = avio_r8(pb);
1001  segment->stream_offset_entries[i] = avio_rb64(pb);
1002  avio_skip(pb, length - 11);
1003  }
1004  return 0;
1005 }
1006 
1007 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1008 {
1010  switch(tag) {
1011  case 0x3F05:
1012  segment->edit_unit_byte_count = avio_rb32(pb);
1013  av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1014  break;
1015  case 0x3F06:
1016  segment->index_sid = avio_rb32(pb);
1017  av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1018  break;
1019  case 0x3F07:
1020  segment->body_sid = avio_rb32(pb);
1021  av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1022  break;
1023  case 0x3F0A:
1024  av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1025  return mxf_read_index_entry_array(pb, segment);
1026  case 0x3F0B:
1027  segment->index_edit_rate.num = avio_rb32(pb);
1028  segment->index_edit_rate.den = avio_rb32(pb);
1029  av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1030  segment->index_edit_rate.den);
1031  break;
1032  case 0x3F0C:
1033  segment->index_start_position = avio_rb64(pb);
1034  av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1035  break;
1036  case 0x3F0D:
1037  segment->index_duration = avio_rb64(pb);
1038  av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1039  break;
1040  }
1041  return 0;
1042 }
1043 
1044 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1045 {
1046  int code, value, ofs = 0;
1047  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1048 
1049  do {
1050  code = avio_r8(pb);
1051  value = avio_r8(pb);
1052  av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1053 
1054  if (ofs <= 14) {
1055  layout[ofs++] = code;
1056  layout[ofs++] = value;
1057  } else
1058  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1059  } while (code != 0); /* SMPTE 377M E.2.46 */
1060 
1061  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1062 }
1063 
1064 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1065 {
1066  MXFDescriptor *descriptor = arg;
1067  int entry_count, entry_size;
1068 
1069  switch(tag) {
1070  case 0x3F01:
1071  return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
1072  &descriptor->sub_descriptors_count);
1073  case 0x3002: /* ContainerDuration */
1074  descriptor->duration = avio_rb64(pb);
1075  break;
1076  case 0x3004:
1077  avio_read(pb, descriptor->essence_container_ul, 16);
1078  break;
1079  case 0x3005:
1080  avio_read(pb, descriptor->codec_ul, 16);
1081  break;
1082  case 0x3006:
1083  descriptor->linked_track_id = avio_rb32(pb);
1084  break;
1085  case 0x3201: /* PictureEssenceCoding */
1086  avio_read(pb, descriptor->essence_codec_ul, 16);
1087  break;
1088  case 0x3203:
1089  descriptor->width = avio_rb32(pb);
1090  break;
1091  case 0x3202:
1092  descriptor->height = avio_rb32(pb);
1093  break;
1094  case 0x320C:
1095  descriptor->frame_layout = avio_r8(pb);
1096  break;
1097  case 0x320D:
1098  entry_count = avio_rb32(pb);
1099  entry_size = avio_rb32(pb);
1100  if (entry_size == 4) {
1101  if (entry_count > 0)
1102  descriptor->video_line_map[0] = avio_rb32(pb);
1103  else
1104  descriptor->video_line_map[0] = 0;
1105  if (entry_count > 1)
1106  descriptor->video_line_map[1] = avio_rb32(pb);
1107  else
1108  descriptor->video_line_map[1] = 0;
1109  } else
1110  av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1111  break;
1112  case 0x320E:
1113  descriptor->aspect_ratio.num = avio_rb32(pb);
1114  descriptor->aspect_ratio.den = avio_rb32(pb);
1115  break;
1116  case 0x3212:
1117  descriptor->field_dominance = avio_r8(pb);
1118  break;
1119  case 0x3301:
1120  descriptor->component_depth = avio_rb32(pb);
1121  break;
1122  case 0x3302:
1123  descriptor->horiz_subsampling = avio_rb32(pb);
1124  break;
1125  case 0x3308:
1126  descriptor->vert_subsampling = avio_rb32(pb);
1127  break;
1128  case 0x3D03:
1129  descriptor->sample_rate.num = avio_rb32(pb);
1130  descriptor->sample_rate.den = avio_rb32(pb);
1131  break;
1132  case 0x3D06: /* SoundEssenceCompression */
1133  avio_read(pb, descriptor->essence_codec_ul, 16);
1134  break;
1135  case 0x3D07:
1136  descriptor->channels = avio_rb32(pb);
1137  break;
1138  case 0x3D01:
1139  descriptor->bits_per_sample = avio_rb32(pb);
1140  break;
1141  case 0x3401:
1142  mxf_read_pixel_layout(pb, descriptor);
1143  break;
1144  default:
1145  /* Private uid used by SONY C0023S01.mxf */
1147  if (descriptor->extradata)
1148  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1149  av_free(descriptor->extradata);
1150  descriptor->extradata_size = 0;
1151  descriptor->extradata = av_malloc(size);
1152  if (!descriptor->extradata)
1153  return AVERROR(ENOMEM);
1154  descriptor->extradata_size = size;
1155  avio_read(pb, descriptor->extradata, size);
1156  }
1157  if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1158  uint32_t rsiz = avio_rb16(pb);
1159  if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1161  descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1162  }
1163  break;
1164  }
1165  return 0;
1166 }
1167 
1168 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1169 {
1170  MXFTaggedValue *tagged_value = arg;
1171  uint8_t key[17];
1172 
1173  if (size <= 17)
1174  return 0;
1175 
1176  avio_read(pb, key, 17);
1177  /* TODO: handle other types of of indirect values */
1178  if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1179  return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1180  } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1181  return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1182  }
1183  return 0;
1184 }
1185 
1186 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1187 {
1188  MXFTaggedValue *tagged_value = arg;
1189  switch (tag){
1190  case 0x5001:
1191  return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1192  case 0x5003:
1193  return mxf_read_indirect_value(tagged_value, pb, size);
1194  }
1195  return 0;
1196 }
1197 
1198 /*
1199  * Match an uid independently of the version byte and up to len common bytes
1200  * Returns: boolean
1201  */
1202 static int mxf_match_uid(const UID key, const UID uid, int len)
1203 {
1204  int i;
1205  for (i = 0; i < len; i++) {
1206  if (i != 7 && key[i] != uid[i])
1207  return 0;
1208  }
1209  return 1;
1210 }
1211 
1212 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1213 {
1214  while (uls->uid[0]) {
1215  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1216  break;
1217  uls++;
1218  }
1219  return uls;
1220 }
1221 
1222 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1223 {
1224  int i;
1225 
1226  if (!strong_ref)
1227  return NULL;
1228  for (i = 0; i < mxf->metadata_sets_count; i++) {
1229  if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1230  (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1231  return mxf->metadata_sets[i];
1232  }
1233  }
1234  return NULL;
1235 }
1236 
1238  // video essence container uls
1239  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14 },
1240  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264, NULL, 15 }, /* H.264 */
1241  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14, AV_CODEC_ID_DNXHD, NULL, 14 }, /* VC-3 */
1242  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1, NULL, 14 }, /* VC-1 */
1243  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1244  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14, AV_CODEC_ID_DIRAC, NULL, 14 }, /* VC-2 */
1245  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14, AV_CODEC_ID_CFHD, NULL, 14 }, /* VC-5 */
1246  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1247  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1248  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15, D10D11Wrap }, /* SMPTE D-10 mapping */
1249  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO, NULL, 15 }, /* DV 625 25mbps */
1250  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO, NULL, 15, RawVWrap }, /* uncompressed picture */
1251  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1252  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1253  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1254  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1255 };
1256 
1257 /* EC ULs for intra-only formats */
1259  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 mappings */
1260  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1261 };
1262 
1263 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1265  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */
1266  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1267  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1268 };
1269 
1270 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1272  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1273  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1274  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1275  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1276  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1277 };
1278 
1280  // sound essence container uls
1281  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 14, RawAWrap }, /* BWF */
1282  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2, NULL, 15 }, /* MPEG-ES */
1283  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 13 }, /* D-10 Mapping 50Mbps PAL Extended Template */
1284  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14, AV_CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */
1285  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1286  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1287 };
1288 
1290  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_smpte_436M", 11 },
1291  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_vanc_smpte_436M", 11 },
1292  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1293  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1294 };
1295 
1296 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1297 {
1298  int val;
1299  const MXFCodecUL *codec_ul;
1300 
1301  codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1302  if (!codec_ul->uid[0])
1303  codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1304  if (!codec_ul->uid[0])
1305  codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1306  if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1307  return UnknownWrapped;
1308 
1309  val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1310  switch (codec_ul->wrapping_indicator_type) {
1311  case RawVWrap:
1312  val = val % 4;
1313  break;
1314  case RawAWrap:
1315  if (val == 0x03 || val == 0x04)
1316  val -= 0x02;
1317  break;
1318  case D10D11Wrap:
1319  if (val == 0x02)
1320  val = 0x01;
1321  break;
1322  }
1323  if (val == 0x01)
1324  return FrameWrapped;
1325  if (val == 0x02)
1326  return ClipWrapped;
1327  return UnknownWrapped;
1328 }
1329 
1330 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1331 {
1332  int i, j, nb_segments = 0;
1333  MXFIndexTableSegment **unsorted_segments;
1334  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1335 
1336  /* count number of segments, allocate arrays and copy unsorted segments */
1337  for (i = 0; i < mxf->metadata_sets_count; i++)
1338  if (mxf->metadata_sets[i]->type == IndexTableSegment)
1339  nb_segments++;
1340 
1341  if (!nb_segments)
1342  return AVERROR_INVALIDDATA;
1343 
1344  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1345  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1346  av_freep(sorted_segments);
1347  av_free(unsorted_segments);
1348  return AVERROR(ENOMEM);
1349  }
1350 
1351  for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1352  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1355  unsorted_segments[nb_segments++] = s;
1356  else
1357  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1359  }
1360  }
1361 
1362  if (!nb_segments) {
1363  av_freep(sorted_segments);
1364  av_free(unsorted_segments);
1365  return AVERROR_INVALIDDATA;
1366  }
1367 
1368  *nb_sorted_segments = 0;
1369 
1370  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1371  for (i = 0; i < nb_segments; i++) {
1372  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1373  uint64_t best_index_duration = 0;
1374 
1375  for (j = 0; j < nb_segments; j++) {
1376  MXFIndexTableSegment *s = unsorted_segments[j];
1377 
1378  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1379  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1380  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1381  */
1382  if ((i == 0 ||
1383  s->body_sid > last_body_sid ||
1384  s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1385  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1386  (best == -1 ||
1387  s->body_sid < best_body_sid ||
1388  s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1389  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1390  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1391  best = j;
1392  best_body_sid = s->body_sid;
1393  best_index_sid = s->index_sid;
1394  best_index_start = s->index_start_position;
1395  best_index_duration = s->index_duration;
1396  }
1397  }
1398 
1399  /* no suitable entry found -> we're done */
1400  if (best == -1)
1401  break;
1402 
1403  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1404  last_body_sid = best_body_sid;
1405  last_index_sid = best_index_sid;
1406  last_index_start = best_index_start;
1407  }
1408 
1409  av_free(unsorted_segments);
1410 
1411  return 0;
1412 }
1413 
1414 /**
1415  * Computes the absolute file offset of the given essence container offset
1416  */
1417 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1418 {
1419  MXFPartition *last_p = NULL;
1420  int a, b, m, m0;
1421 
1422  if (offset < 0)
1423  return AVERROR(EINVAL);
1424 
1425  a = -1;
1426  b = mxf->partitions_count;
1427 
1428  while (b - a > 1) {
1429  m0 = m = (a + b) >> 1;
1430 
1431  while (m < b && mxf->partitions[m].body_sid != body_sid)
1432  m++;
1433 
1434  if (m < b && mxf->partitions[m].body_offset <= offset)
1435  a = m;
1436  else
1437  b = m0;
1438  }
1439 
1440  if (a >= 0)
1441  last_p = &mxf->partitions[a];
1442 
1443  if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1444  *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1445  if (partition_out)
1446  *partition_out = last_p;
1447  return 0;
1448  }
1449 
1450  av_log(mxf->fc, AV_LOG_ERROR,
1451  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1452  offset, body_sid);
1453 
1454  return AVERROR_INVALIDDATA;
1455 }
1456 
1457 /**
1458  * Returns the end position of the essence container with given BodySID, or zero if unknown
1459  */
1460 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1461 {
1462  int x;
1463  int64_t ret = 0;
1464 
1465  for (x = 0; x < mxf->partitions_count; x++) {
1466  MXFPartition *p = &mxf->partitions[x];
1467 
1468  if (p->body_sid != body_sid)
1469  continue;
1470 
1471  if (!p->essence_length)
1472  return 0;
1473 
1474  ret = p->essence_offset + p->essence_length;
1475  }
1476 
1477  return ret;
1478 }
1479 
1480 /* EditUnit -> absolute offset */
1481 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
1482 {
1483  int i;
1484  int64_t offset_temp = 0;
1485 
1486  edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1487 
1488  for (i = 0; i < index_table->nb_segments; i++) {
1489  MXFIndexTableSegment *s = index_table->segments[i];
1490 
1491  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1492 
1493  if (edit_unit < s->index_start_position + s->index_duration) {
1494  int64_t index = edit_unit - s->index_start_position;
1495 
1496  if (s->edit_unit_byte_count)
1497  offset_temp += s->edit_unit_byte_count * index;
1498  else {
1499  if (s->nb_index_entries == 2 * s->index_duration + 1)
1500  index *= 2; /* Avid index */
1501 
1502  if (index < 0 || index >= s->nb_index_entries) {
1503  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1504  index_table->index_sid, s->index_start_position);
1505  return AVERROR_INVALIDDATA;
1506  }
1507 
1508  offset_temp = s->stream_offset_entries[index];
1509  }
1510 
1511  if (edit_unit_out)
1512  *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1513 
1514  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1515  } else {
1516  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1517  offset_temp += s->edit_unit_byte_count * s->index_duration;
1518  }
1519  }
1520 
1521  if (nag)
1522  av_log(mxf->fc, AV_LOG_ERROR, "failed to map EditUnit %"PRId64" in IndexSID %i to an offset\n", edit_unit, index_table->index_sid);
1523 
1524  return AVERROR_INVALIDDATA;
1525 }
1526 
1528 {
1529  int i, j, x;
1530  int8_t max_temporal_offset = -128;
1531  uint8_t *flags;
1532 
1533  /* first compute how many entries we have */
1534  for (i = 0; i < index_table->nb_segments; i++) {
1535  MXFIndexTableSegment *s = index_table->segments[i];
1536 
1537  if (!s->nb_index_entries) {
1538  index_table->nb_ptses = 0;
1539  return 0; /* no TemporalOffsets */
1540  }
1541 
1542  if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1543  index_table->nb_ptses = 0;
1544  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1545  return 0;
1546  }
1547 
1548  index_table->nb_ptses += s->index_duration;
1549  }
1550 
1551  /* paranoid check */
1552  if (index_table->nb_ptses <= 0)
1553  return 0;
1554 
1555  if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1556  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1557  !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1558  !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1559  av_freep(&index_table->ptses);
1560  av_freep(&index_table->fake_index);
1561  av_freep(&index_table->offsets);
1562  return AVERROR(ENOMEM);
1563  }
1564 
1565  /* we may have a few bad TemporalOffsets
1566  * make sure the corresponding PTSes don't have the bogus value 0 */
1567  for (x = 0; x < index_table->nb_ptses; x++)
1568  index_table->ptses[x] = AV_NOPTS_VALUE;
1569 
1570  /**
1571  * We have this:
1572  *
1573  * x TemporalOffset
1574  * 0: 0
1575  * 1: 1
1576  * 2: 1
1577  * 3: -2
1578  * 4: 1
1579  * 5: 1
1580  * 6: -2
1581  *
1582  * We want to transform it into this:
1583  *
1584  * x DTS PTS
1585  * 0: -1 0
1586  * 1: 0 3
1587  * 2: 1 1
1588  * 3: 2 2
1589  * 4: 3 6
1590  * 5: 4 4
1591  * 6: 5 5
1592  *
1593  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1594  * then settings mxf->first_dts = -max(TemporalOffset[x]).
1595  * The latter makes DTS <= PTS.
1596  */
1597  for (i = x = 0; i < index_table->nb_segments; i++) {
1598  MXFIndexTableSegment *s = index_table->segments[i];
1599  int index_delta = 1;
1600  int n = s->nb_index_entries;
1601 
1602  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1603  index_delta = 2; /* Avid index */
1604  /* ignore the last entry - it's the size of the essence container */
1605  n--;
1606  }
1607 
1608  for (j = 0; j < n; j += index_delta, x++) {
1609  int offset = s->temporal_offset_entries[j] / index_delta;
1610  int index = x + offset;
1611 
1612  if (x >= index_table->nb_ptses) {
1613  av_log(mxf->fc, AV_LOG_ERROR,
1614  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1616  break;
1617  }
1618 
1619  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1620 
1621  if (index < 0 || index >= index_table->nb_ptses) {
1622  av_log(mxf->fc, AV_LOG_ERROR,
1623  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1624  x, offset, index);
1625  continue;
1626  }
1627 
1628  index_table->offsets[x] = offset;
1629  index_table->ptses[index] = x;
1630  max_temporal_offset = FFMAX(max_temporal_offset, offset);
1631  }
1632  }
1633 
1634  /* calculate the fake index table in display order */
1635  for (x = 0; x < index_table->nb_ptses; x++) {
1636  index_table->fake_index[x].timestamp = x;
1637  if (index_table->ptses[x] != AV_NOPTS_VALUE)
1638  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1639  }
1640  av_freep(&flags);
1641 
1642  index_table->first_dts = -max_temporal_offset;
1643 
1644  return 0;
1645 }
1646 
1647 /**
1648  * Sorts and collects index table segments into index tables.
1649  * Also computes PTSes if possible.
1650  */
1652 {
1653  int i, j, k, ret, nb_sorted_segments;
1654  MXFIndexTableSegment **sorted_segments = NULL;
1655 
1656  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1657  nb_sorted_segments <= 0) {
1658  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1659  return 0;
1660  }
1661 
1662  /* sanity check and count unique BodySIDs/IndexSIDs */
1663  for (i = 0; i < nb_sorted_segments; i++) {
1664  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1665  mxf->nb_index_tables++;
1666  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1667  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1668  ret = AVERROR_INVALIDDATA;
1669  goto finish_decoding_index;
1670  }
1671  }
1672 
1674  sizeof(*mxf->index_tables));
1675  if (!mxf->index_tables) {
1676  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1677  ret = AVERROR(ENOMEM);
1678  goto finish_decoding_index;
1679  }
1680 
1681  /* distribute sorted segments to index tables */
1682  for (i = j = 0; i < nb_sorted_segments; i++) {
1683  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1684  /* next IndexSID */
1685  j++;
1686  }
1687 
1688  mxf->index_tables[j].nb_segments++;
1689  }
1690 
1691  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1692  MXFIndexTable *t = &mxf->index_tables[j];
1693  MXFTrack *mxf_track = NULL;
1694 
1696  sizeof(*t->segments));
1697 
1698  if (!t->segments) {
1699  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1700  " pointer array\n");
1701  ret = AVERROR(ENOMEM);
1702  goto finish_decoding_index;
1703  }
1704 
1705  if (sorted_segments[i]->index_start_position)
1706  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1707  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1708 
1709  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1710  t->index_sid = sorted_segments[i]->index_sid;
1711  t->body_sid = sorted_segments[i]->body_sid;
1712 
1713  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1714  goto finish_decoding_index;
1715 
1716  for (k = 0; k < mxf->fc->nb_streams; k++) {
1717  MXFTrack *track = mxf->fc->streams[k]->priv_data;
1718  if (track && track->index_sid == t->index_sid) {
1719  mxf_track = track;
1720  break;
1721  }
1722  }
1723 
1724  /* fix zero IndexDurations */
1725  for (k = 0; k < t->nb_segments; k++) {
1726  if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
1727  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
1728  t->index_sid, k);
1729  if (mxf_track)
1730  t->segments[k]->index_edit_rate = mxf_track->edit_rate;
1731  }
1732 
1733  if (t->segments[k]->index_duration)
1734  continue;
1735 
1736  if (t->nb_segments > 1)
1737  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1738  t->index_sid, k);
1739 
1740  if (!mxf_track) {
1741  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1742  break;
1743  }
1744 
1745  /* assume the first stream's duration is reasonable
1746  * leave index_duration = 0 on further segments in case we have any (unlikely)
1747  */
1748  t->segments[k]->index_duration = mxf_track->original_duration;
1749  break;
1750  }
1751  }
1752 
1753  ret = 0;
1754 finish_decoding_index:
1755  av_free(sorted_segments);
1756  return ret;
1757 }
1758 
1759 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1760 {
1761  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1762  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1763  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1764  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1765 }
1766 
1767 static int mxf_uid_to_str(UID uid, char **str)
1768 {
1769  int i;
1770  char *p;
1771  p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1772  if (!p)
1773  return AVERROR(ENOMEM);
1774  for (i = 0; i < sizeof(UID); i++) {
1775  snprintf(p, 2 + 1, "%.2x", uid[i]);
1776  p += 2;
1777  if (i == 3 || i == 5 || i == 7 || i == 9) {
1778  snprintf(p, 1 + 1, "-");
1779  p++;
1780  }
1781  }
1782  return 0;
1783 }
1784 
1785 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1786 {
1787  int i;
1788  char *p;
1789  p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1790  if (!p)
1791  return AVERROR(ENOMEM);
1792  snprintf(p, 2 + 1, "0x");
1793  p += 2;
1794  for (i = 0; i < sizeof(UID); i++) {
1795  snprintf(p, 2 + 1, "%.2X", ul[i]);
1796  p += 2;
1797 
1798  }
1799  for (i = 0; i < sizeof(UID); i++) {
1800  snprintf(p, 2 + 1, "%.2X", uid[i]);
1801  p += 2;
1802  }
1803  return 0;
1804 }
1805 
1806 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1807 {
1808  char *str;
1809  int ret;
1810  if (!package)
1811  return 0;
1812  if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1813  return ret;
1814  av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1815  return 0;
1816 }
1817 
1818 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1819 {
1820  char buf[AV_TIMECODE_STR_SIZE];
1821  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1822 
1823  return 0;
1824 }
1825 
1827 {
1828  MXFStructuralComponent *component = NULL;
1829  MXFPulldownComponent *pulldown = NULL;
1830 
1831  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1832  if (!component)
1833  return NULL;
1834 
1835  switch (component->type) {
1836  case TimecodeComponent:
1837  return (MXFTimecodeComponent*)component;
1838  case PulldownComponent: /* timcode component may be located on a pulldown component */
1839  pulldown = (MXFPulldownComponent*)component;
1841  default:
1842  break;
1843  }
1844  return NULL;
1845 }
1846 
1847 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1848 {
1849  MXFPackage *package = NULL;
1850  int i;
1851 
1852  for (i = 0; i < mxf->packages_count; i++) {
1853  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1854  if (!package)
1855  continue;
1856 
1857  if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1858  return package;
1859  }
1860  return NULL;
1861 }
1862 
1863 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1864 {
1865  MXFDescriptor *sub_descriptor = NULL;
1866  int i;
1867 
1868  if (!descriptor)
1869  return NULL;
1870 
1871  if (descriptor->type == MultipleDescriptor) {
1872  for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1873  sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1874 
1875  if (!sub_descriptor) {
1876  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1877  continue;
1878  }
1879  if (sub_descriptor->linked_track_id == track_id) {
1880  return sub_descriptor;
1881  }
1882  }
1883  } else if (descriptor->type == Descriptor)
1884  return descriptor;
1885 
1886  return NULL;
1887 }
1888 
1890 {
1891  MXFStructuralComponent *component = NULL;
1892  MXFPackage *package = NULL;
1893  MXFDescriptor *descriptor = NULL;
1894  int i;
1895 
1896  if (!essence_group || !essence_group->structural_components_count)
1897  return NULL;
1898 
1899  /* essence groups contains multiple representations of the same media,
1900  this return the first components with a valid Descriptor typically index 0 */
1901  for (i =0; i < essence_group->structural_components_count; i++){
1902  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1903  if (!component)
1904  continue;
1905 
1906  if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1907  continue;
1908 
1909  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1910  if (descriptor)
1911  return component;
1912  }
1913  return NULL;
1914 }
1915 
1917 {
1918  MXFStructuralComponent *component = NULL;
1919 
1920  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1921  if (!component)
1922  return NULL;
1923  switch (component->type) {
1924  case SourceClip:
1925  return component;
1926  case EssenceGroup:
1927  return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1928  default:
1929  break;
1930  }
1931  return NULL;
1932 }
1933 
1935 {
1937  int size, i;
1938  char *key = NULL;
1939 
1940  for (i = 0; i < package->comment_count; i++) {
1941  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1942  if (!tag || !tag->name || !tag->value)
1943  continue;
1944 
1945  size = strlen(tag->name) + 8 + 1;
1946  key = av_mallocz(size);
1947  if (!key)
1948  return AVERROR(ENOMEM);
1949 
1950  snprintf(key, size, "comment_%s", tag->name);
1951  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1952  }
1953  return 0;
1954 }
1955 
1957 {
1958  MXFPackage *physical_package = NULL;
1959  MXFTrack *physical_track = NULL;
1960  MXFStructuralComponent *sourceclip = NULL;
1961  MXFTimecodeComponent *mxf_tc = NULL;
1962  int i, j, k;
1963  AVTimecode tc;
1964  int flags;
1965  int64_t start_position;
1966 
1967  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1968  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1969  if (!sourceclip)
1970  continue;
1971 
1972  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1973  break;
1974 
1975  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1976 
1977  /* the name of physical source package is name of the reel or tape */
1978  if (physical_package->name && physical_package->name[0])
1979  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1980 
1981  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1982  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1983  */
1984  for (j = 0; j < physical_package->tracks_count; j++) {
1985  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1986  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1987  continue;
1988  }
1989 
1990  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1991  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1992  continue;
1993  }
1994 
1995  if (physical_track->edit_rate.num <= 0 ||
1996  physical_track->edit_rate.den <= 0) {
1997  av_log(mxf->fc, AV_LOG_WARNING,
1998  "Invalid edit rate (%d/%d) found on structural"
1999  " component #%d, defaulting to 25/1\n",
2000  physical_track->edit_rate.num,
2001  physical_track->edit_rate.den, i);
2002  physical_track->edit_rate = (AVRational){25, 1};
2003  }
2004 
2005  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2006  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2007  continue;
2008 
2009  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2010  /* scale sourceclip start_position to match physical track edit rate */
2011  start_position = av_rescale_q(sourceclip->start_position,
2012  physical_track->edit_rate,
2013  source_track->edit_rate);
2014 
2015  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2016  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2017  return 0;
2018  }
2019  }
2020  }
2021  }
2022 
2023  return 0;
2024 }
2025 
2027 {
2028  MXFStructuralComponent *component = NULL;
2029  const MXFCodecUL *codec_ul = NULL;
2030  MXFPackage tmp_package;
2031  AVStream *st;
2032  int j;
2033 
2034  for (j = 0; j < track->sequence->structural_components_count; j++) {
2035  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2036  if (!component)
2037  continue;
2038  break;
2039  }
2040  if (!component)
2041  return 0;
2042 
2043  st = avformat_new_stream(mxf->fc, NULL);
2044  if (!st) {
2045  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2046  return AVERROR(ENOMEM);
2047  }
2048 
2051  st->id = track->track_id;
2052 
2053  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2054  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2055  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2056  if (track->name && track->name[0])
2057  av_dict_set(&st->metadata, "track_name", track->name, 0);
2058 
2060  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2061  return 0;
2062 }
2063 
2065 {
2066  MXFPackage *material_package = NULL;
2067  int i, j, k, ret;
2068 
2069  av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2070  /* TODO: handle multiple material packages (OP3x) */
2071  for (i = 0; i < mxf->packages_count; i++) {
2072  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2073  if (material_package) break;
2074  }
2075  if (!material_package) {
2076  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2077  return AVERROR_INVALIDDATA;
2078  }
2079 
2080  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2081  if (material_package->name && material_package->name[0])
2082  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2083  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2084 
2085  for (i = 0; i < material_package->tracks_count; i++) {
2086  MXFPackage *source_package = NULL;
2087  MXFTrack *material_track = NULL;
2088  MXFTrack *source_track = NULL;
2089  MXFTrack *temp_track = NULL;
2090  MXFDescriptor *descriptor = NULL;
2091  MXFStructuralComponent *component = NULL;
2092  MXFTimecodeComponent *mxf_tc = NULL;
2093  UID *essence_container_ul = NULL;
2094  const MXFCodecUL *codec_ul = NULL;
2095  const MXFCodecUL *container_ul = NULL;
2096  const MXFCodecUL *pix_fmt_ul = NULL;
2097  AVStream *st;
2098  AVTimecode tc;
2099  int flags;
2100 
2101  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2102  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2103  continue;
2104  }
2105 
2106  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2107  mxf_tc = (MXFTimecodeComponent*)component;
2108  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2109  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2110  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2111  }
2112  }
2113 
2114  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2115  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2116  continue;
2117  }
2118 
2119  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2120  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2121  if (!component)
2122  continue;
2123 
2124  mxf_tc = (MXFTimecodeComponent*)component;
2125  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2126  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2127  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2128  break;
2129  }
2130  }
2131 
2132  /* TODO: handle multiple source clips, only finds first valid source clip */
2133  if(material_track->sequence->structural_components_count > 1)
2134  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2135  material_track->track_id, material_track->sequence->structural_components_count);
2136 
2137  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2138  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2139  if (!component)
2140  continue;
2141 
2142  source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2143  if (!source_package) {
2144  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2145  continue;
2146  }
2147  for (k = 0; k < source_package->tracks_count; k++) {
2148  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2149  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2150  ret = AVERROR_INVALIDDATA;
2151  goto fail_and_free;
2152  }
2153  if (temp_track->track_id == component->source_track_id) {
2154  source_track = temp_track;
2155  break;
2156  }
2157  }
2158  if (!source_track) {
2159  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2160  break;
2161  }
2162 
2163  for (k = 0; k < mxf->essence_container_data_count; k++) {
2164  MXFEssenceContainerData *essence_data;
2165 
2166  if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2167  av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2168  continue;
2169  }
2170  if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2171  source_track->body_sid = essence_data->body_sid;
2172  source_track->index_sid = essence_data->index_sid;
2173  break;
2174  }
2175  }
2176 
2177  if(source_track && component)
2178  break;
2179  }
2180  if (!source_track || !component || !source_package) {
2181  if((ret = mxf_add_metadata_stream(mxf, material_track)))
2182  goto fail_and_free;
2183  continue;
2184  }
2185 
2186  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2187  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2188  ret = AVERROR_INVALIDDATA;
2189  goto fail_and_free;
2190  }
2191 
2192  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2193  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2194  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2195  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2196  continue;
2197  }
2198 
2199  st = avformat_new_stream(mxf->fc, NULL);
2200  if (!st) {
2201  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2202  ret = AVERROR(ENOMEM);
2203  goto fail_and_free;
2204  }
2205  st->id = material_track->track_id;
2206  st->priv_data = source_track;
2207 
2208  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2209  descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2210 
2211  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2212  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2213  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2214  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2215  else
2216  source_track->original_duration = st->duration = component->duration;
2217 
2218  if (st->duration == -1)
2219  st->duration = AV_NOPTS_VALUE;
2220  st->start_time = component->start_position;
2221  if (material_track->edit_rate.num <= 0 ||
2222  material_track->edit_rate.den <= 0) {
2223  av_log(mxf->fc, AV_LOG_WARNING,
2224  "Invalid edit rate (%d/%d) found on stream #%d, "
2225  "defaulting to 25/1\n",
2226  material_track->edit_rate.num,
2227  material_track->edit_rate.den, st->index);
2228  material_track->edit_rate = (AVRational){25, 1};
2229  }
2230  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2231 
2232  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2233  * the former is accessible via st->priv_data */
2234  source_track->edit_rate = material_track->edit_rate;
2235 
2236  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2238  st->codecpar->codec_type = codec_ul->id;
2239 
2240  if (!descriptor) {
2241  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2242  continue;
2243  }
2244  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2245  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2246  essence_container_ul = &descriptor->essence_container_ul;
2247  source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2248  if (source_track->wrapping == UnknownWrapped)
2249  av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2250  /* HACK: replacing the original key with mxf_encrypted_essence_container
2251  * is not allowed according to s429-6, try to find correct information anyway */
2252  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2253  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2254  for (k = 0; k < mxf->metadata_sets_count; k++) {
2255  MXFMetadataSet *metadata = mxf->metadata_sets[k];
2256  if (metadata->type == CryptoContext) {
2257  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2258  break;
2259  }
2260  }
2261  }
2262 
2263  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2264  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2265  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2266  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2267  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2268  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2269  }
2270 
2271  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2273  for (k = 0; k < 16; k++) {
2274  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2275  descriptor->essence_codec_ul[k]);
2276  if (!(k+1 & 19) || k == 5)
2277  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2278  }
2279  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2280 
2281  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2282  if (source_package->name && source_package->name[0])
2283  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2284  if (material_track->name && material_track->name[0])
2285  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2286 
2287  mxf_parse_physical_source_package(mxf, source_track, st);
2288 
2289  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2290  source_track->intra_only = mxf_is_intra_only(descriptor);
2291  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2292  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2293  st->codecpar->codec_id = container_ul->id;
2294  st->codecpar->width = descriptor->width;
2295  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2296  switch (descriptor->frame_layout) {
2297  case FullFrame:
2299  break;
2300  case OneField:
2301  /* Every other line is stored and needs to be duplicated. */
2302  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2303  break; /* The correct thing to do here is fall through, but by breaking we might be
2304  able to decode some streams at half the vertical resolution, rather than not al all.
2305  It's also for compatibility with the old behavior. */
2306  case MixedFields:
2307  break;
2308  case SegmentedFrame:
2310  case SeparateFields:
2311  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2312  descriptor->video_line_map[0], descriptor->video_line_map[1],
2313  descriptor->field_dominance);
2314  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2315  /* Detect coded field order from VideoLineMap:
2316  * (even, even) => bottom field coded first
2317  * (even, odd) => top field coded first
2318  * (odd, even) => top field coded first
2319  * (odd, odd) => bottom field coded first
2320  */
2321  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2322  switch (descriptor->field_dominance) {
2326  break;
2329  break;
2330  default:
2332  "Field dominance %d support",
2333  descriptor->field_dominance);
2334  }
2335  } else {
2336  switch (descriptor->field_dominance) {
2340  break;
2343  break;
2344  default:
2346  "Field dominance %d support",
2347  descriptor->field_dominance);
2348  }
2349  }
2350  }
2351  /* Turn field height into frame height. */
2352  st->codecpar->height *= 2;
2353  break;
2354  default:
2355  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2356  }
2357  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2358  st->codecpar->format = descriptor->pix_fmt;
2359  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2361  &descriptor->essence_codec_ul);
2362  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2363  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2365  &descriptor->essence_codec_ul)->id;
2366  if (!st->codecpar->codec_tag) {
2367  /* support files created before RP224v10 by defaulting to UYVY422
2368  if subsampling is 4:2:2 and component depth is 8-bit */
2369  if (descriptor->horiz_subsampling == 2 &&
2370  descriptor->vert_subsampling == 1 &&
2371  descriptor->component_depth == 8) {
2373  }
2374  }
2375  }
2376  }
2377  }
2379  if (material_track->sequence->origin) {
2380  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2381  }
2382  if (source_track->sequence->origin) {
2383  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2384  }
2385  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2386  st->display_aspect_ratio = descriptor->aspect_ratio;
2387  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2388  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2389  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2390  if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
2391  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2392  st->codecpar->channels = descriptor->channels;
2393 
2394  if (descriptor->sample_rate.den > 0) {
2395  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2396  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2397  } else {
2398  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2399  "found for stream #%d, time base forced to 1/48000\n",
2400  descriptor->sample_rate.num, descriptor->sample_rate.den,
2401  st->index);
2402  avpriv_set_pts_info(st, 64, 1, 48000);
2403  }
2404 
2405  /* if duration is set, rescale it from EditRate to SampleRate */
2406  if (st->duration != AV_NOPTS_VALUE)
2407  st->duration = av_rescale_q(st->duration,
2408  av_inv_q(material_track->edit_rate),
2409  st->time_base);
2410 
2411  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2412  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2413  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2415  else if (descriptor->bits_per_sample == 32)
2417  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2418  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2420  else if (descriptor->bits_per_sample == 32)
2422  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2424  }
2426  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2427  enum AVMediaType type;
2428  container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2429  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2430  st->codecpar->codec_id = container_ul->id;
2431  type = avcodec_get_type(st->codecpar->codec_id);
2432  if (type == AVMEDIA_TYPE_SUBTITLE)
2433  st->codecpar->codec_type = type;
2434  if (container_ul->desc)
2435  av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2436  }
2437  if (descriptor->extradata) {
2438  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2439  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2440  }
2441  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2442  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2443  &descriptor->essence_codec_ul)->id;
2444  if (coded_width)
2445  st->codecpar->width = coded_width;
2446  ret = ff_generate_avci_extradata(st);
2447  if (ret < 0)
2448  return ret;
2449  }
2450  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2451  /* TODO: decode timestamps */
2453  }
2454  }
2455 
2456  ret = 0;
2457 fail_and_free:
2458  return ret;
2459 }
2460 
2461 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2462 {
2463  struct tm time = { 0 };
2464  time.tm_year = (timestamp >> 48) - 1900;
2465  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2466  time.tm_mday = (timestamp >> 32 & 0xFF);
2467  time.tm_hour = (timestamp >> 24 & 0xFF);
2468  time.tm_min = (timestamp >> 16 & 0xFF);
2469  time.tm_sec = (timestamp >> 8 & 0xFF);
2470 
2471  /* msvcrt versions of strftime calls the invalid parameter handler
2472  * (aborting the process if one isn't set) if the parameters are out
2473  * of range. */
2474  time.tm_mon = av_clip(time.tm_mon, 0, 11);
2475  time.tm_mday = av_clip(time.tm_mday, 1, 31);
2476  time.tm_hour = av_clip(time.tm_hour, 0, 23);
2477  time.tm_min = av_clip(time.tm_min, 0, 59);
2478  time.tm_sec = av_clip(time.tm_sec, 0, 59);
2479 
2480  return (int64_t)av_timegm(&time) * 1000000;
2481 }
2482 
2483 #define SET_STR_METADATA(pb, name, str) do { \
2484  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2485  return ret; \
2486  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2487 } while (0)
2488 
2489 #define SET_UID_METADATA(pb, name, var, str) do { \
2490  avio_read(pb, var, 16); \
2491  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2492  return ret; \
2493  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2494 } while (0)
2495 
2496 #define SET_TS_METADATA(pb, name, var, str) do { \
2497  var = avio_rb64(pb); \
2498  if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2499  return ret; \
2500 } while (0)
2501 
2502 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2503 {
2504  MXFContext *mxf = arg;
2505  AVFormatContext *s = mxf->fc;
2506  int ret;
2507  UID uid = { 0 };
2508  char *str = NULL;
2509  uint64_t ts;
2510  switch (tag) {
2511  case 0x3C01:
2512  SET_STR_METADATA(pb, "company_name", str);
2513  break;
2514  case 0x3C02:
2515  SET_STR_METADATA(pb, "product_name", str);
2516  break;
2517  case 0x3C04:
2518  SET_STR_METADATA(pb, "product_version", str);
2519  break;
2520  case 0x3C05:
2521  SET_UID_METADATA(pb, "product_uid", uid, str);
2522  break;
2523  case 0x3C06:
2524  SET_TS_METADATA(pb, "modification_date", ts, str);
2525  break;
2526  case 0x3C08:
2527  SET_STR_METADATA(pb, "application_platform", str);
2528  break;
2529  case 0x3C09:
2530  SET_UID_METADATA(pb, "generation_uid", uid, str);
2531  break;
2532  case 0x3C0A:
2533  SET_UID_METADATA(pb, "uid", uid, str);
2534  break;
2535  }
2536  return 0;
2537 }
2538 
2539 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2540 {
2541  MXFContext *mxf = arg;
2542  AVFormatContext *s = mxf->fc;
2543  int ret;
2544  char *str = NULL;
2545 
2546  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2547  SET_STR_METADATA(pb, "project_name", str);
2548  }
2549  return 0;
2550 }
2551 
2553  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2554  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2555  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2556  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2557  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2558  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2559  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2560  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2561  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2562  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2563  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2564  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2565  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2566  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2567  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2568  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2569  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2570  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2571  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2572  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2573  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2574  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Generic Sound */
2575  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2576  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2577  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2578  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2579  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2580  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VBI - SMPTE 436M */
2581  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VANC/VBI - SMPTE 436M */
2582  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2583  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* DC Timed Text Descriptor */
2584  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2585  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2586  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2587  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2588  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2589  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2590  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2591  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2592 };
2593 
2595 {
2596  switch (type){
2597  case MultipleDescriptor:
2598  case Descriptor:
2599  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2600  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2601  break;
2602  default:
2603  break;
2604  }
2605  return 0;
2606 }
2607 
2608 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2609 {
2610  AVIOContext *pb = mxf->fc->pb;
2611  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2612  uint64_t klv_end = avio_tell(pb) + klv->length;
2613 
2614  if (!ctx)
2615  return AVERROR(ENOMEM);
2616  mxf_metadataset_init(ctx, type);
2617  while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2618  int ret;
2619  int tag = avio_rb16(pb);
2620  int size = avio_rb16(pb); /* KLV specified by 0x53 */
2621  uint64_t next = avio_tell(pb) + size;
2622  UID uid = {0};
2623 
2624  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2625  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2626  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2627  continue;
2628  }
2629  if (tag > 0x7FFF) { /* dynamic tag */
2630  int i;
2631  for (i = 0; i < mxf->local_tags_count; i++) {
2632  int local_tag = AV_RB16(mxf->local_tags+i*18);
2633  if (local_tag == tag) {
2634  memcpy(uid, mxf->local_tags+i*18+2, 16);
2635  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2636  PRINT_KEY(mxf->fc, "uid", uid);
2637  }
2638  }
2639  }
2640  if (ctx_size && tag == 0x3C0A) {
2641  avio_read(pb, ctx->uid, 16);
2642  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2643  if (ctx_size)
2644  mxf_free_metadataset(&ctx, 1);
2645  return ret;
2646  }
2647 
2648  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2649  * it extending past the end of the KLV though (zzuf5.mxf). */
2650  if (avio_tell(pb) > klv_end) {
2651  if (ctx_size) {
2652  ctx->type = type;
2653  mxf_free_metadataset(&ctx, 1);
2654  }
2655 
2656  av_log(mxf->fc, AV_LOG_ERROR,
2657  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2658  tag, klv->offset);
2659  return AVERROR_INVALIDDATA;
2660  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2661  avio_seek(pb, next, SEEK_SET);
2662  }
2663  if (ctx_size) ctx->type = type;
2664  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2665 }
2666 
2667 /**
2668  * Matches any partition pack key, in other words:
2669  * - HeaderPartition
2670  * - BodyPartition
2671  * - FooterPartition
2672  * @return non-zero if the key is a partition pack key, zero otherwise
2673  */
2675 {
2676  //NOTE: this is a little lax since it doesn't constraint key[14]
2677  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2678  key[13] >= 2 && key[13] <= 4;
2679 }
2680 
2681 /**
2682  * Parses a metadata KLV
2683  * @return <0 on error, 0 otherwise
2684  */
2686  int ctx_size, enum MXFMetadataSetType type)
2687 {
2688  AVFormatContext *s = mxf->fc;
2689  int res;
2690  if (klv.key[5] == 0x53) {
2691  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2692  } else {
2693  uint64_t next = avio_tell(s->pb) + klv.length;
2694  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2695 
2696  /* only seek forward, else this can loop for a long time */
2697  if (avio_tell(s->pb) > next) {
2698  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2699  klv.offset);
2700  return AVERROR_INVALIDDATA;
2701  }
2702 
2703  avio_seek(s->pb, next, SEEK_SET);
2704  }
2705  if (res < 0) {
2706  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2707  return res;
2708  }
2709  return 0;
2710 }
2711 
2712 /**
2713  * Seeks to the previous partition and parses it, if possible
2714  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2715  */
2717 {
2718  AVIOContext *pb = mxf->fc->pb;
2719  KLVPacket klv;
2720  int64_t current_partition_ofs;
2721  int ret;
2722 
2723  if (!mxf->current_partition ||
2725  return 0; /* we've parsed all partitions */
2726 
2727  /* seek to previous partition */
2728  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2729  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2730  mxf->current_partition = NULL;
2731 
2732  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2733 
2734  /* Make sure this is actually a PartitionPack, and if so parse it.
2735  * See deadlock2.mxf
2736  */
2737  if ((ret = klv_read_packet(&klv, pb)) < 0) {
2738  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2739  return ret;
2740  }
2741 
2742  if (!mxf_is_partition_pack_key(klv.key)) {
2743  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2744  return AVERROR_INVALIDDATA;
2745  }
2746 
2747  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2748  * can point to just before the current partition, causing klv_read_packet()
2749  * to sync back up to it. See deadlock3.mxf
2750  */
2751  if (klv.offset >= current_partition_ofs) {
2752  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2753  PRIx64 " indirectly points to itself\n", current_partition_ofs);
2754  return AVERROR_INVALIDDATA;
2755  }
2756 
2757  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2758  return ret;
2759 
2760  return 1;
2761 }
2762 
2763 /**
2764  * Called when essence is encountered
2765  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2766  */
2768 {
2769  AVIOContext *pb = mxf->fc->pb;
2770  int64_t ret;
2771 
2772  if (mxf->parsing_backward) {
2773  return mxf_seek_to_previous_partition(mxf);
2774  } else {
2775  if (!mxf->footer_partition) {
2776  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2777  return 0;
2778  }
2779 
2780  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2781 
2782  /* remember where we were so we don't end up seeking further back than this */
2783  mxf->last_forward_tell = avio_tell(pb);
2784 
2785  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2786  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2787  return -1;
2788  }
2789 
2790  /* seek to FooterPartition and parse backward */
2791  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2792  av_log(mxf->fc, AV_LOG_ERROR,
2793  "failed to seek to FooterPartition @ 0x%" PRIx64
2794  " (%"PRId64") - partial file?\n",
2795  mxf->run_in + mxf->footer_partition, ret);
2796  return ret;
2797  }
2798 
2799  mxf->current_partition = NULL;
2800  mxf->parsing_backward = 1;
2801  }
2802 
2803  return 1;
2804 }
2805 
2806 /**
2807  * Called when the next partition or EOF is encountered
2808  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2809  */
2811 {
2812  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2813 }
2814 
2816 {
2817  for (int i = 0; i < s->nb_streams; i++) {
2818  MXFTrack *track = s->streams[i]->priv_data;
2819  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2820  return track->wrapping;
2821  }
2822  return UnknownWrapped;
2823 }
2824 
2825 /**
2826  * Figures out the proper offset and length of the essence container in each partition
2827  */
2829 {
2830  MXFContext *mxf = s->priv_data;
2831  int x;
2832 
2833  for (x = 0; x < mxf->partitions_count; x++) {
2834  MXFPartition *p = &mxf->partitions[x];
2835  MXFWrappingScheme wrapping;
2836 
2837  if (!p->body_sid)
2838  continue; /* BodySID == 0 -> no essence */
2839 
2840  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2841  * otherwise we point essence_offset at the key of the first essence KLV.
2842  */
2843 
2844  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2845 
2846  if (wrapping == ClipWrapped) {
2849  } else {
2851 
2852  /* essence container spans to the next partition */
2853  if (x < mxf->partitions_count - 1)
2855 
2856  if (p->essence_length < 0) {
2857  /* next ThisPartition < essence_offset */
2858  p->essence_length = 0;
2859  av_log(mxf->fc, AV_LOG_ERROR,
2860  "partition %i: bad ThisPartition = %"PRIX64"\n",
2861  x+1, mxf->partitions[x+1].this_partition);
2862  }
2863  }
2864  }
2865 }
2866 
2867 static int is_pcm(enum AVCodecID codec_id)
2868 {
2869  /* we only care about "normal" PCM codecs until we get samples */
2870  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2871 }
2872 
2873 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
2874 {
2875  int i;
2876  for (i = 0; i < mxf->nb_index_tables; i++)
2877  if (mxf->index_tables[i].index_sid == index_sid)
2878  return &mxf->index_tables[i];
2879  return NULL;
2880 }
2881 
2882 /**
2883  * Deal with the case where for some audio atoms EditUnitByteCount is
2884  * very small (2, 4..). In those cases we should read more than one
2885  * sample per call to mxf_read_packet().
2886  */
2888 {
2889  MXFTrack *track = st->priv_data;
2890  MXFIndexTable *t;
2891 
2892  if (!track)
2893  return;
2894  track->edit_units_per_packet = 1;
2895  if (track->wrapping != ClipWrapped)
2896  return;
2897 
2898  t = mxf_find_index_table(mxf, track->index_sid);
2899 
2900  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2901  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
2902  !is_pcm(st->codecpar->codec_id) ||
2903  !t ||
2904  t->nb_segments != 1 ||
2905  t->segments[0]->edit_unit_byte_count >= 32)
2906  return;
2907 
2908  /* arbitrarily default to 48 kHz PAL audio frame size */
2909  /* TODO: We could compute this from the ratio between the audio
2910  * and video edit rates for 48 kHz NTSC we could use the
2911  * 1802-1802-1802-1802-1801 pattern. */
2912  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2913 }
2914 
2915 /**
2916  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
2917  */
2919 {
2920  MXFTrack *track = st->priv_data;
2922  MXFPartition *p = NULL;
2923  int essence_partition_count = 0;
2924  int edit_unit_byte_count = 0;
2925  int i, ret;
2926 
2927  if (!track || track->wrapping != ClipWrapped)
2928  return 0;
2929 
2930  /* check if track already has an IndexTableSegment */
2931  for (i = 0; i < mxf->metadata_sets_count; i++) {
2932  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
2934  if (s->body_sid == track->body_sid)
2935  return 0;
2936  }
2937  }
2938 
2939  /* find the essence partition */
2940  for (i = 0; i < mxf->partitions_count; i++) {
2941  /* BodySID == 0 -> no essence */
2942  if (mxf->partitions[i].body_sid != track->body_sid)
2943  continue;
2944 
2945  p = &mxf->partitions[i];
2946  essence_partition_count++;
2947  }
2948 
2949  /* only handle files with a single essence partition */
2950  if (essence_partition_count != 1)
2951  return 0;
2952 
2954  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2955  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
2956  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
2957  }
2958 
2959  if (edit_unit_byte_count <= 0)
2960  return 0;
2961 
2962  av_log(mxf->fc, AV_LOG_WARNING, "guessing index for stream %d using edit unit byte count %d\n", st->index, edit_unit_byte_count);
2963 
2964  if (!(segment = av_mallocz(sizeof(*segment))))
2965  return AVERROR(ENOMEM);
2966 
2967  if ((ret = mxf_add_metadata_set(mxf, segment))) {
2968  mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2969  return ret;
2970  }
2971 
2972  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
2973  * using the same SID for index is forbidden in MXF. */
2974  if (!track->index_sid)
2975  track->index_sid = track->body_sid;
2976 
2977  segment->type = IndexTableSegment;
2978  /* stream will be treated as small EditUnitByteCount */
2979  segment->edit_unit_byte_count = edit_unit_byte_count;
2980  segment->index_start_position = 0;
2981  segment->index_duration = st->duration;
2982  segment->index_edit_rate = av_inv_q(st->time_base);
2983  segment->index_sid = track->index_sid;
2984  segment->body_sid = p->body_sid;
2985  return 0;
2986 }
2987 
2989 {
2990  MXFContext *mxf = s->priv_data;
2991  uint32_t length;
2992  int64_t file_size, max_rip_length, min_rip_length;
2993  KLVPacket klv;
2994 
2995  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2996  return;
2997 
2998  file_size = avio_size(s->pb);
2999 
3000  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3001  * The limit below assumes a file with nothing but partition packs and a RIP.
3002  * Before changing this, consider that a muxer may place each sample in its own partition.
3003  *
3004  * 105 is the size of the smallest possible PartitionPack
3005  * 12 is the size of each RIP entry
3006  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3007  */
3008  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3009  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3010 
3011  /* We're only interested in RIPs with at least two entries.. */
3012  min_rip_length = 16+1+24+4;
3013 
3014  /* See S377m section 11 */
3015  avio_seek(s->pb, file_size - 4, SEEK_SET);
3016  length = avio_rb32(s->pb);
3017 
3018  if (length < min_rip_length || length > max_rip_length)
3019  goto end;
3020  avio_seek(s->pb, file_size - length, SEEK_SET);
3021  if (klv_read_packet(&klv, s->pb) < 0 ||
3023  klv.length != length - 20)
3024  goto end;
3025 
3026  avio_skip(s->pb, klv.length - 12);
3027  mxf->footer_partition = avio_rb64(s->pb);
3028 
3029  /* sanity check */
3030  if (mxf->run_in + mxf->footer_partition >= file_size) {
3031  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3032  mxf->footer_partition = 0;
3033  }
3034 
3035 end:
3036  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3037 }
3038 
3040 {
3041  MXFContext *mxf = s->priv_data;
3042  KLVPacket klv;
3043  int64_t essence_offset = 0;
3044  int ret;
3045 
3046  mxf->last_forward_tell = INT64_MAX;
3047 
3049  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3050  return AVERROR_INVALIDDATA;
3051  }
3052  avio_seek(s->pb, -14, SEEK_CUR);
3053  mxf->fc = s;
3054  mxf->run_in = avio_tell(s->pb);
3055 
3057 
3058  while (!avio_feof(s->pb)) {
3059  const MXFMetadataReadTableEntry *metadata;
3060 
3061  if (klv_read_packet(&klv, s->pb) < 0) {
3062  /* EOF - seek to previous partition or stop */
3063  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3064  break;
3065  else
3066  continue;
3067  }
3068 
3069  PRINT_KEY(s, "read header", klv.key);
3070  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3077 
3078  if (!mxf->current_partition) {
3079  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3080  return AVERROR_INVALIDDATA;
3081  }
3082 
3085 
3086  if (!essence_offset)
3087  essence_offset = klv.offset;
3088 
3089  /* seek to footer, previous partition or stop */
3090  if (mxf_parse_handle_essence(mxf) <= 0)
3091  break;
3092  continue;
3093  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3094  /* next partition pack - keep going, seek to previous partition or stop */
3095  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3096  break;
3097  else if (mxf->parsing_backward)
3098  continue;
3099  /* we're still parsing forward. proceed to parsing this partition pack */
3100  }
3101 
3102  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3103  if (IS_KLV_KEY(klv.key, metadata->key)) {
3104  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3105  goto fail;
3106  break;
3107  }
3108  }
3109  if (!metadata->read) {
3110  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3111  UID_ARG(klv.key));
3112  avio_skip(s->pb, klv.length);
3113  }
3114  }
3115  /* FIXME avoid seek */
3116  if (!essence_offset) {
3117  av_log(s, AV_LOG_ERROR, "no essence\n");
3118  ret = AVERROR_INVALIDDATA;
3119  goto fail;
3120  }
3121  avio_seek(s->pb, essence_offset, SEEK_SET);
3122 
3123  /* we need to do this before computing the index tables
3124  * to be able to fill in zero IndexDurations with st->duration */
3125  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3126  goto fail;
3127 
3128  for (int i = 0; i < s->nb_streams; i++)
3130 
3131  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3132  goto fail;
3133 
3134  if (mxf->nb_index_tables > 1) {
3135  /* TODO: look up which IndexSID to use via EssenceContainerData */
3136  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3137  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3138  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3139  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3140  ret = AVERROR_INVALIDDATA;
3141  goto fail;
3142  }
3143 
3145 
3146  for (int i = 0; i < s->nb_streams; i++)
3148 
3149  return 0;
3150 fail:
3151  mxf_read_close(s);
3152 
3153  return ret;
3154 }
3155 
3156 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3157 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3158 {
3159  int64_t a, b, m, offset;
3160  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3161 
3162  if (!t || track->original_duration <= 0)
3163  return -1;
3164 
3165  a = -1;
3166  b = track->original_duration;
3167 
3168  while (b - a > 1) {
3169  m = (a + b) >> 1;
3170  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3171  return -1;
3172  if (offset < current_offset)
3173  a = m;
3174  else
3175  b = m;
3176  }
3177 
3178  *edit_unit_out = b;
3179 
3180  return 0;
3181 }
3182 
3184  int64_t edit_unit)
3185 {
3186  int i, total = 0, size = 0;
3187  MXFTrack *track = st->priv_data;
3188  AVRational time_base = av_inv_q(track->edit_rate);
3190  const MXFSamplesPerFrame *spf = NULL;
3191  int64_t sample_count;
3192 
3193  // For non-audio sample_count equals current edit unit
3195  return edit_unit;
3196 
3197  if ((sample_rate.num / sample_rate.den) == 48000)
3198  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3199  if (!spf) {
3200  int remainder = (sample_rate.num * time_base.num) %
3201  (time_base.den * sample_rate.den);
3202  if (remainder)
3203  av_log(mxf->fc, AV_LOG_WARNING,
3204  "seeking detected on stream #%d with time base (%d/%d) and "
3205  "sample rate (%d/%d), audio pts won't be accurate.\n",
3206  st->index, time_base.num, time_base.den,
3207  sample_rate.num, sample_rate.den);
3208  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3209  }
3210 
3211  while (spf->samples_per_frame[size]) {
3212  total += spf->samples_per_frame[size];
3213  size++;
3214  }
3215 
3216  av_assert2(size);
3217 
3218  sample_count = (edit_unit / size) * (uint64_t)total;
3219  for (i = 0; i < edit_unit % size; i++) {
3220  sample_count += spf->samples_per_frame[i];
3221  }
3222 
3223  return sample_count;
3224 }
3225 
3226 /**
3227  * Make sure track->sample_count is correct based on what offset we're currently at.
3228  * Also determine the next edit unit (or packet) offset.
3229  * @return next_ofs if OK, <0 on error
3230  */
3231 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3232 {
3233  int64_t next_ofs = -1;
3234  MXFTrack *track = st->priv_data;
3235  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3236  int64_t new_edit_unit;
3237  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3238 
3239  if (!t || track->wrapping == UnknownWrapped)
3240  return -1;
3241 
3242  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3243  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3244  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3245  return -1;
3246  }
3247 
3248  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3249  if (next_ofs > current_offset)
3250  return next_ofs;
3251 
3252  if (!resync) {
3253  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3254  return -1;
3255  }
3256 
3257  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3258  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3259  return -1;
3260  }
3261 
3262  new_edit_unit--;
3263  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3264  av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
3265 
3266  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3267 }
3268 
3270  AVPacket *pkt)
3271 {
3272  AVStream *st = mxf->fc->streams[pkt->stream_index];
3273  MXFTrack *track = st->priv_data;
3274  int64_t bits_per_sample = par->bits_per_coded_sample;
3275 
3276  if (!bits_per_sample)
3277  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3278 
3279  pkt->pts = track->sample_count;
3280 
3281  if ( par->channels <= 0
3282  || bits_per_sample <= 0
3283  || par->channels * (int64_t)bits_per_sample < 8)
3284  track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
3285  else
3286  track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3287 
3288  return 0;
3289 }
3290 
3291 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3292 {
3293  AVCodecParameters *par = st->codecpar;
3294  MXFTrack *track = st->priv_data;
3295 
3296  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3297  /* see if we have an index table to derive timestamps from */
3298  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3299 
3300  if (t && track->sample_count < t->nb_ptses) {
3301  pkt->dts = track->sample_count + t->first_dts;
3302  pkt->pts = t->ptses[track->sample_count];
3303  } else if (track->intra_only) {
3304  /* intra-only -> PTS = EditUnit.
3305  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3306  pkt->pts = track->sample_count;
3307  }
3308  track->sample_count++;
3309  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3310  int ret = mxf_set_audio_pts(mxf, par, pkt);
3311  if (ret < 0)
3312  return ret;
3313  } else if (track) {
3314  track->sample_count++;
3315  }
3316  return 0;
3317 }
3318 
3320 {
3321  KLVPacket klv;
3322  MXFContext *mxf = s->priv_data;
3323  int ret;
3324 
3325  while (1) {
3326  int64_t max_data_size;
3327  int64_t pos = avio_tell(s->pb);
3328 
3329  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3330  mxf->current_klv_data = (KLVPacket){{0}};
3331  ret = klv_read_packet(&klv, s->pb);
3332  if (ret < 0)
3333  break;
3334  max_data_size = klv.length;
3335  pos = klv.next_klv - klv.length;
3336  PRINT_KEY(s, "read packet", klv.key);
3337  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3339  ret = mxf_decrypt_triplet(s, pkt, &klv);
3340  if (ret < 0) {
3341  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3342  return ret;
3343  }
3344  return 0;
3345  }
3346  } else {
3347  klv = mxf->current_klv_data;
3348  max_data_size = klv.next_klv - pos;
3349  }
3353  int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3354  int index = mxf_get_stream_index(s, &klv, body_sid);
3355  int64_t next_ofs;
3356  AVStream *st;
3357  MXFTrack *track;
3358 
3359  if (index < 0) {
3360  av_log(s, AV_LOG_ERROR,
3361  "error getting stream index %"PRIu32"\n",
3362  AV_RB32(klv.key + 12));
3363  goto skip;
3364  }
3365 
3366  st = s->streams[index];
3367  track = st->priv_data;
3368 
3369  if (s->streams[index]->discard == AVDISCARD_ALL)
3370  goto skip;
3371 
3372  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3373 
3374  if (track->wrapping != FrameWrapped) {
3375  int64_t size;
3376 
3377  if (next_ofs <= 0) {
3378  // If we have no way to packetize the data, then return it in chunks...
3379  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3381  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3382  }
3383  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3384  } else {
3385  if ((size = next_ofs - pos) <= 0) {
3386  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3387  ret = AVERROR_INVALIDDATA;
3388  goto skip;
3389  }
3390  // We must not overread, because the next edit unit might be in another KLV
3391  if (size > max_data_size)
3392  size = max_data_size;
3393  }
3394 
3395  mxf->current_klv_data = klv;
3396  klv.offset = pos;
3397  klv.length = size;
3398  klv.next_klv = klv.offset + klv.length;
3399  }
3400 
3401  /* check for 8 channels AES3 element */
3402  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3403  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3404  pkt, klv.length);
3405  if (ret < 0) {
3406  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3407  mxf->current_klv_data = (KLVPacket){{0}};
3408  return ret;
3409  }
3410  } else {
3411  ret = av_get_packet(s->pb, pkt, klv.length);
3412  if (ret < 0) {
3413  mxf->current_klv_data = (KLVPacket){{0}};
3414  return ret;
3415  }
3416  }
3417  pkt->stream_index = index;
3418  pkt->pos = klv.offset;
3419 
3420  ret = mxf_set_pts(mxf, st, pkt);
3421  if (ret < 0) {
3422  mxf->current_klv_data = (KLVPacket){{0}};
3423  return ret;
3424  }
3425 
3426  /* seek for truncated packets */
3427  avio_seek(s->pb, klv.next_klv, SEEK_SET);
3428 
3429  return 0;
3430  } else {
3431  skip:
3432  avio_skip(s->pb, max_data_size);
3433  mxf->current_klv_data = (KLVPacket){{0}};
3434  }
3435  }
3436  return avio_feof(s->pb) ? AVERROR_EOF : ret;
3437 }
3438 
3440 {
3441  MXFContext *mxf = s->priv_data;
3442  int i;
3443 
3444  av_freep(&mxf->packages_refs);
3446 
3447  for (i = 0; i < s->nb_streams; i++)
3448  s->streams[i]->priv_data = NULL;
3449 
3450  for (i = 0; i < mxf->metadata_sets_count; i++) {
3451  mxf_free_metadataset(mxf->metadata_sets + i, 1);
3452  }
3453  av_freep(&mxf->partitions);
3454  av_freep(&mxf->metadata_sets);
3455  av_freep(&mxf->aesc);
3456  av_freep(&mxf->local_tags);
3457 
3458  if (mxf->index_tables) {
3459  for (i = 0; i < mxf->nb_index_tables; i++) {
3460  av_freep(&mxf->index_tables[i].segments);
3461  av_freep(&mxf->index_tables[i].ptses);
3462  av_freep(&mxf->index_tables[i].fake_index);
3463  av_freep(&mxf->index_tables[i].offsets);
3464  }
3465  }
3466  av_freep(&mxf->index_tables);
3467 
3468  return 0;
3469 }
3470 
3471 static int mxf_probe(AVProbeData *p) {
3472  const uint8_t *bufp = p->buf;
3473  const uint8_t *end = p->buf + p->buf_size;
3474 
3475  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3476  return 0;
3477 
3478  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3479  end -= sizeof(mxf_header_partition_pack_key);
3480 
3481  for (; bufp < end;) {
3482  if (!((bufp[13] - 1) & 0xF2)){
3483  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3484  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3485  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3487  return AVPROBE_SCORE_MAX;
3488  bufp ++;
3489  } else
3490  bufp += 10;
3491  }
3492 
3493  return 0;
3494 }
3495 
3496 /* rudimentary byte seek */
3497 /* XXX: use MXF Index */
3498 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3499 {
3500  AVStream *st = s->streams[stream_index];
3501  int64_t seconds;
3502  MXFContext* mxf = s->priv_data;
3503  int64_t seekpos;
3504  int i, ret;
3505  MXFIndexTable *t;
3506  MXFTrack *source_track = st->priv_data;
3507 
3508  if (!source_track)
3509  return 0;
3510 
3511  /* if audio then truncate sample_time to EditRate */
3513  sample_time = av_rescale_q(sample_time, st->time_base,
3514  av_inv_q(source_track->edit_rate));
3515 
3516  if (mxf->nb_index_tables <= 0) {
3517  if (!s->bit_rate)
3518  return AVERROR_INVALIDDATA;
3519  if (sample_time < 0)
3520  sample_time = 0;
3521  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3522 
3523  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3524  if (seekpos < 0)
3525  return seekpos;
3526 
3527  ff_update_cur_dts(s, st, sample_time);
3528  mxf->current_klv_data = (KLVPacket){{0}};
3529  } else {
3530  MXFPartition *partition;
3531 
3532  t = &mxf->index_tables[0];
3533  if (t->index_sid != source_track->index_sid) {
3534  /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3535  for (i = 0; i < s->nb_streams; i++) {
3536  MXFTrack *new_source_track = s->streams[i]->priv_data;
3537  if (new_source_track && new_source_track->index_sid == t->index_sid) {
3538  sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3539  source_track = new_source_track;
3540  st = s->streams[i];
3541  break;
3542  }
3543  }
3544  if (i == s->nb_streams)
3545  return AVERROR_INVALIDDATA;
3546  }
3547 
3548  /* clamp above zero, else ff_index_search_timestamp() returns negative
3549  * this also means we allow seeking before the start */
3550  sample_time = FFMAX(sample_time, 0);
3551 
3552  if (t->fake_index) {
3553  /* The first frames may not be keyframes in presentation order, so
3554  * we have to advance the target to be able to find the first
3555  * keyframe backwards... */
3556  if (!(flags & AVSEEK_FLAG_ANY) &&
3557  (flags & AVSEEK_FLAG_BACKWARD) &&
3558  t->ptses[0] != AV_NOPTS_VALUE &&
3559  sample_time < t->ptses[0] &&
3560  (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3561  sample_time = t->ptses[0];
3562 
3563  /* behave as if we have a proper index */
3564  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3565  return sample_time;
3566  /* get the stored order index from the display order index */
3567  sample_time += t->offsets[sample_time];
3568  } else {
3569  /* no IndexEntryArray (one or more CBR segments)
3570  * make sure we don't seek past the end */
3571  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3572  }
3573 
3574  if (source_track->wrapping == UnknownWrapped)
3575  av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3576 
3577  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3578  return ret;
3579 
3580  ff_update_cur_dts(s, st, sample_time);
3581  if (source_track->wrapping == ClipWrapped) {
3582  KLVPacket klv = partition->first_essence_klv;
3583  if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3584  av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3585  return AVERROR_INVALIDDATA;
3586  }
3587  mxf->current_klv_data = klv;
3588  } else {
3589  mxf->current_klv_data = (KLVPacket){{0}};
3590  }
3591  avio_seek(s->pb, seekpos, SEEK_SET);
3592  }
3593 
3594  // Update all tracks sample count
3595  for (i = 0; i < s->nb_streams; i++) {
3596  AVStream *cur_st = s->streams[i];
3597  MXFTrack *cur_track = cur_st->priv_data;
3598  if (cur_track) {
3599  int64_t track_edit_unit = sample_time;
3600  if (st != cur_st)
3601  mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3602  cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3603  }
3604  }
3605  return 0;
3606 }
3607 
3609  .name = "mxf",
3610  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3611  .flags = AVFMT_SEEK_TO_PTS,
3612  .priv_data_size = sizeof(MXFContext),
3613  .read_probe = mxf_probe,
3618 };
static const uint8_t mxf_crypto_source_container_ul[]
Definition: mxfdec.c:313
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:568
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
enum MXFMetadataSetType type
Definition: mxfdec.c:165
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2504
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:795
const char const char void * val
Definition: avisynth_c.h:771
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:2064
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:3980
MXFMetadataSetType
Definition: mxf.h:30
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
uint8_t origin
Definition: mxfdec.c:130
unsigned int component_depth
Definition: mxfdec.c:200
KLVPacket current_klv_data
Definition: mxfdec.c:282
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1007
Definition: mxf.h:39
int index_sid
Definition: mxfdec.c:175
AVTimecode tc
Definition: mxfdec.c:139
UID * comment_refs
Definition: mxfdec.c:236
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
Definition: mxfdec.c:2552
int structural_components_count
Definition: mxfdec.c:152
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:126
int index_sid
Definition: mxfdec.c:256
static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
Definition: mxfdec.c:396
UID * structural_components_refs
Definition: mxfdec.c:127
enum MXFMetadataSetType type
Definition: mxfdec.c:242
MXFOP
Definition: mxfdec.c:67
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition and parses it, if possible.
Definition: mxfdec.c:2716
int edit_unit_byte_count
Definition: mxfdec.c:214
enum MXFMetadataSetType type
Definition: mxfdec.c:114
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1464
static int mxf_probe(AVProbeData *p)
Definition: mxfdec.c:3471
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:101
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4849
int64_t * ptses
Definition: mxfdec.c:260
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2506
UID * structural_components_refs
Definition: mxfdec.c:151
UID sequence_ref
Definition: mxfdec.c:167
static void mxf_read_random_index_pack(AVFormatContext *s)
Definition: mxfdec.c:2988
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3899
#define MXF_MAX_CHUNK_SIZE
Definition: mxfdec.c:59
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:875
#define SET_TS_METADATA(pb, name, var, str)
Definition: mxfdec.c:2496
int size
Definition: avcodec.h:1445
Definition: mxf.h:34
uint64_t footer_partition
Definition: mxfdec.c:281
const char * b
Definition: vf_curves.c:113
int closed
Definition: mxfdec.c:88
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
enum MXFMetadataSetType type
Definition: mxfdec.c:299
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: aes.c:163
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mxfdec.c:3498
static int mxf_uid_to_str(UID uid, char **str)
Definition: mxfdec.c:1767
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1473
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
Definition: mxfdec.c:453
MXFSequence * sequence
Definition: mxfdec.c:166
#define tc
Definition: regdef.h:69
int linked_track_id
Definition: mxfdec.c:205
UID key
Definition: mxf.h:62
static int mxf_umid_to_str(UID ul, UID uid, char **str)
Definition: mxfdec.c:1785
int64_t offset
Definition: mxf.h:63
void * priv_data
Definition: avformat.h:889
static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
Deal with the case where for some audio atoms EditUnitByteCount is very small (2, 4...
Definition: mxfdec.c:2887
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
MXFWrappingScheme wrapping
Definition: mxfdec.c:177
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
char * name
Definition: mxfdec.c:159
discard all
Definition: avcodec.h:802
static AVPacket pkt
#define MXF_FIELD_DOMINANCE_DEFAULT
Definition: mxfdec.c:193
Definition: mxfdec.c:74
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:2047
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:786
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition: mxfdec.c:1759
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
#define sample
static int mxf_read_header(AVFormatContext *s)
Definition: mxfdec.c:3039
UID source_container_ul
Definition: mxfdec.c:109
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
int id
Definition: mxf.h:78
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3891
static int find_body_sid_by_offset(MXFContext *mxf, int64_t offset)
Definition: mxfdec.c:429
Definition: mxf.h:72
static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:958
int edit_units_per_packet
Definition: mxfdec.c:178
static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read, int ctx_size, enum MXFMetadataSetType type)
Parses a metadata KLV.
Definition: mxfdec.c:2685
MXFWrappingIndicatorType wrapping_indicator_type
Definition: mxf.h:81
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
Definition: mxfdec.c:1481
enum MXFMetadataSetType type
Definition: mxfdec.c:183
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function...
Definition: dict.h:73
Definition: mxfdec.c:73
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
Definition: mxfdec.c:2810
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition: mxfdec.c:2608
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:3319
Format I/O context.
Definition: avformat.h:1351
Definition: mxfdec.c:71
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:2867
uint8_t UID[16]
Definition: mxf.h:28
int frame_layout
Definition: mxfdec.c:191
UID uid
Definition: mxfenc.c:2165
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1952
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfdec.c:320
Definition: mxfdec.c:64
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
UID * packages_refs
Definition: mxfdec.c:271
#define MXF_FIELD_DOMINANCE_FF
Definition: mxfdec.c:194
uint8_t
UID * tracks_refs
Definition: mxfdec.c:231
#define av_malloc(s)
int64_t first_dts
Definition: mxfdec.c:259
const MXFSamplesPerFrame * ff_mxf_get_samples_per_frame(AVFormatContext *s, AVRational time_base)
Definition: mxf.c:154
Opaque data information usually continuous.
Definition: avutil.h:203
static const uint8_t mxf_avid_essence_element_key[]
Definition: mxfdec.c:307
int bits_per_sample
Definition: mxfdec.c:198
int width
Video only.
Definition: avcodec.h:3965
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:801
timecode is drop frame
Definition: timecode.h:36
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVRational index_edit_rate
Definition: mxfdec.c:217
enum AVStreamParseType need_parsing
Definition: avformat.h:1092
int id
Format-specific stream ID.
Definition: avformat.h:881
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:3439
Definition: mxf.h:61
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4456
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
Definition: mxfdec.c:1806
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
unsigned wrapping_indicator_pos
Definition: mxf.h:80
#define UID_ARG(x)
Definition: mxf.h:103
int complete
Definition: mxfdec.c:89
static const uint8_t mxf_klv_key[]
Definition: mxfdec.c:311
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:293
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
Definition: mxfdec.c:1651
MXFIndexTableSegment ** segments
Definition: mxfdec.c:262
const MXFCodecUL ff_mxf_codec_uls[]
Definition: mxf.c:36
uint8_t * data
Definition: avcodec.h:1444
static const uint8_t mxf_sony_mpeg4_extradata[]
Definition: mxfdec.c:317
uint32_t tag
Definition: movenc.c:1483
#define AVERROR_EOF
End of file.
Definition: error.h:55
static const uint8_t mxf_avid_project_name[]
Definition: mxfdec.c:318
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
Definition: mxfdec.c:69
Definition: ismindex.c:69
ptrdiff_t size
Definition: opengl_enc.c:101
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str, int be)
Definition: mxfdec.c:775
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:922
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define flags(name, subs,...)
Definition: cbs_h2645.c:263
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition: mxfdec.c:1258
unsigned int vert_subsampling
Definition: mxfdec.c:202
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
int intra_only
Definition: mxfdec.c:172
#define MXF_FIELD_DOMINANCE_FL
Definition: mxfdec.c:195
#define av_log(a,...)
int32_t kag_size
Definition: mxfdec.c:97
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:648
static const uint8_t mxf_random_index_pack_key[]
Definition: mxfdec.c:316
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
Definition: mxfdec.c:1330
static MXFDescriptor * mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
Definition: mxfdec.c:1863
uint8_t track_number[4]
Definition: mxfdec.c:170
int64_t original_duration
Definition: mxfdec.c:174
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:184
#define SET_UID_METADATA(pb, name, var, str)
Definition: mxfdec.c:2489
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:383
#define AVINDEX_KEYFRAME
Definition: avformat.h:810
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
Definition: mxfdec.c:3183
int metadata_sets_count
Definition: mxfdec.c:276
UID essence_container_ul
Definition: mxfdec.c:184
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
Definition: mxfdec.c:415
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
int64_t start_position
Definition: mxfdec.c:119
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int last_forward_partition
Definition: mxfdec.c:287
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1503
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:848
static void mxf_compute_essence_containers(AVFormatContext *s)
Figures out the proper offset and length of the essence container in each partition.
Definition: mxfdec.c:2828
MXFPartitionType
Definition: mxfdec.c:61
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
Definition: mxfdec.c:1044
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:1826
UID essence_codec_ul
Definition: mxfdec.c:185
int8_t * temporal_offset_entries
Definition: mxfdec.c:220
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
Definition: mxfdec.c:1818
#define AVERROR(e)
Definition: error.h:43
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:900
MXFDescriptor * descriptor
Definition: mxfdec.c:233
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:804
uint64_t index_start_position
Definition: mxfdec.c:218
int nb_ptses
Definition: mxfdec.c:258
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
Definition: mxfdec.c:977
unsigned matching_len
Definition: mxf.h:77
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
Definition: mxfdec.c:1264
Definition: mxf.h:56
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3895
const char * arg
Definition: jacosubdec.c:66
uint64_t length
Definition: mxf.h:64
static const MXFCodecUL mxf_sound_essence_container_uls[]
Definition: mxfdec.c:1279
simple assert() macros that are a bit more flexible than ISO C assert().
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3217
GLsizei GLsizei * length
Definition: opengl_enc.c:115
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
Definition: mxfdec.c:2767
#define IS_KLV_KEY(x, y)
Definition: mxfdec.c:323
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:31
int track_id
Definition: mxfdec.c:168
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
UID package_uid
Definition: mxfdec.c:229
#define FFMAX(a, b)
Definition: common.h:94
int64_t essence_length
Definition: mxfdec.c:96
#define fail()
Definition: checkasm.h:117
static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:934
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:826
int64_t duration
Definition: mxfdec.c:129
int video_line_map[2]
Definition: mxfdec.c:192
static int mxf_match_uid(const UID key, const UID uid, int len)
Definition: mxfdec.c:1202
int packages_count
Definition: mxfdec.c:272
Only parse headers, do not repack.
Definition: avformat.h:794
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:639
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:1916
int64_t index_byte_count
Definition: mxfdec.c:99
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:451
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition: mxf.c:119
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition: mxf.c:77
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:450
Definition: hls.c:68
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
int nb_segments
Definition: mxfdec.c:261
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5307
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition: mxfdec.c:1212
static const uint8_t mxf_jp2k_rsiz[]
Definition: mxfdec.c:319
MXFPartition * partitions
Definition: mxfdec.c:268
int8_t * offsets
Definition: mxfdec.c:264
enum MXFMetadataSetType type
Definition: mxfdec.c:213
static const uint8_t mxf_essence_element_key[]
Definition: mxfdec.c:306
static void * mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
Definition: mxfdec.c:1222
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int local_tags_count
Definition: mxfdec.c:280
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3286
unsigned int horiz_subsampling
Definition: mxfdec.c:201
static const uint8_t mxf_system_item_key_cp[]
Definition: mxfdec.c:309
#define PRIxUID
Definition: mxf.h:97
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
static MXFStructuralComponent * mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
Definition: mxfdec.c:1889
static const uint8_t mxf_encrypted_triplet_key[]
Definition: mxfdec.c:314
#define FFMIN(a, b)
Definition: common.h:96
static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
Definition: mxfdec.c:3157
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
enum AVPixelFormat pix_fmt
Definition: mxfdec.c:208
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
UID uid
Definition: mxfdec.c:124
int64_t essence_offset
absolute offset of essence
Definition: mxfdec.c:95
struct AVRational rate
Definition: mxfdec.c:138
static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
Definition: mxfdec.c:1934
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
Definition: mxfdec.c:1847
int64_t last_forward_tell
Definition: mxfdec.c:286
static const uint8_t mxf_header_partition_pack_key[]
Definition: mxfdec.c:305
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:550
static const MXFCodecUL mxf_intra_only_picture_coded_width[]
Definition: mxfdec.c:1271
Definition: mxfdec.c:72
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2668
int n
Definition: avisynth_c.h:684
AVDictionary * metadata
Definition: avformat.h:938
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:2939
int64_t this_partition
Definition: mxfdec.c:94
static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
Definition: mxfdec.c:481
enum AVCodecID codec_id
Definition: vaapi_decode.c:362
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
Definition: mxfdec.c:2502
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
Definition: mxf.c:28
UID * sub_descriptors_refs
Definition: mxfdec.c:203
static const uint8_t mxf_system_item_key_gc[]
Definition: mxfdec.c:310
static MXFIndexTable * mxf_find_index_table(MXFContext *mxf, int index_sid)
Definition: mxfdec.c:2873
static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:920
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1135
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
uint64_t index_duration
Definition: mxfdec.c:219
Stream structure.
Definition: avformat.h:874
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
Definition: mxfdec.c:762
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
Definition: aes.c:195
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1186
sample_rate
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
Definition: mxfdec.c:2918
UID * essence_container_data_refs
Definition: mxfdec.c:273
Timecode helpers header.
int sub_descriptors_count
Definition: mxfdec.c:204
int nb_index_tables
Definition: mxfdec.c:288
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
static int resync(AVFormatContext *s)
Definition: flvdec.c:906
static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1064
static const uint8_t mxf_encrypted_essence_container[]
Definition: mxfdec.c:315
static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
Definition: mxfdec.c:2594
Definition: mxfdec.c:68
int samples_per_frame[6]
Definition: mxf.h:86
#define AV_RN16(p)
Definition: intreadwrite.h:360
enum MXFMetadataSetType type
Definition: mxfdec.c:125
void * buf
Definition: avisynth_c.h:690
int run_in
Definition: mxfdec.c:283
GLint GLenum type
Definition: opengl_enc.c:105
KLVPacket first_essence_klv
Definition: mxfdec.c:103
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int comment_count
Definition: mxfdec.c:237
static const MXFCodecUL mxf_data_essence_container_uls[]
Definition: mxfdec.c:1289
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:423
AVRational aspect_ratio
Definition: mxfdec.c:188
int index
Definition: gxfenc.c:89
Definition: mxf.h:54
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:576
MXFPartitionType type
Definition: mxfdec.c:90
static const uint8_t mxf_canopus_essence_element_key[]
Definition: mxfdec.c:308
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: avformat.h:1225
struct AVAES * aesc
Definition: mxfdec.c:278
AVMediaType
Definition: avutil.h:199
AVFormatContext * fc
Definition: mxfdec.c:277
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:500
uint8_t * extradata
Definition: mxfdec.c:206
UID package_ul
Definition: mxfdec.c:230
unsigned partitions_count
Definition: mxfdec.c:269
enum MXFMetadataSetType type
Definition: mxfdec.c:108
AVRational sample_rate
Definition: mxfdec.c:187
#define snprintf
Definition: snprintf.h:34
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
Computes the absolute file offset of the given essence container offset.
Definition: mxfdec.c:1417
This structure contains the data a format has to probe a file.
Definition: avformat.h:448
Definition: mxf.h:75
#define AV_RN32(p)
Definition: intreadwrite.h:364
misc parsing utilities
int essence_container_data_count
Definition: mxfdec.c:274
uint8_t * local_tags
Definition: mxfdec.c:279
int channels
Definition: mxfdec.c:197
#define READ_STR16(type, big_endian)
Definition: mxfdec.c:801
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
static const uint8_t mxf_indirect_value_utf16be[]
Definition: mxfdec.c:321
static int64_t klv_decode_ber_length(AVIOContext *pb)
Definition: mxfdec.c:366
MXFWrappingScheme
Definition: mxfdec.c:81
int64_t duration
Definition: mxfdec.c:153
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:84
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
Definition: mxfdec.c:1296
char * name
Definition: mxfdec.c:169
static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:865
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:923
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int body_sid
Definition: mxfdec.c:176
int sample_rate
Audio only.
Definition: avcodec.h:4009
Definition: mxfdec.c:75
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
Definition: mxfdec.c:1956
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:460
const uint8_t * key
Definition: avformat.h:1527
static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
Definition: mxfdec.c:3291
int parsing_backward
Definition: mxfdec.c:285
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:78
full parsing and repack
Definition: avformat.h:793
Main libavformat public API header.
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:810
int tracks_count
Definition: mxfdec.c:232
Definition: mxf.h:37
int body_sid
Definition: mxfdec.c:257
if(ret< 0)
Definition: vf_mcdeint.c:279
const char * desc
Definition: mxf.h:79
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition: mxfdec.c:1237
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
int height
Definition: mxfdec.c:190
UID codec_ul
Definition: mxfdec.c:186
Definition: mxf.h:71
Definition: mxfdec.c:77
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:913
MXFMetadataReadFunc * read
Definition: mxfdec.c:297
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1618
Definition: mxfdec.c:70
Definition: mxfdec.c:76
static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
Definition: mxfdec.c:2026
int field_dominance
Definition: mxfdec.c:196
static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
Definition: mxfdec.c:325
AVInputFormat ff_mxf_demuxer
Definition: mxfdec.c:3608
UID uid
Definition: mxfdec.c:227
int den
Denominator.
Definition: rational.h:60
AVIndexEntry * fake_index
Definition: mxfdec.c:263
int64_t pack_ofs
absolute offset of pack in file, including run-in
Definition: mxfdec.c:101
int structural_components_count
Definition: mxfdec.c:128
UID data_definition_ul
Definition: mxfdec.c:126
static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
Definition: mxfdec.c:2461
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:752
enum MXFMetadataSetType type
Definition: mxfdec.c:251
int body_sid
Definition: mxfdec.c:93
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
Definition: mxfdec.c:1527
#define av_free(p)
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par, AVPacket *pkt)
Definition: mxfdec.c:3269
const MXFCodecUL ff_mxf_codec_tag_uls[]
Definition: mxf.c:83
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
Make sure track->sample_count is correct based on what offset we're currently at.
Definition: mxfdec.c:3231
int len
uint64_t * stream_offset_entries
Definition: mxfdec.c:222
static int mxf_is_partition_pack_key(UID key)
Matches any partition pack key, in other words:
Definition: mxfdec.c:2674
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:2539
static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
Definition: mxfdec.c:739
MXFOP op
Definition: mxfdec.c:270
void * priv_data
Format private data.
Definition: avformat.h:1379
static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
Returns the end position of the essence container with given BodySID, or zero if unknown.
Definition: mxfdec.c:1460
static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
Definition: mxfdec.c:2815
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:2938
int extradata_size
Definition: mxfdec.c:207
UID uid
Definition: mxfdec.c:164
static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
Definition: mxfdec.c:1168
uint64_t layout
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3941
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3913
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:876
#define SET_STR_METADATA(pb, name, str)
Definition: mxfdec.c:2483
int channels
Audio only.
Definition: avcodec.h:4005
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1443
int64_t duration
Definition: mxfdec.c:199
MXFMetadataSet ** metadata_sets
Definition: mxfdec.c:275
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:647
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1021
int64_t next_klv
Definition: mxf.h:65
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:358
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3903
MXFIndexTable * index_tables
Definition: mxfdec.c:289
UID uid
Definition: mxf.h:76
int pack_length
Definition: mxfdec.c:100
int stream_index
Definition: avcodec.h:1446
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:903
int64_t body_offset
Definition: mxfdec.c:102
AVRational edit_rate
Definition: mxfdec.c:171
Definition: mxf.h:70
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:929
char * name
Definition: mxfdec.c:235
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1421
int index_sid
Definition: mxfdec.c:92
Definition: mxf.h:31
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1437
enum MXFMetadataSetType type
Definition: mxfdec.c:228
for(j=16;j >0;--j)
Definition: mxfdec.c:62
uint64_t sample_count
Definition: mxfdec.c:173
MXFPartition * current_partition
Definition: mxfdec.c:284
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
char * value
Definition: mxfdec.c:160
uint64_t previous_partition
Definition: mxfdec.c:91