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