FFmpeg
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  * SMPTE 2067-21 Interoperable Master Format — Application #2E
32  *
33  * Principle
34  * Search for Track numbers which will identify essence element KLV packets.
35  * Search for SourcePackage which define tracks which contains Track numbers.
36  * Material Package contains tracks with reference to SourcePackage tracks.
37  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
38  * Assign Descriptors to correct Tracks.
39  *
40  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
41  * Metadata parsing resolves Strong References to objects.
42  *
43  * Simple demuxer, only OP1A supported and some files might not work at all.
44  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
45  */
46 
47 #include <inttypes.h>
48 
49 #include "libavutil/aes.h"
50 #include "libavutil/avassert.h"
52 #include "libavutil/mathematics.h"
53 #include "libavcodec/bytestream.h"
54 #include "libavutil/intreadwrite.h"
55 #include "libavutil/parseutils.h"
56 #include "libavutil/timecode.h"
57 #include "libavutil/opt.h"
58 #include "avformat.h"
59 #include "internal.h"
60 #include "mxf.h"
61 
62 #define MXF_MAX_CHUNK_SIZE (32 << 20)
63 
64 typedef enum {
69 
70 typedef enum {
71  OP1a = 1,
81  OPSONYOpt, /* FATE sample, violates the spec in places */
82 } MXFOP;
83 
84 typedef enum {
89 
90 typedef struct MXFPartition {
91  int closed;
92  int complete;
95  int index_sid;
96  int body_sid;
97  int64_t this_partition;
98  int64_t essence_offset; ///< absolute offset of essence
99  int64_t essence_length;
104  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
105  int64_t body_offset;
107 } MXFPartition;
108 
109 typedef struct MXFCryptoContext {
114 
115 typedef struct MXFStructuralComponent {
121  int64_t duration;
122  int64_t start_position;
125 
126 typedef struct MXFSequence {
132  int64_t duration;
134 } MXFSequence;
135 
136 typedef struct MXFTimecodeComponent {
141  struct AVRational rate;
144 
145 typedef struct {
150 
151 typedef struct {
156  int64_t duration;
158 
159 typedef struct {
162  char *name;
163  char *value;
165 
166 typedef struct {
169  MXFSequence *sequence; /* mandatory, and only one */
171  int track_id;
172  char *name;
173  uint8_t track_number[4];
176  uint64_t sample_count;
177  int64_t original_duration; /* st->duration in SampleRate/EditRate units */
179  int body_sid;
181  int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
182 } MXFTrack;
183 
184 typedef struct MXFDescriptor {
192  int width;
193  int height; /* Field height, not frame height */
194  int frame_layout; /* See MXFFrameLayout enum */
195  int video_line_map[2];
196 #define MXF_FIELD_DOMINANCE_DEFAULT 0
197 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
198 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
200  int channels;
202  int64_t duration; /* ContainerDuration optional property */
203  unsigned int component_depth;
204  unsigned int black_ref_level;
205  unsigned int white_ref_level;
206  unsigned int color_range;
207  unsigned int horiz_subsampling;
208  unsigned int vert_subsampling;
220  size_t coll_size;
221 } MXFDescriptor;
222 
223 typedef struct MXFIndexTableSegment {
228  int body_sid;
231  uint64_t index_duration;
237 
238 typedef struct MXFPackage {
245  MXFDescriptor *descriptor; /* only one */
247  char *name;
250 } MXFPackage;
251 
252 typedef struct MXFEssenceContainerData {
258  int body_sid;
260 
261 typedef struct MXFMetadataSet {
265 
266 /* decoded index table */
267 typedef struct MXFIndexTable {
269  int body_sid;
270  int nb_ptses; /* number of PTSes or total duration of index */
271  int64_t first_dts; /* DTS = EditUnit + first_dts */
272  int64_t *ptses; /* maps EditUnit -> PTS */
274  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
275  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
276  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
277 } MXFIndexTable;
278 
279 typedef struct MXFContext {
280  const AVClass *class; /**< Class for private options. */
291  struct AVAES *aesc;
296  int run_in;
304 } MXFContext;
305 
306 /* NOTE: klv_offset is not set (-1) for local keys */
307 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
308 
310  const UID key;
312  int ctx_size;
315 
316 static int mxf_read_close(AVFormatContext *s);
317 
318 /* partial keys to match */
319 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
320 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
321 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
322 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
323 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
324 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
325 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
326 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
327 /* complete keys to match */
328 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
329 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
330 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
331 static const uint8_t mxf_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,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,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 
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 
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 */
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
603  size = klv_decode_ber_length(pb);
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
626  size = klv_decode_ber_length(pb);
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);
646  pkt->stream_index = index;
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 
1098  !FF_ALLOC_TYPED_ARRAY(segment->flag_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  }
1297  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[0])) {
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  }
1307  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[1])) {
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  }
1314  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[2])) {
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  }
1320  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[3])) {
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  }
1327  if (IS_KLV_KEY(uid, mxf_apple_coll_prefix)) {
1328  if (!descriptor->coll) {
1329  descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1330  if (!descriptor->coll)
1331  return AVERROR(ENOMEM);
1332  }
1333  if (IS_KLV_KEY(uid, mxf_apple_coll_max_cll)) {
1334  descriptor->coll->MaxCLL = avio_rb16(pb);
1335  }
1336  if (IS_KLV_KEY(uid, mxf_apple_coll_max_fall)) {
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 
1479  codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1480  if (!codec_ul->uid[0])
1481  codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
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) {
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",
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  */
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->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",
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");
1843  ret = AVERROR_INVALIDDATA;
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 {
1936  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1937  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1938  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
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;
1998  av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
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 
2133  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
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");
2356  ret = AVERROR_INVALIDDATA;
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");
2394  ret = AVERROR_INVALIDDATA;
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 */
2470  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2471  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2472  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2473  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
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);
2497  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
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) {
2626  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2627  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2628  if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
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;
2666  container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2667  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2668  st->codecpar->codec_id = container_ul->id;
2669  type = avcodec_get_type(st->codecpar->codec_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) {
2685  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2686  &descriptor->essence_codec_ul)->id;
2687  if (coded_width)
2688  st->codecpar->width = coded_width;
2689  ret = ff_generate_avci_extradata(st);
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 0x3C04:
2792  SET_STR_METADATA(pb, "product_version", str);
2793  break;
2794  case 0x3C05:
2795  SET_UID_METADATA(pb, "product_uid", uid, str);
2796  break;
2797  case 0x3C06:
2798  SET_TS_METADATA(pb, "modification_date", ts, str);
2799  break;
2800  case 0x3C07:
2801  SET_VERSION_METADATA(pb, "toolkit_version", major, minor, tertiary, patch, release, str);
2802  break;
2803  case 0x3C08:
2804  SET_STR_METADATA(pb, "application_platform", str);
2805  break;
2806  case 0x3C09:
2807  SET_UID_METADATA(pb, "generation_uid", uid, str);
2808  break;
2809  case 0x3C0A:
2810  SET_UID_METADATA(pb, "uid", uid, str);
2811  break;
2812  }
2813  return 0;
2814 }
2815 
2816 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2817 {
2818  MXFContext *mxf = arg;
2819  AVFormatContext *s = mxf->fc;
2820  int ret;
2821  char *str = NULL;
2822 
2823  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2824  SET_STR_METADATA(pb, "project_name", str);
2825  }
2826  return 0;
2827 }
2828 
2830  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2831  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2832  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2833  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2834  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2835  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2836  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2837  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2838  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2839  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2840  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2841  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2842  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2843  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2844  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2845  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2846  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2847  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2848  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2849  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2850  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2851  { { 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 */
2852  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2853  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2854  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2855  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2856  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2857  { { 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 */
2858  { { 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 */
2859  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2860  { { 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 */
2861  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2862  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2863  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2864  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2865  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2866  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2867  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2868  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2869 };
2870 
2872 {
2873  ctx->type = type;
2874  switch (type){
2875  case MultipleDescriptor:
2876  case Descriptor:
2877  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2878  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2879  break;
2880  default:
2881  break;
2882  }
2883  return 0;
2884 }
2885 
2886 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2887 {
2888  AVIOContext *pb = mxf->fc->pb;
2889  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2890  uint64_t klv_end = avio_tell(pb) + klv->length;
2891 
2892  if (!ctx)
2893  return AVERROR(ENOMEM);
2894  if (ctx_size)
2895  mxf_metadataset_init(ctx, type);
2896  while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2897  int ret;
2898  int tag = avio_rb16(pb);
2899  int size = avio_rb16(pb); /* KLV specified by 0x53 */
2900  int64_t next = avio_tell(pb);
2901  UID uid = {0};
2902  if (next < 0 || next > INT64_MAX - size)
2903  return next < 0 ? next : AVERROR_INVALIDDATA;
2904  next += size;
2905 
2906  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2907  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2908  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2909  continue;
2910  }
2911  if (tag > 0x7FFF) { /* dynamic tag */
2912  int i;
2913  for (i = 0; i < mxf->local_tags_count; i++) {
2914  int local_tag = AV_RB16(mxf->local_tags+i*18);
2915  if (local_tag == tag) {
2916  memcpy(uid, mxf->local_tags+i*18+2, 16);
2917  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2918  PRINT_KEY(mxf->fc, "uid", uid);
2919  }
2920  }
2921  }
2922  if (ctx_size && tag == 0x3C0A) {
2923  avio_read(pb, ctx->uid, 16);
2924  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2925  if (ctx_size)
2926  mxf_free_metadataset(&ctx, 1);
2927  return ret;
2928  }
2929 
2930  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2931  * it extending past the end of the KLV though (zzuf5.mxf). */
2932  if (avio_tell(pb) > klv_end) {
2933  if (ctx_size) {
2934  mxf_free_metadataset(&ctx, 1);
2935  }
2936 
2937  av_log(mxf->fc, AV_LOG_ERROR,
2938  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2939  tag, klv->offset);
2940  return AVERROR_INVALIDDATA;
2941  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2942  avio_seek(pb, next, SEEK_SET);
2943  }
2944  return ctx_size ? mxf_add_metadata_set(mxf, &ctx) : 0;
2945 }
2946 
2947 /**
2948  * Matches any partition pack key, in other words:
2949  * - HeaderPartition
2950  * - BodyPartition
2951  * - FooterPartition
2952  * @return non-zero if the key is a partition pack key, zero otherwise
2953  */
2955 {
2956  //NOTE: this is a little lax since it doesn't constraint key[14]
2957  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2958  key[13] >= 2 && key[13] <= 4;
2959 }
2960 
2961 /**
2962  * Parses a metadata KLV
2963  * @return <0 on error, 0 otherwise
2964  */
2966  int ctx_size, enum MXFMetadataSetType type)
2967 {
2968  AVFormatContext *s = mxf->fc;
2969  int res;
2970  if (klv.key[5] == 0x53) {
2971  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2972  } else {
2973  uint64_t next = avio_tell(s->pb) + klv.length;
2974  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2975 
2976  /* only seek forward, else this can loop for a long time */
2977  if (avio_tell(s->pb) > next) {
2978  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2979  klv.offset);
2980  return AVERROR_INVALIDDATA;
2981  }
2982 
2983  avio_seek(s->pb, next, SEEK_SET);
2984  }
2985  if (res < 0) {
2986  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2987  return res;
2988  }
2989  return 0;
2990 }
2991 
2992 /**
2993  * Seeks to the previous partition and parses it, if possible
2994  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2995  */
2997 {
2998  AVIOContext *pb = mxf->fc->pb;
2999  KLVPacket klv;
3000  int64_t current_partition_ofs;
3001  int ret;
3002 
3003  if (!mxf->current_partition ||
3005  return 0; /* we've parsed all partitions */
3006 
3007  /* seek to previous partition */
3008  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3009  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3010  mxf->current_partition = NULL;
3011 
3012  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3013 
3014  /* Make sure this is actually a PartitionPack, and if so parse it.
3015  * See deadlock2.mxf
3016  */
3017  if ((ret = klv_read_packet(&klv, pb)) < 0) {
3018  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3019  return ret;
3020  }
3021 
3022  if (!mxf_is_partition_pack_key(klv.key)) {
3023  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3024  return AVERROR_INVALIDDATA;
3025  }
3026 
3027  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3028  * can point to just before the current partition, causing klv_read_packet()
3029  * to sync back up to it. See deadlock3.mxf
3030  */
3031  if (klv.offset >= current_partition_ofs) {
3032  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3033  PRIx64 " indirectly points to itself\n", current_partition_ofs);
3034  return AVERROR_INVALIDDATA;
3035  }
3036 
3037  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3038  return ret;
3039 
3040  return 1;
3041 }
3042 
3043 /**
3044  * Called when essence is encountered
3045  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3046  */
3048 {
3049  AVIOContext *pb = mxf->fc->pb;
3050  int64_t ret;
3051 
3052  if (mxf->parsing_backward) {
3053  return mxf_seek_to_previous_partition(mxf);
3054  } else {
3055  if (!mxf->footer_partition) {
3056  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3057  return 0;
3058  }
3059 
3060  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3061 
3062  /* remember where we were so we don't end up seeking further back than this */
3063  mxf->last_forward_tell = avio_tell(pb);
3064 
3065  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3066  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3067  return -1;
3068  }
3069 
3070  /* seek to FooterPartition and parse backward */
3071  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3072  av_log(mxf->fc, AV_LOG_ERROR,
3073  "failed to seek to FooterPartition @ 0x%" PRIx64
3074  " (%"PRId64") - partial file?\n",
3075  mxf->run_in + mxf->footer_partition, ret);
3076  return ret;
3077  }
3078 
3079  mxf->current_partition = NULL;
3080  mxf->parsing_backward = 1;
3081  }
3082 
3083  return 1;
3084 }
3085 
3086 /**
3087  * Called when the next partition or EOF is encountered
3088  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3089  */
3091 {
3092  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3093 }
3094 
3096 {
3097  for (int i = 0; i < s->nb_streams; i++) {
3098  MXFTrack *track = s->streams[i]->priv_data;
3099  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3100  return track->wrapping;
3101  }
3102  return UnknownWrapped;
3103 }
3104 
3105 /**
3106  * Figures out the proper offset and length of the essence container in each partition
3107  */
3109 {
3110  MXFContext *mxf = s->priv_data;
3111  int x;
3112 
3113  for (x = 0; x < mxf->partitions_count; x++) {
3114  MXFPartition *p = &mxf->partitions[x];
3115  MXFWrappingScheme wrapping;
3116 
3117  if (!p->body_sid)
3118  continue; /* BodySID == 0 -> no essence */
3119 
3120  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3121  * otherwise we point essence_offset at the key of the first essence KLV.
3122  */
3123 
3124  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3125 
3126  if (wrapping == ClipWrapped) {
3129  } else {
3131 
3132  /* essence container spans to the next partition */
3133  if (x < mxf->partitions_count - 1)
3135 
3136  if (p->essence_length < 0) {
3137  /* next ThisPartition < essence_offset */
3138  p->essence_length = 0;
3139  av_log(mxf->fc, AV_LOG_ERROR,
3140  "partition %i: bad ThisPartition = %"PRIX64"\n",
3141  x+1, mxf->partitions[x+1].this_partition);
3142  }
3143  }
3144  }
3145 }
3146 
3147 static int is_pcm(enum AVCodecID codec_id)
3148 {
3149  /* we only care about "normal" PCM codecs until we get samples */
3150  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
3151 }
3152 
3154 {
3155  int i;
3156  for (i = 0; i < mxf->nb_index_tables; i++)
3157  if (mxf->index_tables[i].index_sid == index_sid)
3158  return &mxf->index_tables[i];
3159  return NULL;
3160 }
3161 
3162 /**
3163  * Deal with the case where for some audio atoms EditUnitByteCount is
3164  * very small (2, 4..). In those cases we should read more than one
3165  * sample per call to mxf_read_packet().
3166  */
3168 {
3169  MXFTrack *track = st->priv_data;
3170  MXFIndexTable *t;
3171 
3172  if (!track)
3173  return;
3174  track->edit_units_per_packet = 1;
3175  if (track->wrapping != ClipWrapped)
3176  return;
3177 
3178  t = mxf_find_index_table(mxf, track->index_sid);
3179 
3180  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3181  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3182  !is_pcm(st->codecpar->codec_id) ||
3183  !t ||
3184  t->nb_segments != 1 ||
3185  t->segments[0]->edit_unit_byte_count >= 32)
3186  return;
3187 
3188  /* arbitrarily default to 48 kHz PAL audio frame size */
3189  /* TODO: We could compute this from the ratio between the audio
3190  * and video edit rates for 48 kHz NTSC we could use the
3191  * 1802-1802-1802-1802-1801 pattern. */
3192  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3193 }
3194 
3195 /**
3196  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3197  */
3199 {
3200  MXFTrack *track = st->priv_data;
3202  MXFPartition *p = NULL;
3203  int essence_partition_count = 0;
3204  int edit_unit_byte_count = 0;
3205  int i, ret;
3206 
3207  if (!track || track->wrapping != ClipWrapped)
3208  return 0;
3209 
3210  /* check if track already has an IndexTableSegment */
3211  for (i = 0; i < mxf->metadata_sets_count; i++) {
3212  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3214  if (s->body_sid == track->body_sid)
3215  return 0;
3216  }
3217  }
3218 
3219  /* find the essence partition */
3220  for (i = 0; i < mxf->partitions_count; i++) {
3221  /* BodySID == 0 -> no essence */
3222  if (mxf->partitions[i].body_sid != track->body_sid)
3223  continue;
3224 
3225  p = &mxf->partitions[i];
3226  essence_partition_count++;
3227  }
3228 
3229  /* only handle files with a single essence partition */
3230  if (essence_partition_count != 1)
3231  return 0;
3232 
3234  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3235  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3236  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3237  }
3238 
3239  if (edit_unit_byte_count <= 0)
3240  return 0;
3241 
3242  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);
3243 
3244  if (!(segment = av_mallocz(sizeof(*segment))))
3245  return AVERROR(ENOMEM);
3246 
3247  if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3248  return ret;
3249 
3250  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3251  * using the same SID for index is forbidden in MXF. */
3252  if (!track->index_sid)
3253  track->index_sid = track->body_sid;
3254 
3255  segment->type = IndexTableSegment;
3256  /* stream will be treated as small EditUnitByteCount */
3257  segment->edit_unit_byte_count = edit_unit_byte_count;
3258  segment->index_start_position = 0;
3259  segment->index_duration = st->duration;
3260  segment->index_edit_rate = av_inv_q(st->time_base);
3261  segment->index_sid = track->index_sid;
3262  segment->body_sid = p->body_sid;
3263  return 0;
3264 }
3265 
3267 {
3268  MXFContext *mxf = s->priv_data;
3269  uint32_t length;
3270  int64_t file_size, max_rip_length, min_rip_length;
3271  KLVPacket klv;
3272 
3273  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3274  return;
3275 
3276  file_size = avio_size(s->pb);
3277 
3278  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3279  * The limit below assumes a file with nothing but partition packs and a RIP.
3280  * Before changing this, consider that a muxer may place each sample in its own partition.
3281  *
3282  * 105 is the size of the smallest possible PartitionPack
3283  * 12 is the size of each RIP entry
3284  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3285  */
3286  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3287  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3288 
3289  /* We're only interested in RIPs with at least two entries.. */
3290  min_rip_length = 16+1+24+4;
3291 
3292  /* See S377m section 11 */
3293  avio_seek(s->pb, file_size - 4, SEEK_SET);
3294  length = avio_rb32(s->pb);
3295 
3296  if (length < min_rip_length || length > max_rip_length)
3297  goto end;
3298  avio_seek(s->pb, file_size - length, SEEK_SET);
3299  if (klv_read_packet(&klv, s->pb) < 0 ||
3301  goto end;
3302  if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3303  av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3304  goto end;
3305  }
3306 
3307  avio_skip(s->pb, klv.length - 12);
3308  mxf->footer_partition = avio_rb64(s->pb);
3309 
3310  /* sanity check */
3311  if (mxf->run_in + mxf->footer_partition >= file_size) {
3312  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3313  mxf->footer_partition = 0;
3314  }
3315 
3316 end:
3317  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3318 }
3319 
3321 {
3322  MXFContext *mxf = s->priv_data;
3323  KLVPacket klv;
3324  int64_t essence_offset = 0;
3325  int ret;
3326 
3327  mxf->last_forward_tell = INT64_MAX;
3328 
3330  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3331  //goto fail should not be needed as no metadata sets will have been parsed yet
3332  return AVERROR_INVALIDDATA;
3333  }
3334  avio_seek(s->pb, -14, SEEK_CUR);
3335  mxf->fc = s;
3336  mxf->run_in = avio_tell(s->pb);
3337 
3339 
3340  while (!avio_feof(s->pb)) {
3341  const MXFMetadataReadTableEntry *metadata;
3342 
3343  if (klv_read_packet(&klv, s->pb) < 0) {
3344  /* EOF - seek to previous partition or stop */
3345  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3346  break;
3347  else
3348  continue;
3349  }
3350 
3351  PRINT_KEY(s, "read header", klv.key);
3352  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3359 
3360  if (!mxf->current_partition) {
3361  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3362  ret = AVERROR_INVALIDDATA;
3363  goto fail;
3364  }
3365 
3368 
3369  if (!essence_offset)
3370  essence_offset = klv.offset;
3371 
3372  /* seek to footer, previous partition or stop */
3373  if (mxf_parse_handle_essence(mxf) <= 0)
3374  break;
3375  continue;
3376  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3377  /* next partition pack - keep going, seek to previous partition or stop */
3378  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3379  break;
3380  else if (mxf->parsing_backward)
3381  continue;
3382  /* we're still parsing forward. proceed to parsing this partition pack */
3383  }
3384 
3385  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3386  if (IS_KLV_KEY(klv.key, metadata->key)) {
3387  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3388  goto fail;
3389  break;
3390  }
3391  }
3392  if (!metadata->read) {
3393  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3394  UID_ARG(klv.key));
3395  avio_skip(s->pb, klv.length);
3396  }
3397  }
3398  /* FIXME avoid seek */
3399  if (!essence_offset) {
3400  av_log(s, AV_LOG_ERROR, "no essence\n");
3401  ret = AVERROR_INVALIDDATA;
3402  goto fail;
3403  }
3404  avio_seek(s->pb, essence_offset, SEEK_SET);
3405 
3406  /* we need to do this before computing the index tables
3407  * to be able to fill in zero IndexDurations with st->duration */
3408  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3409  goto fail;
3410 
3411  for (int i = 0; i < s->nb_streams; i++)
3413 
3414  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3415  goto fail;
3416 
3417  if (mxf->nb_index_tables > 1) {
3418  /* TODO: look up which IndexSID to use via EssenceContainerData */
3419  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3420  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3421  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3422  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3423  ret = AVERROR_INVALIDDATA;
3424  goto fail;
3425  }
3426 
3428 
3429  for (int i = 0; i < s->nb_streams; i++)
3431 
3432  return 0;
3433 fail:
3434  mxf_read_close(s);
3435 
3436  return ret;
3437 }
3438 
3439 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3440 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3441 {
3442  int64_t a, b, m, offset;
3443  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3444 
3445  if (!t || track->original_duration <= 0)
3446  return -1;
3447 
3448  a = -1;
3449  b = track->original_duration;
3450 
3451  while (b - a > 1) {
3452  m = (a + b) >> 1;
3453  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3454  return -1;
3455  if (offset < current_offset)
3456  a = m;
3457  else
3458  b = m;
3459  }
3460 
3461  *edit_unit_out = b;
3462 
3463  return 0;
3464 }
3465 
3467  int64_t edit_unit)
3468 {
3469  MXFTrack *track = st->priv_data;
3470  AVRational time_base = av_inv_q(track->edit_rate);
3472 
3473  // For non-audio sample_count equals current edit unit
3475  return edit_unit;
3476 
3477  if ((sample_rate.num / sample_rate.den) == 48000) {
3478  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3479  } else {
3480  int remainder = (sample_rate.num * time_base.num) %
3481  (time_base.den * sample_rate.den);
3482  if (remainder)
3483  av_log(mxf->fc, AV_LOG_WARNING,
3484  "seeking detected on stream #%d with time base (%d/%d) and "
3485  "sample rate (%d/%d), audio pts won't be accurate.\n",
3486  st->index, time_base.num, time_base.den,
3487  sample_rate.num, sample_rate.den);
3488  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3489  }
3490 }
3491 
3492 /**
3493  * Make sure track->sample_count is correct based on what offset we're currently at.
3494  * Also determine the next edit unit (or packet) offset.
3495  * @return next_ofs if OK, <0 on error
3496  */
3497 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3498 {
3499  int64_t next_ofs = -1;
3500  MXFTrack *track = st->priv_data;
3501  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3502  int64_t new_edit_unit;
3503  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3504 
3505  if (!t || track->wrapping == UnknownWrapped)
3506  return -1;
3507 
3508  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3509  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3510  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3511  return -1;
3512  }
3513 
3514  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3515  if (next_ofs > current_offset)
3516  return next_ofs;
3517 
3518  if (!resync) {
3519  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3520  return -1;
3521  }
3522 
3523  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3524  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3525  return -1;
3526  }
3527 
3528  new_edit_unit--;
3529  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3530  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);
3531 
3532  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3533 }
3534 
3536  AVPacket *pkt)
3537 {
3538  AVStream *st = mxf->fc->streams[pkt->stream_index];
3539  MXFTrack *track = st->priv_data;
3540  int64_t bits_per_sample = par->bits_per_coded_sample;
3541 
3542  if (!bits_per_sample)
3543  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3544 
3545  pkt->pts = track->sample_count;
3546 
3547  if ( par->channels <= 0
3548  || bits_per_sample <= 0
3549  || par->channels * (int64_t)bits_per_sample < 8)
3550  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);
3551  else
3552  track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3553 
3554  return 0;
3555 }
3556 
3557 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3558 {
3559  AVCodecParameters *par = st->codecpar;
3560  MXFTrack *track = st->priv_data;
3561 
3562  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3563  /* see if we have an index table to derive timestamps from */
3564  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3565 
3566  if (t && track->sample_count < t->nb_ptses) {
3567  pkt->dts = track->sample_count + t->first_dts;
3568  pkt->pts = t->ptses[track->sample_count];
3569  } else if (track->intra_only) {
3570  /* intra-only -> PTS = EditUnit.
3571  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3572  pkt->pts = track->sample_count;
3573  }
3574  track->sample_count++;
3575  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3576  int ret = mxf_set_audio_pts(mxf, par, pkt);
3577  if (ret < 0)
3578  return ret;
3579  } else if (track) {
3580  pkt->dts = pkt->pts = track->sample_count;
3581  pkt->duration = 1;
3582  track->sample_count++;
3583  }
3584  return 0;
3585 }
3586 
3588 {
3589  KLVPacket klv;
3590  MXFContext *mxf = s->priv_data;
3591  int ret;
3592 
3593  while (1) {
3594  int64_t max_data_size;
3595  int64_t pos = avio_tell(s->pb);
3596 
3597  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3598  mxf->current_klv_data = (KLVPacket){{0}};
3599  ret = klv_read_packet(&klv, s->pb);
3600  if (ret < 0)
3601  break;
3602  max_data_size = klv.length;
3603  pos = klv.next_klv - klv.length;
3604  PRINT_KEY(s, "read packet", klv.key);
3605  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3607  ret = mxf_decrypt_triplet(s, pkt, &klv);
3608  if (ret < 0) {
3609  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3610  return ret;
3611  }
3612  return 0;
3613  }
3614  } else {
3615  klv = mxf->current_klv_data;
3616  max_data_size = klv.next_klv - pos;
3617  }
3622  int index = mxf_get_stream_index(s, &klv, body_sid);
3623  int64_t next_ofs;
3624  AVStream *st;
3625  MXFTrack *track;
3626 
3627  if (index < 0) {
3628  av_log(s, AV_LOG_ERROR,
3629  "error getting stream index %"PRIu32"\n",
3630  AV_RB32(klv.key + 12));
3631  goto skip;
3632  }
3633 
3634  st = s->streams[index];
3635  track = st->priv_data;
3636 
3637  if (s->streams[index]->discard == AVDISCARD_ALL)
3638  goto skip;
3639 
3640  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3641 
3642  if (track->wrapping != FrameWrapped) {
3643  int64_t size;
3644 
3645  if (next_ofs <= 0) {
3646  // If we have no way to packetize the data, then return it in chunks...
3647  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3649  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3650  }
3651  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3652  } else {
3653  if ((size = next_ofs - pos) <= 0) {
3654  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3655  mxf->current_klv_data = (KLVPacket){{0}};
3656  return AVERROR_INVALIDDATA;
3657  }
3658  // We must not overread, because the next edit unit might be in another KLV
3659  if (size > max_data_size)
3660  size = max_data_size;
3661  }
3662 
3663  mxf->current_klv_data = klv;
3664  klv.offset = pos;
3665  klv.length = size;
3666  klv.next_klv = klv.offset + klv.length;
3667  }
3668 
3669  /* check for 8 channels AES3 element */
3670  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3671  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3672  pkt, klv.length);
3673  if (ret < 0) {
3674  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3675  mxf->current_klv_data = (KLVPacket){{0}};
3676  return ret;
3677  }
3678  } else if (mxf->eia608_extract &&
3679  s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3680  ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3681  if (ret < 0) {
3682  mxf->current_klv_data = (KLVPacket){{0}};
3683  return ret;
3684  }
3685  } else {
3686  ret = av_get_packet(s->pb, pkt, klv.length);
3687  if (ret < 0) {
3688  mxf->current_klv_data = (KLVPacket){{0}};
3689  return ret;
3690  }
3691  }
3692  pkt->stream_index = index;
3693  pkt->pos = klv.offset;
3694 
3695  ret = mxf_set_pts(mxf, st, pkt);
3696  if (ret < 0) {
3697  mxf->current_klv_data = (KLVPacket){{0}};
3698  return ret;
3699  }
3700 
3701  /* seek for truncated packets */
3702  avio_seek(s->pb, klv.next_klv, SEEK_SET);
3703 
3704  return 0;
3705  } else {
3706  skip:
3707  avio_skip(s->pb, max_data_size);
3708  mxf->current_klv_data = (KLVPacket){{0}};
3709  }
3710  }
3711  return avio_feof(s->pb) ? AVERROR_EOF : ret;
3712 }
3713 
3715 {
3716  MXFContext *mxf = s->priv_data;
3717  int i;
3718 
3719  av_freep(&mxf->packages_refs);
3721 
3722  for (i = 0; i < s->nb_streams; i++)
3723  s->streams[i]->priv_data = NULL;
3724 
3725  for (i = 0; i < mxf->metadata_sets_count; i++) {
3726  mxf_free_metadataset(mxf->metadata_sets + i, 1);
3727  }
3728  mxf->metadata_sets_count = 0;
3729  av_freep(&mxf->partitions);
3730  av_freep(&mxf->metadata_sets);
3731  av_freep(&mxf->aesc);
3732  av_freep(&mxf->local_tags);
3733 
3734  if (mxf->index_tables) {
3735  for (i = 0; i < mxf->nb_index_tables; i++) {
3736  av_freep(&mxf->index_tables[i].segments);
3737  av_freep(&mxf->index_tables[i].ptses);
3738  av_freep(&mxf->index_tables[i].fake_index);
3739  av_freep(&mxf->index_tables[i].offsets);
3740  }
3741  }
3742  av_freep(&mxf->index_tables);
3743 
3744  return 0;
3745 }
3746 
3747 static int mxf_probe(const AVProbeData *p) {
3748  const uint8_t *bufp = p->buf;
3749  const uint8_t *end = p->buf + p->buf_size;
3750 
3751  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3752  return 0;
3753 
3754  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3755  end -= sizeof(mxf_header_partition_pack_key);
3756 
3757  for (; bufp < end;) {
3758  if (!((bufp[13] - 1) & 0xF2)){
3759  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3760  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3761  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3763  return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
3764  bufp ++;
3765  } else
3766  bufp += 10;
3767  }
3768 
3769  return 0;
3770 }
3771 
3772 /* rudimentary byte seek */
3773 /* XXX: use MXF Index */
3774 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3775 {
3776  AVStream *st = s->streams[stream_index];
3777  int64_t seconds;
3778  MXFContext* mxf = s->priv_data;
3779  int64_t seekpos;
3780  int i, ret;
3781  MXFIndexTable *t;
3782  MXFTrack *source_track = st->priv_data;
3783 
3784  if (!source_track)
3785  return 0;
3786 
3787  /* if audio then truncate sample_time to EditRate */
3789  sample_time = av_rescale_q(sample_time, st->time_base,
3790  av_inv_q(source_track->edit_rate));
3791 
3792  if (mxf->nb_index_tables <= 0) {
3793  if (!s->bit_rate)
3794  return AVERROR_INVALIDDATA;
3795  if (sample_time < 0)
3796  sample_time = 0;
3797  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3798 
3799  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3800  if (seekpos < 0)
3801  return seekpos;
3802 
3803  ff_update_cur_dts(s, st, sample_time);
3804  mxf->current_klv_data = (KLVPacket){{0}};
3805  } else {
3806  MXFPartition *partition;
3807 
3808  t = &mxf->index_tables[0];
3809  if (t->index_sid != source_track->index_sid) {
3810  /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3811  for (i = 0; i < s->nb_streams; i++) {
3812  MXFTrack *new_source_track = s->streams[i]->priv_data;
3813  if (new_source_track && new_source_track->index_sid == t->index_sid) {
3814  sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3815  source_track = new_source_track;
3816  st = s->streams[i];
3817  break;
3818  }
3819  }
3820  if (i == s->nb_streams)
3821  return AVERROR_INVALIDDATA;
3822  }
3823 
3824  /* clamp above zero, else ff_index_search_timestamp() returns negative
3825  * this also means we allow seeking before the start */
3826  sample_time = FFMAX(sample_time, 0);
3827 
3828  if (t->fake_index) {
3829  /* The first frames may not be keyframes in presentation order, so
3830  * we have to advance the target to be able to find the first
3831  * keyframe backwards... */
3832  if (!(flags & AVSEEK_FLAG_ANY) &&
3833  (flags & AVSEEK_FLAG_BACKWARD) &&
3834  t->ptses[0] != AV_NOPTS_VALUE &&
3835  sample_time < t->ptses[0] &&
3836  (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3837  sample_time = t->ptses[0];
3838 
3839  /* behave as if we have a proper index */
3840  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3841  return sample_time;
3842  /* get the stored order index from the display order index */
3843  sample_time += t->offsets[sample_time];
3844  } else {
3845  /* no IndexEntryArray (one or more CBR segments)
3846  * make sure we don't seek past the end */
3847  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3848  }
3849 
3850  if (source_track->wrapping == UnknownWrapped)
3851  av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3852 
3853  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3854  return ret;
3855 
3856  ff_update_cur_dts(s, st, sample_time);
3857  if (source_track->wrapping == ClipWrapped) {
3858  KLVPacket klv = partition->first_essence_klv;
3859  if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3860  av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3861  return AVERROR_INVALIDDATA;
3862  }
3863  mxf->current_klv_data = klv;
3864  } else {
3865  mxf->current_klv_data = (KLVPacket){{0}};
3866  }
3867  avio_seek(s->pb, seekpos, SEEK_SET);
3868  }
3869 
3870  // Update all tracks sample count
3871  for (i = 0; i < s->nb_streams; i++) {
3872  AVStream *cur_st = s->streams[i];
3873  MXFTrack *cur_track = cur_st->priv_data;
3874  if (cur_track) {
3875  int64_t track_edit_unit = sample_time;
3876  if (st != cur_st)
3877  mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3878  cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3879  }
3880  }
3881  return 0;
3882 }
3883 
3884 static const AVOption options[] = {
3885  { "eia608_extract", "extract eia 608 captions from s436m track",
3886  offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3888  { NULL },
3889 };
3890 
3891 static const AVClass demuxer_class = {
3892  .class_name = "mxf",
3893  .item_name = av_default_item_name,
3894  .option = options,
3895  .version = LIBAVUTIL_VERSION_INT,
3896  .category = AV_CLASS_CATEGORY_DEMUXER,
3897 };
3898 
3900  .name = "mxf",
3901  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3902  .flags = AVFMT_SEEK_TO_PTS,
3903  .priv_data_size = sizeof(MXFContext),
3904  .read_probe = mxf_probe,
3909  .priv_class = &demuxer_class,
3910 };
static const uint8_t mxf_crypto_source_container_ul[]
Definition: mxfdec.c:328
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:568
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
#define FF_MXF_MasteringDisplay_PREFIX
Definition: mxf.h:88
AVContentLightMetadata * coll
Definition: mxfdec.c:219
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2411
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:805
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:2270
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
MXFMetadataSetType
Definition: mxf.h:30
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
uint8_t origin
Definition: mxfdec.c:133
unsigned int component_depth
Definition: mxfdec.c:203
KLVPacket current_klv_data
Definition: mxfdec.c:295
static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
Definition: mxfdec.c:478
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1117
Definition: mxf.h:39
int index_sid
Definition: mxfdec.c:178
AVTimecode tc
Definition: mxfdec.c:142
unsigned MaxCLL
Max content light level (cd/m^2).
AVOption.
Definition: opt.h:248
UID * comment_refs
Definition: mxfdec.c:248
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
Definition: mxfdec.c:2829
int structural_components_count
Definition: mxfdec.c:155
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:147
int index_sid
Definition: mxfdec.c:268
static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
Definition: mxfdec.c:422
UID * structural_components_refs
Definition: mxfdec.c:130
MXFOP
Definition: mxfdec.c:70
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition and parses it, if possible.
Definition: mxfdec.c:2996
int edit_unit_byte_count
Definition: mxfdec.c:226
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
enum MXFMetadataSetType type
Definition: mxfdec.c:117
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:103
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4905
int64_t * ptses
Definition: mxfdec.c:272
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2413
UID * structural_components_refs
Definition: mxfdec.c:154
UID sequence_ref
Definition: mxfdec.c:170
static void mxf_read_random_index_pack(AVFormatContext *s)
Definition: mxfdec.c:3266
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
#define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str)
Definition: mxfdec.c:2751
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
#define MXF_MAX_CHUNK_SIZE
Definition: mxfdec.c:62
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:885
#define SET_TS_METADATA(pb, name, var, str)
Definition: mxfdec.c:2769
int size
Definition: packet.h:364
Definition: mxf.h:34
uint64_t footer_partition
Definition: mxfdec.c:294
int closed
Definition: mxfdec.c:91
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
enum MXFMetadataSetType type
Definition: mxfdec.c:313
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: aes.c:163
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mxfdec.c:3774
static int mxf_uid_to_str(UID uid, char **str)
Definition: mxfdec.c:1942
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:102
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1365
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
Definition: mxfdec.c:554
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
MXFSequence * sequence
Definition: mxfdec.c:169
#define tc
Definition: regdef.h:69
int linked_track_id
Definition: mxfdec.c:211
UID key
Definition: mxf.h:68
static int mxf_umid_to_str(UID ul, UID uid, char **str)
Definition: mxfdec.c:1960
int64_t offset
Definition: mxf.h:69
GLint GLenum type
Definition: opengl_enc.c:104
static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set)
Definition: mxfdec.c:847
void * priv_data
Definition: avformat.h:899
static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
Deal with the case where for some audio atoms EditUnitByteCount is very small (2, 4...
Definition: mxfdec.c:3167
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
MXFWrappingScheme wrapping
Definition: mxfdec.c:180
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
const char * key
#define FF_MXF_MasteringDisplayWhitePointChromaticity
Definition: mxf.h:90
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static const uint8_t mxf_apple_coll_max_cll[]
Definition: mxfdec.c:336
char * name
Definition: mxfdec.c:162
discard all
Definition: avcodec.h:236
static AVPacket pkt
#define MXF_FIELD_DOMINANCE_DEFAULT
Definition: mxfdec.c:196
Definition: mxfdec.c:77
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition: utils.c:2000
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:770
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition: mxfdec.c:1934
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:91
#define sample
static int mxf_read_header(AVFormatContext *s)
Definition: mxfdec.c:3320
UID source_container_ul
Definition: mxfdec.c:112
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
const MXFCodecUL ff_mxf_color_space_uls[]
Definition: mxf.c:127
int id
Definition: mxf.h:100
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
Definition: mxf.h:78
static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1068
int edit_units_per_packet
Definition: mxfdec.c:181
static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read, int ctx_size, enum MXFMetadataSetType type)
Parses a metadata KLV.
Definition: mxfdec.c:2965
MXFWrappingIndicatorType wrapping_indicator_type
Definition: mxf.h:103
enum AVColorSpace color_space
Definition: codec_par.h:149
unsigned int black_ref_level
Definition: mxfdec.c:204
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
Definition: mxfdec.c:1656
enum MXFMetadataSetType type
Definition: mxfdec.c:186
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that&#39;s been allocated with av_malloc() or another memory allocation function...
Definition: dict.h:73
static const uint8_t index_table[8]
Definition: siren.c:33
Definition: mxfdec.c:76
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
Definition: mxfdec.c:3090
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition: mxfdec.c:2886
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:3587
Format I/O context.
Definition: avformat.h:1243
Definition: mxfdec.c:74
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:3147
uint8_t UID[16]
Definition: mxf.h:28
int frame_layout
Definition: mxfdec.c:194
UID uid
Definition: mxfenc.c:2204
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1905
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
const UID container_ul
Definition: mxfenc.c:2117
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfdec.c:334
Definition: mxfdec.c:67
static const uint8_t mxf_mastering_display_prefix[13]
Definition: mxfdec.c:339
UID * packages_refs
Definition: mxfdec.c:284
#define MXF_FIELD_DOMINANCE_FF
Definition: mxfdec.c:197
uint8_t
UID * tracks_refs
Definition: mxfdec.c:243
#define av_malloc(s)
int64_t first_dts
Definition: mxfdec.c:271
Opaque data information usually continuous.
Definition: avutil.h:203
static const uint8_t mxf_avid_essence_element_key[]
Definition: mxfdec.c:321
int bits_per_sample
Definition: mxfdec.c:201
int width
Video only.
Definition: codec_par.h:126
AVOptions.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:785
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
timecode is drop frame
Definition: timecode.h:36
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
AVRational index_edit_rate
Definition: mxfdec.c:229
enum AVStreamParseType need_parsing
Definition: avformat.h:1092
int id
Format-specific stream ID.
Definition: avformat.h:891
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:3714
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
Definition: mxf.h:67
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4481
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
Definition: mxfdec.c:1990
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:91
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1311
unsigned wrapping_indicator_pos
Definition: mxf.h:102
#define UID_ARG(x)
Definition: mxf.h:124
int complete
Definition: mxfdec.c:92
static const uint8_t mxf_klv_key[]
Definition: mxfdec.c:325
#define av_clip
Definition: common.h:122
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:307
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
Definition: mxfdec.c:1826
MXFIndexTableSegment ** segments
Definition: mxfdec.c:274
const MXFCodecUL ff_mxf_codec_uls[]
Definition: mxf.c:39
uint8_t * data
Definition: packet.h:363
static const uint8_t mxf_sony_mpeg4_extradata[]
Definition: mxfdec.c:331
uint32_t tag
Definition: movenc.c:1597
static const uint8_t mxf_apple_coll_prefix[]
Definition: mxfdec.c:326
#define AVERROR_EOF
End of file.
Definition: error.h:55
static const uint8_t mxf_avid_project_name[]
Definition: mxfdec.c:332
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:310
Definition: mxfdec.c:72
Definition: ismindex.c:69
AVColorRange
Visual content value range.
Definition: pixfmt.h:551
ptrdiff_t size
Definition: opengl_enc.c:100
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str, int be)
Definition: mxfdec.c:886
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:906
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition: mxfdec.c:1436
unsigned int vert_subsampling
Definition: mxfdec.c:208
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
int intra_only
Definition: mxfdec.c:175
#define MXF_FIELD_DOMINANCE_FL
Definition: mxfdec.c:198
#define av_log(a,...)
int32_t kag_size
Definition: mxfdec.c:100
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
Definition: mxfdec.c:1508
static MXFDescriptor * mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
Definition: mxfdec.c:2047
uint8_t track_number[4]
Definition: mxfdec.c:173
int64_t original_duration
Definition: mxfdec.c:177
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:219
#define SET_UID_METADATA(pb, name, var, str)
Definition: mxfdec.c:2762
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:409
static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
Definition: mxfdec.c:2246
#define AVINDEX_KEYFRAME
Definition: avformat.h:820
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
Definition: mxfdec.c:3466
int metadata_sets_count
Definition: mxfdec.c:289
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
UID essence_container_ul
Definition: mxfdec.c:187
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
Definition: mxfdec.c:441
const MXFCodecUL ff_mxf_color_primaries_uls[]
Definition: mxf.c:91
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
int64_t start_position
Definition: mxfdec.c:122
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int last_forward_partition
Definition: mxfdec.c:300
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1610
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1483
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:958
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:3108
MXFPartitionType
Definition: mxfdec.c:64
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
Definition: mxfdec.c:1154
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:2010
UID essence_codec_ul
Definition: mxfdec.c:188
int8_t * temporal_offset_entries
Definition: mxfdec.c:232
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
Definition: mxfdec.c:2002
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1010
UID color_trc_ul
Definition: mxfdec.c:216
MXFDescriptor * descriptor
Definition: mxfdec.c:245
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:814
uint64_t index_start_position
Definition: mxfdec.c:230
int nb_ptses
Definition: mxfdec.c:270
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
Definition: mxfdec.c:1087
unsigned matching_len
Definition: mxf.h:99
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
Definition: mxfdec.c:1442
Definition: mxf.h:57
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
const char * arg
Definition: jacosubdec.c:66
uint64_t length
Definition: mxf.h:70
static const MXFCodecUL mxf_sound_essence_container_uls[]
Definition: mxfdec.c:1457
simple assert() macros that are a bit more flexible than ISO C assert().
GLsizei GLsizei * length
Definition: opengl_enc.c:114
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
Definition: mxfdec.c:3047
#define IS_KLV_KEY(x, y)
Definition: mxfdec.c:347
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:31
int track_id
Definition: mxfdec.c:171
GLsizei count
Definition: opengl_enc.c:108
UID package_uid
Definition: mxfdec.c:241
#define FF_MXF_MasteringDisplayPrimaries
Definition: mxf.h:89
#define FFMAX(a, b)
Definition: common.h:103
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
int64_t essence_length
Definition: mxfdec.c:99
#define fail()
Definition: checkasm.h:133
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc(void)
Copyright (c) 2016 Neil Birkbeck neil.birkbeck@gmail.com
const uint8_t ff_mxf_random_index_pack_key[16]
Definition: mxf.c:25
static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1044
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:936
int64_t duration
Definition: mxfdec.c:132
int video_line_map[2]
Definition: mxfdec.c:195
static int mxf_match_uid(const UID key, const UID uid, int len)
Definition: mxfdec.c:1379
int packages_count
Definition: mxfdec.c:285
Only parse headers, do not repack.
Definition: avformat.h:804
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:2100
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
int64_t index_byte_count
Definition: mxfdec.c:102
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition: mxf.c:171
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
UID color_space_ul
Definition: mxfdec.c:217
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition: mxf.c:80
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
static int mxf_probe(const AVProbeData *p)
Definition: mxfdec.c:3747
Definition: hls.c:68
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1299
int nb_segments
Definition: mxfdec.c:273
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: utils.c:5330
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition: mxfdec.c:1389
static const uint8_t mxf_jp2k_rsiz[]
Definition: mxfdec.c:333
MXFPartition * partitions
Definition: mxfdec.c:281
int8_t * offsets
Definition: mxfdec.c:276