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