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