FFmpeg
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  * SMPTE 2067-21 Interoperable Master Format — Application #2E
32  *
33  * Principle
34  * Search for Track numbers which will identify essence element KLV packets.
35  * Search for SourcePackage which define tracks which contains Track numbers.
36  * Material Package contains tracks with reference to SourcePackage tracks.
37  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
38  * Assign Descriptors to correct Tracks.
39  *
40  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
41  * Metadata parsing resolves Strong References to objects.
42  *
43  * Simple demuxer, only OP1A supported and some files might not work at all.
44  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
45  */
46 
47 #include <inttypes.h>
48 #include <time.h>
49 
50 #include "libavutil/aes.h"
51 #include "libavutil/avstring.h"
53 #include "libavutil/mathematics.h"
54 #include "libavutil/mem.h"
55 #include "libavcodec/bytestream.h"
56 #include "libavcodec/defs.h"
57 #include "libavcodec/internal.h"
60 #include "libavutil/intreadwrite.h"
61 #include "libavutil/parseutils.h"
62 #include "libavutil/timecode.h"
63 #include "libavutil/opt.h"
64 #include "avformat.h"
65 #include "avlanguage.h"
66 #include "demux.h"
67 #include "internal.h"
68 #include "mxf.h"
69 
70 #define MXF_MAX_CHUNK_SIZE (32 << 20)
71 #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
72 
73 typedef enum {
78 
79 typedef enum {
80  OP1a = 1,
90  OPSONYOpt, /* FATE sample, violates the spec in places */
91 } MXFOP;
92 
93 typedef enum {
98 
99 typedef struct MXFPartition {
100  int closed;
101  int complete;
105  int body_sid;
106  int64_t essence_offset; ///< absolute offset of essence
112  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
115 } MXFPartition;
116 
117 typedef struct MXFMetadataSet {
119  uint64_t partition_score;
121 
122 typedef struct MXFMetadataSetGroup {
126 
127 typedef struct MXFCryptoContext {
131 
132 typedef struct MXFStructuralComponent {
141 
142 typedef struct MXFSequence {
148  uint8_t origin;
149 } MXFSequence;
150 
151 typedef struct MXFTimecodeComponent {
155  struct AVRational rate;
158 
159 typedef struct {
163 
164 typedef struct {
170 
171 typedef struct {
173  char *name;
174  char *value;
176 
177 typedef struct {
179  MXFSequence *sequence; /* mandatory, and only one */
181  int track_id;
182  char *name;
183  uint8_t track_number[4];
186  uint64_t sample_count;
187  int64_t original_duration; /* st->duration in SampleRate/EditRate units */
189  int body_sid;
191  int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
192 } MXFTrack;
193 
194 typedef struct MXFDescriptor {
201  int width;
202  int height; /* Field height, not frame height */
203  int frame_layout; /* See MXFFrameLayout enum */
205 #define MXF_FIELD_DOMINANCE_DEFAULT 0
206 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
207 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
209  int channels;
211  int64_t duration; /* ContainerDuration optional property */
212  unsigned int component_depth;
213  unsigned int black_ref_level;
214  unsigned int white_ref_level;
215  unsigned int color_range;
216  unsigned int horiz_subsampling;
217  unsigned int vert_subsampling;
223  uint8_t *extradata;
232  size_t coll_size;
233 } MXFDescriptor;
234 
235 typedef struct MXFMCASubDescriptor {
244  char *language;
246 
247 typedef struct MXFFFV1SubDescriptor {
249  uint8_t *extradata;
252 
253 typedef struct MXFIndexTableSegment {
257  int body_sid;
260  uint64_t index_duration;
266 
267 typedef struct MXFPackage {
274  char *name;
277 } MXFPackage;
278 
279 typedef struct MXFEssenceContainerData {
284  int body_sid;
286 
287 /* decoded index table */
288 typedef struct MXFIndexTable {
290  int body_sid;
291  int nb_ptses; /* number of PTSes or total duration of index */
292  int64_t first_dts; /* DTS = EditUnit + first_dts */
293  int64_t *ptses; /* maps EditUnit -> PTS */
295  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
296  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
297  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
298 } MXFIndexTable;
299 
300 typedef struct MXFContext {
301  const AVClass *class; /**< Class for private options. */
311  struct AVAES *aesc;
312  uint8_t *local_tags;
316  int run_in;
324 } MXFContext;
325 
326 /* NOTE: klv_offset is not set (-1) for local keys */
327 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
328 
330  const UID key;
332  int ctx_size;
335 
336 /* partial keys to match */
337 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
338 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
339 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
340 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
341 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
342 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
343 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
344 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
345 
346 /* complete keys to match */
347 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 };
348 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
349 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
350 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
351 static const uint8_t mxf_ffv1_extradata[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x04,0x01,0x06,0x0c,0x01,0x00,0x00,0x00 }; // FFV1InitializationMetadata
352 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
353 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00 };
354 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 };
355 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 };
356 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 };
357 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 };
358 
359 static const uint8_t mxf_mca_label_dictionary_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x01,0x00,0x00,0x00 };
360 static const uint8_t mxf_mca_tag_symbol[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x02,0x00,0x00,0x00 };
361 static const uint8_t mxf_mca_tag_name[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x03,0x00,0x00,0x00 };
362 static const uint8_t mxf_group_of_soundfield_groups_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x04,0x00,0x00,0x00 };
363 static const uint8_t mxf_mca_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x05,0x00,0x00,0x00 };
364 static const uint8_t mxf_mca_channel_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x04,0x0a,0x00,0x00,0x00,0x00 };
365 static const uint8_t mxf_soundfield_group_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x06,0x00,0x00,0x00 };
366 static const uint8_t mxf_mca_rfc5646_spoken_language[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0d,0x03,0x01,0x01,0x02,0x03,0x15,0x00,0x00 };
367 
368 static const uint8_t mxf_sub_descriptor[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00 };
369 
371 static const uint8_t mxf_mastering_display_uls[4][16] = {
376 };
377 
378 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
379 
381 {
383  switch (type) {
384  case Descriptor:
385  case MultipleDescriptor:
386  av_freep(&((MXFDescriptor *)*ctx)->extradata);
387  av_freep(&((MXFDescriptor *)*ctx)->mastering);
388  av_freep(&((MXFDescriptor *)*ctx)->coll);
389  av_freep(&((MXFDescriptor *)*ctx)->file_descriptors_refs);
390  av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
391  break;
392  case FFV1SubDescriptor:
393  av_freep(&((MXFFFV1SubDescriptor *)*ctx)->extradata);
394  break;
399  av_freep(&((MXFMCASubDescriptor *)*ctx)->group_of_soundfield_groups_link_id_refs);
400  break;
401  case Sequence:
402  av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
403  break;
404  case EssenceGroup:
405  av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
406  break;
407  case SourcePackage:
408  case MaterialPackage:
409  av_freep(&((MXFPackage *)*ctx)->tracks_refs);
410  av_freep(&((MXFPackage *)*ctx)->name);
411  av_freep(&((MXFPackage *)*ctx)->comment_refs);
412  break;
413  case TaggedValue:
414  av_freep(&((MXFTaggedValue *)*ctx)->name);
415  av_freep(&((MXFTaggedValue *)*ctx)->value);
416  break;
417  case Track:
418  av_freep(&((MXFTrack *)*ctx)->name);
419  break;
420  case IndexTableSegment:
421  seg = (MXFIndexTableSegment *)*ctx;
423  av_freep(&seg->flag_entries);
425  default:
426  break;
427  }
428  av_freep(ctx);
429 }
430 
432 {
433  uint64_t size = avio_r8(pb);
434  if (size & 0x80) { /* long form */
435  int bytes_num = size & 0x7f;
436  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
437  if (bytes_num > 8)
438  return AVERROR_INVALIDDATA;
439  size = 0;
440  while (bytes_num--)
441  size = size << 8 | avio_r8(pb);
442  }
443  if (size > INT64_MAX)
444  return AVERROR_INVALIDDATA;
445  return size;
446 }
447 
448 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
449 {
450  int i, b;
451  for (i = 0; i < size && !avio_feof(pb); i++) {
452  b = avio_r8(pb);
453  if (b == key[0])
454  i = 0;
455  else if (b != key[i])
456  i = -1;
457  }
458  return i == size;
459 }
460 
461 static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
462 {
463  int64_t length, pos;
464  if (!mxf_read_sync(pb, mxf_klv_key, 4))
465  return AVERROR_INVALIDDATA;
466  klv->offset = avio_tell(pb) - 4;
467  if (klv->offset < mxf->run_in)
468  return AVERROR_INVALIDDATA;
469 
470  memcpy(klv->key, mxf_klv_key, 4);
471  avio_read(pb, klv->key + 4, 12);
472  length = klv_decode_ber_length(pb);
473  if (length < 0)
474  return length;
475  klv->length = length;
476  pos = avio_tell(pb);
477  if (pos > INT64_MAX - length)
478  return AVERROR_INVALIDDATA;
479  klv->next_klv = pos + length;
480  return 0;
481 }
482 
483 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
484 {
485  int i;
486 
487  for (i = 0; i < s->nb_streams; i++) {
488  MXFTrack *track = s->streams[i]->priv_data;
489  /* SMPTE 379M 7.3 */
490  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)))
491  return i;
492  }
493  /* return 0 if only one stream, for OP Atom files with 0 as track number */
494  return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
495 }
496 
498 {
499  // we look for partition where the offset is placed
500  int a, b, m;
501  int64_t pack_ofs;
502 
503  a = -1;
504  b = mxf->partitions_count;
505 
506  while (b - a > 1) {
507  m = (a + b) >> 1;
508  pack_ofs = mxf->partitions[m].pack_ofs;
509  if (pack_ofs <= offset)
510  a = m;
511  else
512  b = m;
513  }
514 
515  if (a == -1)
516  return 0;
517  return mxf->partitions[a].body_sid;
518 }
519 
521 {
522  int count = avio_rb16(s->pb);
523  int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
524  int line_num, sample_coding, sample_count;
525  int did, sdid, data_length;
526  int i, ret;
527 
528  if (count > 1)
529  av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
530 
531  for (i = 0; i < count; i++) {
532  if (length < 6) {
533  av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
534  return AVERROR_INVALIDDATA;
535  }
536  line_num = avio_rb16(s->pb);
537  avio_r8(s->pb); // wrapping type
538  sample_coding = avio_r8(s->pb);
539  sample_count = avio_rb16(s->pb);
540  length -= 6 + 8 + sample_count;
541  if (line_num != 9 && line_num != 11)
542  continue;
543  if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
544  av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
545  continue;
546  }
547  if (length < 0)
548  return AVERROR_INVALIDDATA;
549 
550  avio_rb32(s->pb); // array count
551  avio_rb32(s->pb); // array elem size
552  did = avio_r8(s->pb);
553  sdid = avio_r8(s->pb);
554  data_length = avio_r8(s->pb);
555  if (did != 0x61 || sdid != 1) {
556  av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
557  continue;
558  }
559  cdp_identifier = avio_rb16(s->pb); // cdp id
560  if (cdp_identifier != 0x9669) {
561  av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
562  return AVERROR_INVALIDDATA;
563  }
564  cdp_length = avio_r8(s->pb);
565  avio_r8(s->pb); // cdp_frame_rate
566  avio_r8(s->pb); // cdp_flags
567  avio_rb16(s->pb); // cdp_hdr_sequence_cntr
568  ccdata_id = avio_r8(s->pb); // ccdata_id
569  if (ccdata_id != 0x72) {
570  av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
571  return AVERROR_INVALIDDATA;
572  }
573  cc_count = avio_r8(s->pb) & 0x1f;
574  ret = av_get_packet(s->pb, pkt, cc_count * 3);
575  if (ret < 0)
576  return ret;
577  if (cdp_length - 9 - 4 < cc_count * 3) {
578  av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
579  return AVERROR_INVALIDDATA;
580  }
581  avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
582  cdp_footer_id = avio_r8(s->pb);
583  if (cdp_footer_id != 0x74) {
584  av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
585  return AVERROR_INVALIDDATA;
586  }
587  avio_rb16(s->pb); // cdp_ftr_sequence_cntr
588  avio_r8(s->pb); // packet_checksum
589  break;
590  }
591 
592  return 0;
593 }
594 
595 /* XXX: use AVBitStreamFilter */
597 {
598  const uint8_t *buf_ptr, *end_ptr;
599  uint8_t *data_ptr;
600  int i;
601 
602  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
603  return AVERROR_INVALIDDATA;
604  length = av_get_packet(pb, pkt, length);
605  if (length < 0)
606  return length;
607  data_ptr = pkt->data;
608  end_ptr = pkt->data + length;
609  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
610 
611  if (st->codecpar->ch_layout.nb_channels > 8)
612  return AVERROR_INVALIDDATA;
613 
614  for (; end_ptr - buf_ptr >= st->codecpar->ch_layout.nb_channels * 4; ) {
615  for (i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {
616  uint32_t sample = bytestream_get_le32(&buf_ptr);
617  if (st->codecpar->bits_per_coded_sample == 24)
618  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
619  else
620  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
621  }
622  // always 8 channels stored SMPTE 331M
623  buf_ptr += 32 - st->codecpar->ch_layout.nb_channels * 4;
624  }
625  av_shrink_packet(pkt, data_ptr - pkt->data);
626  return 0;
627 }
628 
630 {
631  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
632  MXFContext *mxf = s->priv_data;
633  AVIOContext *pb = s->pb;
634  int64_t end = avio_tell(pb) + klv->length;
635  int64_t size;
636  uint64_t orig_size;
637  uint64_t plaintext_size;
638  uint8_t ivec[16];
639  uint8_t tmpbuf[16];
640  int index;
641  int body_sid;
642 
643  if (!mxf->aesc && s->key && s->keylen == 16) {
644  mxf->aesc = av_aes_alloc();
645  if (!mxf->aesc)
646  return AVERROR(ENOMEM);
647  av_aes_init(mxf->aesc, s->key, 128, 1);
648  }
649  // crypto context
651  if (size < 0)
652  return size;
653  avio_skip(pb, size);
654  // plaintext offset
656  plaintext_size = avio_rb64(pb);
657  // source klv key
659  avio_read(pb, klv->key, 16);
661  return AVERROR_INVALIDDATA;
662 
663  body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
664  index = mxf_get_stream_index(s, klv, body_sid);
665  if (index < 0)
666  return AVERROR_INVALIDDATA;
667  // source size
669  orig_size = avio_rb64(pb);
670  if (orig_size < plaintext_size)
671  return AVERROR_INVALIDDATA;
672  // enc. code
674  if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)
675  return AVERROR_INVALIDDATA;
676  avio_read(pb, ivec, 16);
677  avio_read(pb, tmpbuf, 16);
678  if (mxf->aesc)
679  av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
680  if (memcmp(tmpbuf, checkv, 16))
681  av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
682  size -= 32;
683  size = av_get_packet(pb, pkt, size);
684  if (size < 0)
685  return size;
686  else if (size < plaintext_size)
687  return AVERROR_INVALIDDATA;
688  size -= plaintext_size;
689  if (mxf->aesc)
690  av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
691  &pkt->data[plaintext_size], size >> 4, ivec, 1);
692  av_shrink_packet(pkt, orig_size);
694  avio_skip(pb, end - avio_tell(pb));
695  return 0;
696 }
697 
698 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
699 {
700  MXFContext *mxf = arg;
701  int item_num = avio_rb32(pb);
702  int item_len = avio_rb32(pb);
703 
704  if (item_len != 18) {
705  avpriv_request_sample(pb, "Primer pack item length %d", item_len);
706  return AVERROR_PATCHWELCOME;
707  }
708  if (item_num > 65536 || item_num < 0) {
709  av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
710  return AVERROR_INVALIDDATA;
711  }
712  if (mxf->local_tags)
713  av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
714  av_free(mxf->local_tags);
715  mxf->local_tags_count = 0;
716  mxf->local_tags = av_calloc(item_num, item_len);
717  if (!mxf->local_tags)
718  return AVERROR(ENOMEM);
719  mxf->local_tags_count = item_num;
720  avio_read(pb, mxf->local_tags, item_num*item_len);
721  return 0;
722 }
723 
724 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
725 {
726  MXFContext *mxf = arg;
727  AVFormatContext *s = mxf->fc;
728  MXFPartition *partition, *tmp_part;
729  UID op;
730  uint64_t footer_partition;
731  uint32_t nb_essence_containers;
732  uint64_t this_partition;
733 
734  if (mxf->partitions_count >= INT_MAX / 2)
735  return AVERROR_INVALIDDATA;
736 
737  av_assert0(klv_offset >= mxf->run_in);
738 
739  tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
740  if (!tmp_part)
741  return AVERROR(ENOMEM);
742  mxf->partitions = tmp_part;
743 
744  if (mxf->parsing_backward) {
745  /* insert the new partition pack in the middle
746  * this makes the entries in mxf->partitions sorted by offset */
747  memmove(&mxf->partitions[mxf->last_forward_partition+1],
749  (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
750  partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
751  } else {
752  mxf->last_forward_partition++;
753  partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
754  }
755 
756  memset(partition, 0, sizeof(*partition));
757  mxf->partitions_count++;
758  partition->pack_length = avio_tell(pb) - klv_offset + size;
759  partition->pack_ofs = klv_offset;
760 
761  switch(uid[13]) {
762  case 2:
763  partition->type = Header;
764  break;
765  case 3:
766  partition->type = BodyPartition;
767  break;
768  case 4:
769  partition->type = Footer;
770  break;
771  default:
772  av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
773  return AVERROR_INVALIDDATA;
774  }
775 
776  /* consider both footers to be closed (there is only Footer and CompleteFooter) */
777  partition->closed = partition->type == Footer || !(uid[14] & 1);
778  partition->complete = uid[14] > 2;
779  avio_skip(pb, 4);
780  partition->kag_size = avio_rb32(pb);
781  this_partition = avio_rb64(pb);
782  if (this_partition != klv_offset - mxf->run_in) {
783  av_log(mxf->fc, AV_LOG_ERROR,
784  "this_partition %"PRId64" mismatches %"PRId64"\n",
785  this_partition, klv_offset - mxf->run_in);
786  return AVERROR_INVALIDDATA;
787  }
788  partition->previous_partition = avio_rb64(pb);
789  footer_partition = avio_rb64(pb);
790  partition->header_byte_count = avio_rb64(pb);
791  partition->index_byte_count = avio_rb64(pb);
792  partition->index_sid = avio_rb32(pb);
793  partition->body_offset = avio_rb64(pb);
794  partition->body_sid = avio_rb32(pb);
795  if (partition->body_offset < 0)
796  return AVERROR_INVALIDDATA;
797 
798  if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
799  av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
800  return AVERROR_INVALIDDATA;
801  }
802  nb_essence_containers = avio_rb32(pb);
803 
804  if (partition->type == Header) {
805  char str[36];
806  snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));
807  av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);
808  }
809 
810  if (this_partition &&
811  partition->previous_partition == this_partition) {
812  av_log(mxf->fc, AV_LOG_ERROR,
813  "PreviousPartition equal to ThisPartition %"PRIx64"\n",
814  partition->previous_partition);
815  /* override with the actual previous partition offset */
816  if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
817  MXFPartition *prev =
818  mxf->partitions + mxf->last_forward_partition - 2;
819  partition->previous_partition = prev->pack_ofs - mxf->run_in;
820  }
821  /* if no previous body partition are found point to the header
822  * partition */
823  if (partition->previous_partition == this_partition)
824  partition->previous_partition = 0;
825  av_log(mxf->fc, AV_LOG_ERROR,
826  "Overriding PreviousPartition with %"PRIx64"\n",
827  partition->previous_partition);
828  }
829 
830  /* some files don't have FooterPartition set in every partition */
831  if (footer_partition) {
832  if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
833  av_log(mxf->fc, AV_LOG_ERROR,
834  "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
835  mxf->footer_partition, footer_partition);
836  } else {
837  mxf->footer_partition = footer_partition;
838  }
839  }
840 
841  av_log(mxf->fc, AV_LOG_TRACE,
842  "PartitionPack: ThisPartition = 0x%"PRIX64
843  ", PreviousPartition = 0x%"PRIX64", "
844  "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
845  this_partition,
846  partition->previous_partition, footer_partition,
847  partition->index_sid, partition->body_sid);
848 
849  /* sanity check PreviousPartition if set */
850  //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
851  if (partition->previous_partition &&
852  mxf->run_in + partition->previous_partition >= klv_offset) {
853  av_log(mxf->fc, AV_LOG_ERROR,
854  "PreviousPartition points to this partition or forward\n");
855  return AVERROR_INVALIDDATA;
856  }
857 
858  if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
859  else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
860  else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
861  else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
862  else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
863  else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
864  else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
865  else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
866  else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
867  else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
868  else if (op[12] == 0x10) {
869  /* SMPTE 390m: "There shall be exactly one essence container"
870  * The following block deals with files that violate this, namely:
871  * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
872  * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
873  if (nb_essence_containers != 1) {
874  MXFOP op = nb_essence_containers ? OP1a : OPAtom;
875 
876  /* only nag once */
877  if (!mxf->op)
878  av_log(mxf->fc, AV_LOG_WARNING,
879  "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
880  nb_essence_containers,
881  op == OP1a ? "OP1a" : "OPAtom");
882 
883  mxf->op = op;
884  } else
885  mxf->op = OPAtom;
886  } else {
887  av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
888  mxf->op = OP1a;
889  }
890 
891  if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
892  av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
893  partition->kag_size);
894 
895  if (mxf->op == OPSONYOpt)
896  partition->kag_size = 512;
897  else
898  partition->kag_size = 1;
899 
900  av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
901  }
902 
903  return 0;
904 }
905 
906 static uint64_t partition_score(MXFPartition *p)
907 {
908  uint64_t score;
909  if (!p)
910  return 0;
911  if (p->type == Footer)
912  score = 5;
913  else if (p->complete)
914  score = 4;
915  else if (p->closed)
916  score = 3;
917  else
918  score = 1;
919  return (score << 60) | ((uint64_t)p->pack_ofs >> 4);
920 }
921 
923 {
925  int ret;
926 
927  // Index Table is special because it might be added manually without
928  // partition and we iterate thorugh all instances of them. Also some files
929  // use the same Instance UID for different index tables...
930  if (type != IndexTableSegment) {
931  for (int i = 0; i < mg->metadata_sets_count; i++) {
932  if (!memcmp((*metadata_set)->uid, mg->metadata_sets[i]->uid, 16)) {
933  uint64_t old_s = mg->metadata_sets[i]->partition_score;
934  uint64_t new_s = (*metadata_set)->partition_score;
935  if (old_s > new_s) {
936  mxf_free_metadataset(metadata_set, type);
937  return 0;
938  }
939  }
940  }
941  }
942 
943  ret = av_dynarray_add_nofree(&mg->metadata_sets, &mg->metadata_sets_count, *metadata_set);
944  if (ret < 0) {
945  mxf_free_metadataset(metadata_set, type);
946  return ret;
947  }
948  return 0;
949 }
950 
951 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
952 {
953  MXFCryptoContext *cryptocontext = arg;
954  if (size != 16)
955  return AVERROR_INVALIDDATA;
957  avio_read(pb, cryptocontext->source_container_ul, 16);
958  return 0;
959 }
960 
961 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
962 {
963  int64_t ret;
964  unsigned c = avio_rb32(pb);
965 
966  //avio_read() used int
967  if (c > INT_MAX / sizeof(UID))
968  return AVERROR_PATCHWELCOME;
969  *count = c;
970 
971  av_free(*refs);
972  *refs = av_malloc_array(*count, sizeof(UID));
973  if (!*refs) {
974  *count = 0;
975  return AVERROR(ENOMEM);
976  }
977  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
978  ret = avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
979  if (ret != *count * sizeof(UID)) {
980  *count = ret < 0 ? 0 : ret / sizeof(UID);
981  return ret < 0 ? ret : AVERROR_INVALIDDATA;
982  }
983 
984  return 0;
985 }
986 
987 static inline int mxf_read_us_ascii_string(AVIOContext *pb, int size, char** str)
988 {
989  int ret;
990  size_t buf_size;
991 
992  if (size < 0 || size > INT_MAX - 1)
993  return AVERROR(EINVAL);
994 
995  buf_size = size + 1;
996  av_free(*str);
997  *str = av_malloc(buf_size);
998  if (!*str)
999  return AVERROR(ENOMEM);
1000 
1001  ret = avio_get_str(pb, size, *str, buf_size);
1002 
1003  if (ret < 0) {
1004  av_freep(str);
1005  return ret;
1006  }
1007 
1008  return ret;
1009 }
1010 
1011 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
1012 {
1013  int ret;
1014  size_t buf_size;
1015 
1016  if (size < 0 || size > INT_MAX/2)
1017  return AVERROR(EINVAL);
1018 
1019  buf_size = size + size / 2 + 1;
1020  av_free(*str);
1021  *str = av_malloc(buf_size);
1022  if (!*str)
1023  return AVERROR(ENOMEM);
1024 
1025  if (be)
1026  ret = avio_get_str16be(pb, size, *str, buf_size);
1027  else
1028  ret = avio_get_str16le(pb, size, *str, buf_size);
1029 
1030  if (ret < 0) {
1031  av_freep(str);
1032  return ret;
1033  }
1034 
1035  return ret;
1036 }
1037 
1038 #define READ_STR16(type, big_endian) \
1039 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
1040 { \
1041 return mxf_read_utf16_string(pb, size, str, big_endian); \
1042 }
1043 READ_STR16(be, 1)
1044 READ_STR16(le, 0)
1045 #undef READ_STR16
1046 
1047 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1048 {
1049  MXFContext *mxf = arg;
1050  switch (tag) {
1051  case 0x1901:
1052  if (mxf->packages_refs)
1053  av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
1054  return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
1055  case 0x1902:
1057  }
1058  return 0;
1059 }
1060 
1061 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1062 {
1063  MXFStructuralComponent *source_clip = arg;
1064  switch(tag) {
1065  case 0x0202:
1066  source_clip->duration = avio_rb64(pb);
1067  break;
1068  case 0x1201:
1069  source_clip->start_position = avio_rb64(pb);
1070  break;
1071  case 0x1101:
1072  /* UMID, only get last 16 bytes */
1073  avio_read(pb, source_clip->source_package_ul, 16);
1074  avio_read(pb, source_clip->source_package_uid, 16);
1075  break;
1076  case 0x1102:
1077  source_clip->source_track_id = avio_rb32(pb);
1078  break;
1079  }
1080  return 0;
1081 }
1082 
1083 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1084 {
1085  MXFTimecodeComponent *mxf_timecode = arg;
1086  switch(tag) {
1087  case 0x1501:
1088  mxf_timecode->start_frame = avio_rb64(pb);
1089  break;
1090  case 0x1502:
1091  mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
1092  break;
1093  case 0x1503:
1094  mxf_timecode->drop_frame = avio_r8(pb);
1095  break;
1096  }
1097  return 0;
1098 }
1099 
1100 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1101 {
1102  MXFPulldownComponent *mxf_pulldown = arg;
1103  switch(tag) {
1104  case 0x0d01:
1105  avio_read(pb, mxf_pulldown->input_segment_ref, 16);
1106  break;
1107  }
1108  return 0;
1109 }
1110 
1111 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1112 {
1113  MXFTrack *track = arg;
1114  switch(tag) {
1115  case 0x4801:
1116  track->track_id = avio_rb32(pb);
1117  break;
1118  case 0x4804:
1119  avio_read(pb, track->track_number, 4);
1120  break;
1121  case 0x4802:
1122  mxf_read_utf16be_string(pb, size, &track->name);
1123  break;
1124  case 0x4b01:
1125  track->edit_rate.num = avio_rb32(pb);
1126  track->edit_rate.den = avio_rb32(pb);
1127  break;
1128  case 0x4803:
1129  avio_read(pb, track->sequence_ref, 16);
1130  break;
1131  }
1132  return 0;
1133 }
1134 
1135 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1136 {
1137  MXFSequence *sequence = arg;
1138  switch(tag) {
1139  case 0x0202:
1140  sequence->duration = avio_rb64(pb);
1141  break;
1142  case 0x0201:
1143  avio_read(pb, sequence->data_definition_ul, 16);
1144  break;
1145  case 0x4b02:
1146  sequence->origin = avio_r8(pb);
1147  break;
1148  case 0x1001:
1150  &sequence->structural_components_count);
1151  }
1152  return 0;
1153 }
1154 
1155 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1156 {
1157  MXFEssenceGroup *essence_group = arg;
1158  switch (tag) {
1159  case 0x0202:
1160  essence_group->duration = avio_rb64(pb);
1161  break;
1162  case 0x0501:
1163  return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
1164  &essence_group->structural_components_count);
1165  }
1166  return 0;
1167 }
1168 
1169 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1170 {
1171  MXFPackage *package = arg;
1172  switch(tag) {
1173  case 0x4403:
1174  return mxf_read_strong_ref_array(pb, &package->tracks_refs,
1175  &package->tracks_count);
1176  case 0x4401:
1177  /* UMID */
1178  avio_read(pb, package->package_ul, 16);
1179  avio_read(pb, package->package_uid, 16);
1180  break;
1181  case 0x4701:
1182  avio_read(pb, package->descriptor_ref, 16);
1183  break;
1184  case 0x4402:
1185  return mxf_read_utf16be_string(pb, size, &package->name);
1186  case 0x4406:
1187  return mxf_read_strong_ref_array(pb, &package->comment_refs,
1188  &package->comment_count);
1189  }
1190  return 0;
1191 }
1192 
1193 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1194 {
1195  MXFEssenceContainerData *essence_data = arg;
1196  switch(tag) {
1197  case 0x2701:
1198  /* linked package umid UMID */
1199  avio_read(pb, essence_data->package_ul, 16);
1200  avio_read(pb, essence_data->package_uid, 16);
1201  break;
1202  case 0x3f06:
1203  essence_data->index_sid = avio_rb32(pb);
1204  break;
1205  case 0x3f07:
1206  essence_data->body_sid = avio_rb32(pb);
1207  break;
1208  }
1209  return 0;
1210 }
1211 
1213 {
1214  int i, length;
1215  uint32_t nb_index_entries;
1216 
1217  if (segment->temporal_offset_entries)
1218  return AVERROR_INVALIDDATA;
1219 
1220  nb_index_entries = avio_rb32(pb);
1221  if (nb_index_entries > INT_MAX)
1222  return AVERROR_INVALIDDATA;
1223  segment->nb_index_entries = nb_index_entries;
1224 
1225  length = avio_rb32(pb);
1226  if(segment->nb_index_entries && length < 11)
1227  return AVERROR_INVALIDDATA;
1228 
1229  if (!FF_ALLOC_TYPED_ARRAY(segment->temporal_offset_entries, segment->nb_index_entries) ||
1230  !FF_ALLOC_TYPED_ARRAY(segment->flag_entries , segment->nb_index_entries) ||
1231  !FF_ALLOC_TYPED_ARRAY(segment->stream_offset_entries , segment->nb_index_entries)) {
1232  av_freep(&segment->temporal_offset_entries);
1233  av_freep(&segment->flag_entries);
1234  return AVERROR(ENOMEM);
1235  }
1236 
1237  for (i = 0; i < segment->nb_index_entries; i++) {
1238  if(avio_feof(pb))
1239  return AVERROR_INVALIDDATA;
1240  segment->temporal_offset_entries[i] = avio_r8(pb);
1241  avio_r8(pb); /* KeyFrameOffset */
1242  segment->flag_entries[i] = avio_r8(pb);
1243  segment->stream_offset_entries[i] = avio_rb64(pb);
1244  avio_skip(pb, length - 11);
1245  }
1246  return 0;
1247 }
1248 
1249 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1250 {
1252  switch(tag) {
1253  case 0x3F05:
1254  segment->edit_unit_byte_count = avio_rb32(pb);
1255  av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1256  break;
1257  case 0x3F06:
1258  segment->index_sid = avio_rb32(pb);
1259  av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1260  break;
1261  case 0x3F07:
1262  segment->body_sid = avio_rb32(pb);
1263  av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1264  break;
1265  case 0x3F0A:
1266  av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1267  return mxf_read_index_entry_array(pb, segment);
1268  case 0x3F0B:
1269  segment->index_edit_rate.num = avio_rb32(pb);
1270  segment->index_edit_rate.den = avio_rb32(pb);
1271  if (segment->index_edit_rate.num <= 0 ||
1272  segment->index_edit_rate.den <= 0)
1273  return AVERROR_INVALIDDATA;
1274  av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1275  segment->index_edit_rate.den);
1276  break;
1277  case 0x3F0C:
1278  segment->index_start_position = avio_rb64(pb);
1279  av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1280  break;
1281  case 0x3F0D:
1282  segment->index_duration = avio_rb64(pb);
1283  av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1284  break;
1285  }
1286  return 0;
1287 }
1288 
1289 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1290 {
1291  int code, value, ofs = 0;
1292  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1293 
1294  do {
1295  code = avio_r8(pb);
1296  value = avio_r8(pb);
1297  av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1298 
1299  if (ofs <= 14) {
1300  layout[ofs++] = code;
1301  layout[ofs++] = value;
1302  } else
1303  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1304  } while (code != 0); /* SMPTE 377M E.2.46 */
1305 
1306  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1307 }
1308 
1309 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1310 {
1311  MXFDescriptor *descriptor = arg;
1312  int entry_count, entry_size;
1313 
1314  switch(tag) {
1315  case 0x3F01:
1316  return mxf_read_strong_ref_array(pb, &descriptor->file_descriptors_refs,
1317  &descriptor->file_descriptors_count);
1318  case 0x3002: /* ContainerDuration */
1319  descriptor->duration = avio_rb64(pb);
1320  break;
1321  case 0x3004:
1322  avio_read(pb, descriptor->essence_container_ul, 16);
1323  break;
1324  case 0x3005:
1325  avio_read(pb, descriptor->codec_ul, 16);
1326  break;
1327  case 0x3006:
1328  descriptor->linked_track_id = avio_rb32(pb);
1329  break;
1330  case 0x3201: /* PictureEssenceCoding */
1331  avio_read(pb, descriptor->essence_codec_ul, 16);
1332  break;
1333  case 0x3203:
1334  descriptor->width = avio_rb32(pb);
1335  break;
1336  case 0x3202:
1337  descriptor->height = avio_rb32(pb);
1338  break;
1339  case 0x320C:
1340  descriptor->frame_layout = avio_r8(pb);
1341  break;
1342  case 0x320D:
1343  entry_count = avio_rb32(pb);
1344  entry_size = avio_rb32(pb);
1345  if (entry_size == 4) {
1346  if (entry_count > 0)
1347  descriptor->video_line_map[0] = avio_rb32(pb);
1348  else
1349  descriptor->video_line_map[0] = 0;
1350  if (entry_count > 1)
1351  descriptor->video_line_map[1] = avio_rb32(pb);
1352  else
1353  descriptor->video_line_map[1] = 0;
1354  } else
1355  av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1356  break;
1357  case 0x320E:
1358  descriptor->aspect_ratio.num = avio_rb32(pb);
1359  descriptor->aspect_ratio.den = avio_rb32(pb);
1360  break;
1361  case 0x3210:
1362  avio_read(pb, descriptor->color_trc_ul, 16);
1363  break;
1364  case 0x3212:
1365  descriptor->field_dominance = avio_r8(pb);
1366  break;
1367  case 0x3219:
1368  avio_read(pb, descriptor->color_primaries_ul, 16);
1369  break;
1370  case 0x321A:
1371  avio_read(pb, descriptor->color_space_ul, 16);
1372  break;
1373  case 0x3301:
1374  descriptor->component_depth = avio_rb32(pb);
1375  break;
1376  case 0x3302:
1377  descriptor->horiz_subsampling = avio_rb32(pb);
1378  break;
1379  case 0x3304:
1380  descriptor->black_ref_level = avio_rb32(pb);
1381  break;
1382  case 0x3305:
1383  descriptor->white_ref_level = avio_rb32(pb);
1384  break;
1385  case 0x3306:
1386  descriptor->color_range = avio_rb32(pb);
1387  break;
1388  case 0x3308:
1389  descriptor->vert_subsampling = avio_rb32(pb);
1390  break;
1391  case 0x3D03:
1392  descriptor->sample_rate.num = avio_rb32(pb);
1393  descriptor->sample_rate.den = avio_rb32(pb);
1394  break;
1395  case 0x3D06: /* SoundEssenceCompression */
1396  avio_read(pb, descriptor->essence_codec_ul, 16);
1397  break;
1398  case 0x3D07:
1399  descriptor->channels = avio_rb32(pb);
1400  break;
1401  case 0x3D01:
1402  descriptor->bits_per_sample = avio_rb32(pb);
1403  break;
1404  case 0x3401:
1405  mxf_read_pixel_layout(pb, descriptor);
1406  break;
1407  default:
1408  /* Private uid used by SONY C0023S01.mxf */
1410  if (descriptor->extradata)
1411  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1412  av_free(descriptor->extradata);
1413  descriptor->extradata_size = 0;
1414  descriptor->extradata = av_malloc(size);
1415  if (!descriptor->extradata)
1416  return AVERROR(ENOMEM);
1417  descriptor->extradata_size = size;
1418  avio_read(pb, descriptor->extradata, size);
1419  }
1420  if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1421  uint32_t rsiz = avio_rb16(pb);
1422  if (rsiz == AV_PROFILE_JPEG2000_DCINEMA_2K ||
1424  descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1425  }
1427  if (!descriptor->mastering) {
1429  if (!descriptor->mastering)
1430  return AVERROR(ENOMEM);
1431  }
1433  for (int i = 0; i < 3; i++) {
1434  /* Order: large x, large y, other (i.e. RGB) */
1437  }
1438  /* Check we have seen mxf_mastering_display_white_point_chromaticity */
1439  if (descriptor->mastering->white_point[0].den != 0)
1440  descriptor->mastering->has_primaries = 1;
1441  }
1445  /* Check we have seen mxf_mastering_display_primaries */
1446  if (descriptor->mastering->display_primaries[0][0].den != 0)
1447  descriptor->mastering->has_primaries = 1;
1448  }
1451  /* Check we have seen mxf_mastering_display_minimum_luminance */
1452  if (descriptor->mastering->min_luminance.den != 0)
1453  descriptor->mastering->has_luminance = 1;
1454  }
1457  /* Check we have seen mxf_mastering_display_maximum_luminance */
1458  if (descriptor->mastering->max_luminance.den != 0)
1459  descriptor->mastering->has_luminance = 1;
1460  }
1461  }
1463  if (!descriptor->coll) {
1464  descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1465  if (!descriptor->coll)
1466  return AVERROR(ENOMEM);
1467  }
1469  descriptor->coll->MaxCLL = avio_rb16(pb);
1470  }
1472  descriptor->coll->MaxFALL = avio_rb16(pb);
1473  }
1474  }
1475 
1477  return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs, &descriptor->sub_descriptors_count);
1478 
1479  break;
1480  }
1481  return 0;
1482 }
1483 
1484 static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1485 {
1486  MXFMCASubDescriptor *mca_sub_descriptor = arg;
1487 
1489  avio_read(pb, mca_sub_descriptor->mca_label_dictionary_id, 16);
1490 
1492  avio_read(pb, mca_sub_descriptor->mca_link_id, 16);
1493 
1495  avio_read(pb, mca_sub_descriptor->soundfield_group_link_id, 16);
1496 
1499 
1501  mca_sub_descriptor->mca_channel_id = avio_rb32(pb);
1502 
1504  return mxf_read_us_ascii_string(pb, size, &mca_sub_descriptor->language);
1505 
1506  return 0;
1507 }
1508 
1509 static int mxf_read_ffv1_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1510 {
1511  MXFFFV1SubDescriptor *ffv1_sub_descriptor = arg;
1512 
1514  if (ffv1_sub_descriptor->extradata)
1515  av_log(NULL, AV_LOG_WARNING, "Duplicate ffv1_extradata\n");
1516  av_free(ffv1_sub_descriptor->extradata);
1517  ffv1_sub_descriptor->extradata_size = 0;
1518  ffv1_sub_descriptor->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
1519  if (!ffv1_sub_descriptor->extradata)
1520  return AVERROR(ENOMEM);
1521  ffv1_sub_descriptor->extradata_size = size;
1522  avio_read(pb, ffv1_sub_descriptor->extradata, size);
1523  }
1524 
1525  return 0;
1526 }
1527 
1528 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1529 {
1530  MXFTaggedValue *tagged_value = arg;
1531  uint8_t key[17];
1532 
1533  if (size <= 17)
1534  return 0;
1535 
1536  avio_read(pb, key, 17);
1537  /* TODO: handle other types of of indirect values */
1538  if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1539  return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1540  } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1541  return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1542  }
1543  return 0;
1544 }
1545 
1546 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1547 {
1548  MXFTaggedValue *tagged_value = arg;
1549  switch (tag){
1550  case 0x5001:
1551  return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1552  case 0x5003:
1553  return mxf_read_indirect_value(tagged_value, pb, size);
1554  }
1555  return 0;
1556 }
1557 
1558 /*
1559  * Match an uid independently of the version byte and up to len common bytes
1560  * Returns: boolean
1561  */
1562 static int mxf_match_uid(const UID key, const uint8_t uid_prefix[], int len)
1563 {
1564  int i;
1565  for (i = 0; i < len; i++) {
1566  if (i != 7 && key[i] != uid_prefix[i])
1567  return 0;
1568  }
1569  return 1;
1570 }
1571 
1572 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1573 {
1574  while (uls->uid[0]) {
1575  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1576  break;
1577  uls++;
1578  }
1579  return uls;
1580 }
1581 
1582 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1583 {
1585 
1586  if (!strong_ref)
1587  return NULL;
1588  for (int i = mg->metadata_sets_count - 1; i >= 0; i--)
1589  if (!memcmp(*strong_ref, mg->metadata_sets[i]->uid, 16))
1590  return mg->metadata_sets[i];
1591 
1592  return NULL;
1593 }
1594 
1596  // video essence container uls
1597  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14, J2KWrap },
1598  { { 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 */
1599  { { 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 */
1600  { { 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 */
1601  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1602  { { 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 */
1603  { { 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 */
1604  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1605  { { 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 */
1606  { { 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 */
1607  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x23,0x01,0x00 }, 14, AV_CODEC_ID_FFV1, NULL, 14 },
1608  { { 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 */
1609  { { 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 */
1610  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1611  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1612  { { 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 */
1613  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1614  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1615 };
1616 
1617 /* EC ULs for intra-only formats */
1619  { { 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 */
1620  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1621 };
1622 
1623 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1625  { { 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 */
1626  { { 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 */
1627  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1628 };
1629 
1630 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1632  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1633  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1634  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1635  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1636  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1637 };
1638 
1640  // sound essence container uls
1641  { { 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 */
1642  { { 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 */
1643  { { 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 */
1644  { { 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 */
1645  { { 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) */
1646  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x16,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC ADIF (SMPTE 381-4) */
1647  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x17,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC ADTS (SMPTE 381-4) */
1648  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x18,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC LATM/LOAS (SMPTE 381-4) */
1649  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1650 };
1651 
1653  { { 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 },
1654  { { 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 },
1655  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1656  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1657 };
1658 
1659 typedef struct MXFChannelOrderingUL {
1664 
1666  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x01,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left
1667  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x02,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right
1668  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x03,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center
1669  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x04,0x00,0x00,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Low Frequency Effects
1670  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x05,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround
1671  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x06,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround
1672  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x07,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_SURROUND_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround
1673  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x08,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_SURROUND_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround
1674  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x09,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround
1675  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0a,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround
1676  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0b,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_LEFT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Center
1677  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0c,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_RIGHT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Center
1678  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0d,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Surround
1679  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0e,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, // Hearing impaired audio channel
1680  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0f,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED }, // Visually impaired narrative audio channel
1681  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x03,0x00,0x00,0x00 }, AV_CHAN_STEREO_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Total
1682  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x04,0x00,0x00,0x00 }, AV_CHAN_STEREO_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Total
1683  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x01,0x00,0x00 }, AV_CHAN_TOP_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Height
1684  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x02,0x00,0x00 }, AV_CHAN_TOP_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Height
1685  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x03,0x00,0x00 }, AV_CHAN_TOP_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Height
1686  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x04,0x00,0x00 }, AV_CHAN_TOP_SURROUND_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround Height
1687  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x05,0x00,0x00 }, AV_CHAN_TOP_SURROUND_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround Height
1688  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x06,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround Height
1689  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x07,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround Height
1690  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x08,0x00,0x00 }, AV_CHAN_TOP_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround Height
1691  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x09,0x00,0x00 }, AV_CHAN_TOP_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround Height
1692  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0a,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Top Surround
1693  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0b,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Top Surround
1694  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0c,0x00,0x00 }, AV_CHAN_TOP_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Top Surround
1695  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0d,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Front Subwoofer
1696  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0e,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY_2, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Front Subwoofer
1697  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0f,0x00,0x00 }, AV_CHAN_TOP_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear Height
1698  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x10,0x00,0x00 }, AV_CHAN_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear
1699  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x11,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Below
1700  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x12,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Below
1701  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x13,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Below
1702  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_AUDIO_SERVICE_TYPE_NB },
1703 };
1704 
1705 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1706 {
1707  int val;
1708  const MXFCodecUL *codec_ul;
1709 
1711  if (!codec_ul->uid[0])
1713  if (!codec_ul->uid[0])
1714  codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1715  if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1716  return UnknownWrapped;
1717 
1718  val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1719  switch (codec_ul->wrapping_indicator_type) {
1720  case RawVWrap:
1721  val = val % 4;
1722  break;
1723  case RawAWrap:
1724  if (val == 0x03 || val == 0x04)
1725  val -= 0x02;
1726  break;
1727  case D10D11Wrap:
1728  if (val == 0x02)
1729  val = 0x01;
1730  break;
1731  case J2KWrap:
1732  if (val != 0x02)
1733  val = 0x01;
1734  break;
1735  }
1736  if (val == 0x01)
1737  return FrameWrapped;
1738  if (val == 0x02)
1739  return ClipWrapped;
1740  return UnknownWrapped;
1741 }
1742 
1743 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1744 {
1745  int i, j, nb_segments = 0;
1746  MXFIndexTableSegment **unsorted_segments;
1747  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1749 
1750  /* count number of segments, allocate arrays and copy unsorted segments */
1751  nb_segments = mg->metadata_sets_count;
1752  if (!nb_segments)
1753  return AVERROR_INVALIDDATA;
1754 
1755  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1756  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1757  av_freep(sorted_segments);
1758  av_free(unsorted_segments);
1759  return AVERROR(ENOMEM);
1760  }
1761 
1762  for (i = nb_segments = 0; i < mg->metadata_sets_count; i++) {
1763  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
1764  if (s->edit_unit_byte_count || s->nb_index_entries)
1765  unsorted_segments[nb_segments++] = s;
1766  else
1767  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1768  s->index_sid, s->index_start_position);
1769  }
1770 
1771  if (!nb_segments) {
1772  av_freep(sorted_segments);
1773  av_free(unsorted_segments);
1774  return AVERROR_INVALIDDATA;
1775  }
1776 
1777  *nb_sorted_segments = 0;
1778 
1779  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1780  for (i = 0; i < nb_segments; i++) {
1781  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1782  uint64_t best_index_duration = 0;
1783 
1784  for (j = 0; j < nb_segments; j++) {
1785  MXFIndexTableSegment *s = unsorted_segments[j];
1786 
1787  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1788  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1789  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1790  */
1791  if ((i == 0 ||
1792  s->body_sid > last_body_sid ||
1793  s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1794  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1795  (best == -1 ||
1796  s->body_sid < best_body_sid ||
1797  s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1798  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1799  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)) {
1800  best = j;
1801  best_body_sid = s->body_sid;
1802  best_index_sid = s->index_sid;
1803  best_index_start = s->index_start_position;
1804  best_index_duration = s->index_duration;
1805  }
1806  }
1807 
1808  /* no suitable entry found -> we're done */
1809  if (best == -1)
1810  break;
1811 
1812  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1813  last_body_sid = best_body_sid;
1814  last_index_sid = best_index_sid;
1815  last_index_start = best_index_start;
1816  }
1817 
1818  av_free(unsorted_segments);
1819 
1820  return 0;
1821 }
1822 
1823 /**
1824  * Computes the absolute file offset of the given essence container offset
1825  */
1826 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1827 {
1828  MXFPartition *last_p = NULL;
1829  int a, b, m, m0;
1830 
1831  if (offset < 0)
1832  return AVERROR(EINVAL);
1833 
1834  a = -1;
1835  b = mxf->partitions_count;
1836 
1837  while (b - a > 1) {
1838  m0 = m = (a + b) >> 1;
1839 
1840  while (m < b && mxf->partitions[m].body_sid != body_sid)
1841  m++;
1842 
1843  if (m < b && mxf->partitions[m].body_offset <= offset)
1844  a = m;
1845  else
1846  b = m0;
1847  }
1848 
1849  if (a >= 0)
1850  last_p = &mxf->partitions[a];
1851 
1852  if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1853  *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1854  if (partition_out)
1855  *partition_out = last_p;
1856  return 0;
1857  }
1858 
1859  av_log(mxf->fc, AV_LOG_ERROR,
1860  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1861  offset, body_sid);
1862 
1863  return AVERROR_INVALIDDATA;
1864 }
1865 
1866 /**
1867  * Returns the end position of the essence container with given BodySID, or zero if unknown
1868  */
1870 {
1871  for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1872  MXFPartition *p = &mxf->partitions[x];
1873 
1874  if (p->body_sid != body_sid)
1875  continue;
1876 
1877  if (!p->essence_length)
1878  return 0;
1879 
1880  return p->essence_offset + p->essence_length;
1881  }
1882 
1883  return 0;
1884 }
1885 
1886 /* EditUnit -> absolute offset */
1887 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)
1888 {
1889  int i;
1890  int64_t offset_temp = 0;
1891 
1892  edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1893 
1894  for (i = 0; i < index_table->nb_segments; i++) {
1895  MXFIndexTableSegment *s = index_table->segments[i];
1896 
1897  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1898 
1899  if (edit_unit < s->index_start_position + s->index_duration) {
1900  int64_t index = edit_unit - s->index_start_position;
1901 
1902  if (s->edit_unit_byte_count) {
1903  if (index > INT64_MAX / s->edit_unit_byte_count ||
1904  s->edit_unit_byte_count * index > INT64_MAX - offset_temp)
1905  return AVERROR_INVALIDDATA;
1906 
1907  offset_temp += s->edit_unit_byte_count * index;
1908  } else {
1909  if (s->nb_index_entries == 2 * s->index_duration + 1)
1910  index *= 2; /* Avid index */
1911 
1912  if (index < 0 || index >= s->nb_index_entries) {
1913  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1914  index_table->index_sid, s->index_start_position);
1915  return AVERROR_INVALIDDATA;
1916  }
1917 
1918  offset_temp = s->stream_offset_entries[index];
1919  }
1920 
1921  if (edit_unit_out)
1922  *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1923 
1924  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1925  } else {
1926  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1927  offset_temp += s->edit_unit_byte_count * s->index_duration;
1928  }
1929  }
1930 
1931  if (nag)
1932  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);
1933 
1934  return AVERROR_INVALIDDATA;
1935 }
1936 
1938 {
1939  int i, j, x;
1940  int8_t max_temporal_offset = -128;
1941  uint8_t *flags;
1942 
1943  /* first compute how many entries we have */
1944  for (i = 0; i < index_table->nb_segments; i++) {
1945  MXFIndexTableSegment *s = index_table->segments[i];
1946 
1947  if (!s->nb_index_entries) {
1948  index_table->nb_ptses = 0;
1949  return 0; /* no TemporalOffsets */
1950  }
1951 
1952  if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1953  index_table->nb_ptses = 0;
1954  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1955  return 0;
1956  }
1957 
1958  if (s->nb_index_entries != s->index_duration &&
1959  s->nb_index_entries != s->index_duration + 1 && /* Avid index */
1960  s->nb_index_entries != s->index_duration * 2 + 1) {
1961  index_table->nb_ptses = 0;
1962  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration does not match nb_index_entries\n", s->index_sid);
1963  return 0;
1964  }
1965 
1966  index_table->nb_ptses += s->index_duration;
1967  }
1968 
1969  /* paranoid check */
1970  if (index_table->nb_ptses <= 0)
1971  return 0;
1972 
1973  if (!(index_table->ptses = av_malloc_array(index_table->nb_ptses, sizeof(int64_t))) ||
1974  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1975  !(index_table->offsets = av_malloc_array(index_table->nb_ptses, sizeof(int8_t))) ||
1976  !(flags = av_malloc_array(index_table->nb_ptses, sizeof(uint8_t)))) {
1977  av_freep(&index_table->ptses);
1978  av_freep(&index_table->fake_index);
1979  av_freep(&index_table->offsets);
1980  return AVERROR(ENOMEM);
1981  }
1982 
1983  /* we may have a few bad TemporalOffsets
1984  * make sure the corresponding PTSes don't have the bogus value 0 */
1985  for (x = 0; x < index_table->nb_ptses; x++)
1986  index_table->ptses[x] = AV_NOPTS_VALUE;
1987 
1988  /**
1989  * We have this:
1990  *
1991  * x TemporalOffset
1992  * 0: 0
1993  * 1: 1
1994  * 2: 1
1995  * 3: -2
1996  * 4: 1
1997  * 5: 1
1998  * 6: -2
1999  *
2000  * We want to transform it into this:
2001  *
2002  * x DTS PTS
2003  * 0: -1 0
2004  * 1: 0 3
2005  * 2: 1 1
2006  * 3: 2 2
2007  * 4: 3 6
2008  * 5: 4 4
2009  * 6: 5 5
2010  *
2011  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
2012  * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
2013  * The latter makes DTS <= PTS.
2014  */
2015  for (i = x = 0; i < index_table->nb_segments; i++) {
2016  MXFIndexTableSegment *s = index_table->segments[i];
2017  int index_delta = 1;
2018  int n = s->nb_index_entries;
2019 
2020  if (s->nb_index_entries == 2 * s->index_duration + 1)
2021  index_delta = 2; /* Avid index */
2022  if (s->nb_index_entries == index_delta * s->index_duration + 1)
2023  /* ignore the last entry - it's the size of the essence container in Avid */
2024  n--;
2025 
2026  for (j = 0; j < n; j += index_delta, x++) {
2027  int offset = s->temporal_offset_entries[j] / index_delta;
2028  int index = x + offset;
2029 
2030  if (x >= index_table->nb_ptses) {
2031  av_log(mxf->fc, AV_LOG_ERROR,
2032  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
2033  s->nb_index_entries, s->index_duration);
2034  break;
2035  }
2036 
2037  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
2038 
2039  if (index < 0 || index >= index_table->nb_ptses) {
2040  av_log(mxf->fc, AV_LOG_ERROR,
2041  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
2042  x, offset, index);
2043  continue;
2044  }
2045 
2046  index_table->offsets[x] = offset;
2047  index_table->ptses[index] = x;
2048  max_temporal_offset = FFMAX(max_temporal_offset, offset);
2049  }
2050  }
2051 
2052  /* calculate the fake index table in display order */
2053  for (x = 0; x < index_table->nb_ptses; x++) {
2054  index_table->fake_index[x].timestamp = x;
2055  if (index_table->ptses[x] != AV_NOPTS_VALUE)
2056  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2057  }
2058  av_freep(&flags);
2059 
2060  index_table->first_dts = -max_temporal_offset;
2061 
2062  return 0;
2063 }
2064 
2065 /**
2066  * Sorts and collects index table segments into index tables.
2067  * Also computes PTSes if possible.
2068  */
2070 {
2071  int i, j, k, ret, nb_sorted_segments;
2072  MXFIndexTableSegment **sorted_segments = NULL;
2073 
2074  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2075  nb_sorted_segments <= 0) {
2076  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2077  return 0;
2078  }
2079 
2080  /* sanity check and count unique BodySIDs/IndexSIDs */
2081  for (i = 0; i < nb_sorted_segments; i++) {
2082  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2083  mxf->nb_index_tables++;
2084  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2085  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2087  goto finish_decoding_index;
2088  }
2089  }
2090 
2092  sizeof(*mxf->index_tables));
2093  if (!mxf->index_tables) {
2094  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2095  ret = AVERROR(ENOMEM);
2096  goto finish_decoding_index;
2097  }
2098 
2099  /* distribute sorted segments to index tables */
2100  for (i = j = 0; i < nb_sorted_segments; i++) {
2101  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2102  /* next IndexSID */
2103  j++;
2104  }
2105 
2106  mxf->index_tables[j].nb_segments++;
2107  }
2108 
2109  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2110  MXFIndexTable *t = &mxf->index_tables[j];
2111  MXFTrack *mxf_track = NULL;
2112 
2113  t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2114  if (!t->segments) {
2115  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2116  " pointer array\n");
2117  ret = AVERROR(ENOMEM);
2118  goto finish_decoding_index;
2119  }
2120 
2121  if (sorted_segments[i]->index_start_position)
2122  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2123  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2124 
2125  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2126  t->index_sid = sorted_segments[i]->index_sid;
2127  t->body_sid = sorted_segments[i]->body_sid;
2128 
2129  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2130  goto finish_decoding_index;
2131 
2132  for (k = 0; k < mxf->fc->nb_streams; k++) {
2133  MXFTrack *track = mxf->fc->streams[k]->priv_data;
2134  if (track && track->index_sid == t->index_sid) {
2135  mxf_track = track;
2136  break;
2137  }
2138  }
2139 
2140  /* fix zero IndexDurations */
2141  for (k = 0; k < t->nb_segments; k++) {
2142  if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2143  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2144  t->index_sid, k);
2145  if (mxf_track)
2146  t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2147  }
2148 
2149  if (t->segments[k]->index_duration)
2150  continue;
2151 
2152  if (t->nb_segments > 1)
2153  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2154  t->index_sid, k);
2155 
2156  if (!mxf_track) {
2157  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2158  break;
2159  }
2160 
2161  /* assume the first stream's duration is reasonable
2162  * leave index_duration = 0 on further segments in case we have any (unlikely)
2163  */
2164  t->segments[k]->index_duration = mxf_track->original_duration;
2165  break;
2166  }
2167  }
2168 
2169  ret = 0;
2170 finish_decoding_index:
2171  av_free(sorted_segments);
2172  return ret;
2173 }
2174 
2175 static int mxf_is_st_422(const UID *essence_container_ul) {
2176  static const uint8_t st_422_essence_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c };
2177 
2178  return essence_container_ul && mxf_match_uid(*essence_container_ul, st_422_essence_container_ul,
2179  sizeof(st_422_essence_container_ul));
2180 }
2181 
2182 static int mxf_is_intra_only(MXFDescriptor *descriptor)
2183 {
2185  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
2187  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
2188 }
2189 
2190 static void mxf_umid_to_str(const UID ul, const UID uid,
2191  char str[2 + sizeof(UID) * 4 + 1])
2192 {
2193  snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2194  ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2195  ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2196 }
2197 
2198 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2199  uint16_t patch, uint16_t release, char **str)
2200 {
2201  *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2202  if (!*str)
2203  return AVERROR(ENOMEM);
2204  return 0;
2205 }
2206 
2207 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2208 {
2209  char str[2 + 4 * sizeof(UID) + 1];
2210  if (!package)
2211  return 0;
2212  mxf_umid_to_str(package->package_ul, package->package_uid, str);
2213  av_dict_set(pm, key, str, 0);
2214  return 0;
2215 }
2216 
2217 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2218 {
2219  char buf[AV_TIMECODE_STR_SIZE];
2220  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2221 
2222  return 0;
2223 }
2224 
2226 {
2227  MXFTimecodeComponent *timecode;
2228  MXFPulldownComponent *pulldown;
2229 
2230  timecode = mxf_resolve_strong_ref(mxf, strong_ref, TimecodeComponent);
2231  if (timecode)
2232  return timecode;
2233 
2234  pulldown = mxf_resolve_strong_ref(mxf, strong_ref, PulldownComponent);
2235  if (pulldown)
2237 
2238  return NULL;
2239 }
2240 
2241 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2242 {
2243  MXFPackage *package = NULL;
2244  int i;
2245 
2246  for (i = 0; i < mxf->packages_count; i++) {
2247  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2248  if (!package)
2249  continue;
2250 
2251  if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2252  return package;
2253  }
2254  return NULL;
2255 }
2256 
2257 static MXFDescriptor* mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
2258 {
2259  MXFDescriptor *descriptor = mxf_resolve_strong_ref(mxf, strong_ref, Descriptor);
2260  if (descriptor)
2261  return descriptor;
2262 
2263  descriptor = mxf_resolve_strong_ref(mxf, strong_ref, MultipleDescriptor);
2264  if (descriptor) {
2265  for (int i = 0; i < descriptor->file_descriptors_count; i++) {
2266  MXFDescriptor *file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2267 
2268  if (!file_descriptor) {
2269  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2270  continue;
2271  }
2272  if (file_descriptor->linked_track_id == track_id) {
2273  return file_descriptor;
2274  }
2275  }
2276  }
2277 
2278  return NULL;
2279 }
2280 
2282 {
2283  MXFStructuralComponent *component = NULL;
2284  MXFPackage *package = NULL;
2285  MXFDescriptor *descriptor = NULL;
2286  MXFEssenceGroup *essence_group;
2287  int i;
2288 
2289  component = mxf_resolve_strong_ref(mxf, strong_ref, SourceClip);
2290  if (component)
2291  return component;
2292 
2293  essence_group = mxf_resolve_strong_ref(mxf, strong_ref, EssenceGroup);
2294  if (!essence_group)
2295  return NULL;
2296 
2297  /* essence groups contains multiple representations of the same media,
2298  this return the first components with a valid Descriptor typically index 0 */
2299  for (i =0; i < essence_group->structural_components_count; i++){
2300  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2301  if (!component)
2302  continue;
2303 
2304  if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2305  continue;
2306 
2307  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2308  if (descriptor)
2309  return component;
2310  }
2311 
2312  return NULL;
2313 }
2314 
2316 {
2318  int i;
2319  char *key = NULL;
2320 
2321  for (i = 0; i < package->comment_count; i++) {
2322  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2323  if (!tag || !tag->name || !tag->value)
2324  continue;
2325 
2326  key = av_asprintf("comment_%s", tag->name);
2327  if (!key)
2328  return AVERROR(ENOMEM);
2329 
2331  }
2332  return 0;
2333 }
2334 
2336 {
2337  MXFPackage *physical_package = NULL;
2338  MXFTrack *physical_track = NULL;
2339  MXFStructuralComponent *sourceclip = NULL;
2340  MXFTimecodeComponent *mxf_tc = NULL;
2341  int i, j, k;
2342  AVTimecode tc;
2343  int flags;
2344  int64_t start_position;
2345 
2346  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2347  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2348  if (!sourceclip)
2349  continue;
2350 
2351  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2352  break;
2353 
2354  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2355 
2356  /* the name of physical source package is name of the reel or tape */
2357  if (physical_package->name && physical_package->name[0])
2358  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2359 
2360  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2361  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2362  */
2363  for (j = 0; j < physical_package->tracks_count; j++) {
2364  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2365  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2366  continue;
2367  }
2368 
2369  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2370  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2371  continue;
2372  }
2373 
2374  if (physical_track->edit_rate.num <= 0 ||
2375  physical_track->edit_rate.den <= 0) {
2376  av_log(mxf->fc, AV_LOG_WARNING,
2377  "Invalid edit rate (%d/%d) found on structural"
2378  " component #%d, defaulting to 25/1\n",
2379  physical_track->edit_rate.num,
2380  physical_track->edit_rate.den, i);
2381  physical_track->edit_rate = (AVRational){25, 1};
2382  }
2383 
2384  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2385  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2386  continue;
2387 
2388  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2389  /* scale sourceclip start_position to match physical track edit rate */
2390  start_position = av_rescale_q(sourceclip->start_position,
2391  physical_track->edit_rate,
2392  source_track->edit_rate);
2393 
2394  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2395  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2396  return 0;
2397  }
2398  }
2399  }
2400  }
2401 
2402  return 0;
2403 }
2404 
2406 {
2407  MXFStructuralComponent *component = NULL;
2408  const MXFCodecUL *codec_ul = NULL;
2409  MXFPackage tmp_package;
2410  AVStream *st;
2411  int j;
2412 
2413  for (j = 0; j < track->sequence->structural_components_count; j++) {
2414  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2415  if (!component)
2416  continue;
2417  break;
2418  }
2419  if (!component)
2420  return 0;
2421 
2422  st = avformat_new_stream(mxf->fc, NULL);
2423  if (!st) {
2424  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2425  return AVERROR(ENOMEM);
2426  }
2427 
2430  st->id = track->track_id;
2431 
2432  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2433  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2434  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2435  if (track->name && track->name[0])
2436  av_dict_set(&st->metadata, "track_name", track->name, 0);
2437 
2439  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2440  return 0;
2441 }
2442 
2444 {
2445  if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2446  /* CDCI range metadata */
2447  if (!descriptor->component_depth)
2448  return AVCOL_RANGE_UNSPECIFIED;
2449  if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2450  descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2451  (descriptor->color_range == (1<<descriptor->component_depth) ||
2452  descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2453  return AVCOL_RANGE_JPEG;
2454  if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2455  descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2456  descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2457  descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2458  return AVCOL_RANGE_MPEG;
2459  avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2460  descriptor->color_range, descriptor->black_ref_level,
2461  descriptor->white_ref_level, descriptor->component_depth);
2462  }
2463 
2464  return AVCOL_RANGE_UNSPECIFIED;
2465 }
2466 
2467 static int is_pcm(enum AVCodecID codec_id)
2468 {
2469  /* we only care about "normal" PCM codecs until we get samples */
2471 }
2472 
2473 static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2474 {
2475  // language abbr should contain at least 2 chars
2476  if (rfc5646 && strlen(rfc5646) > 1) {
2477  char primary_tag[4] =
2478  {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2479 
2480  const char *iso6392 = ff_convert_lang_to(primary_tag,
2482  if (iso6392)
2483  return(av_dict_set(met, "language", iso6392, 0));
2484  }
2485  return 0;
2486 }
2487 
2489 {
2491  for (int k = 0; k < mg->metadata_sets_count; k++) {
2492  MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mg->metadata_sets[k];
2493  if (!memcmp(&group->mca_link_id, mca_link_id, 16))
2494  return group;
2495  }
2496  return NULL;
2497 }
2498 
2499 static void parse_ffv1_sub_descriptor(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2500 {
2501  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2502  MXFFFV1SubDescriptor *ffv1_sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], FFV1SubDescriptor);
2503  if (ffv1_sub_descriptor == NULL)
2504  continue;
2505 
2506  descriptor->extradata = ffv1_sub_descriptor->extradata;
2507  descriptor->extradata_size = ffv1_sub_descriptor->extradata_size;
2508  ffv1_sub_descriptor->extradata = NULL;
2509  ffv1_sub_descriptor->extradata_size = 0;
2510  break;
2511  }
2512 }
2513 
2514 static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2515 {
2516  AVChannelLayout *ch_layout = &st->codecpar->ch_layout;
2517  char *language = NULL;
2518  int ambigous_language = 0;
2519  enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2520  int ambigous_service_type = 0;
2521  int ret;
2522 
2523  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2524  char *channel_language;
2525 
2527  if (label == NULL)
2528  continue;
2529 
2530  if (ch_layout->order == AV_CHANNEL_ORDER_UNSPEC) {
2531  av_channel_layout_uninit(ch_layout);
2532  ret = av_channel_layout_custom_init(ch_layout, descriptor->channels);
2533  if (ret < 0)
2534  return ret;
2535  }
2536 
2537  for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2538  if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2539  int target_channel = label->mca_channel_id;
2540  if (target_channel == 0 && descriptor->channels == 1)
2541  target_channel = 1;
2542  if (target_channel <= 0 || target_channel > descriptor->channels) {
2543  av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2544  return AVERROR_INVALIDDATA;
2545  }
2546  ch_layout->u.map[target_channel - 1].id = channel_ordering->channel;
2547  if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2548  service_type = channel_ordering->service_type;
2549  else if (service_type != channel_ordering->service_type)
2550  ambigous_service_type = 1;
2551  break;
2552  }
2553  }
2554 
2555  channel_language = label->language;
2556  if (!channel_language) {
2558  if (group) {
2559  channel_language = group->language;
2560  if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2563  if (supergroup)
2564  channel_language = supergroup->language;
2565  }
2566  }
2567  }
2568  if (channel_language) {
2569  if (language && strcmp(language, channel_language))
2570  ambigous_language = 1;
2571  else
2572  language = channel_language;
2573  }
2574  }
2575 
2576  if (language && !ambigous_language) {
2577  int ret = set_language(mxf->fc, language, &st->metadata);
2578  if (ret < 0)
2579  return ret;
2580  }
2581 
2582  if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2583  enum AVAudioServiceType *ast;
2587  sizeof(*ast), 0);
2588  if (!side_data)
2589  return AVERROR(ENOMEM);
2590  ast = (enum AVAudioServiceType*)side_data->data;
2591  *ast = service_type;
2592  }
2593 
2595  if (ret < 0)
2596  return ret;
2597 
2598  return 0;
2599 }
2600 
2602 {
2603  MXFPackage *material_package = NULL;
2604  int i, j, k, ret;
2605 
2606  /* TODO: handle multiple material packages (OP3x) */
2607  for (i = 0; i < mxf->packages_count; i++) {
2608  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2609  if (material_package) break;
2610  }
2611  if (!material_package) {
2612  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2613  return AVERROR_INVALIDDATA;
2614  }
2615 
2616  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2617  if (material_package->name && material_package->name[0])
2618  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2619  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2620 
2621  for (i = 0; i < material_package->tracks_count; i++) {
2622  MXFPackage *source_package = NULL;
2623  MXFTrack *material_track = NULL;
2624  MXFTrack *source_track = NULL;
2625  MXFTrack *temp_track = NULL;
2626  MXFDescriptor *descriptor = NULL;
2627  MXFStructuralComponent *component = NULL;
2628  MXFTimecodeComponent *mxf_tc = NULL;
2629  UID *essence_container_ul = NULL;
2630  const MXFCodecUL *codec_ul = NULL;
2631  const MXFCodecUL *container_ul = NULL;
2632  const MXFCodecUL *pix_fmt_ul = NULL;
2633  AVStream *st;
2634  FFStream *sti;
2635  AVTimecode tc;
2636  int flags;
2637 
2638  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2639  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2640  continue;
2641  }
2642 
2643  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2644  mxf_tc = (MXFTimecodeComponent*)component;
2645  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2646  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2647  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2648  }
2649  }
2650 
2651  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2652  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2653  continue;
2654  }
2655 
2656  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2657  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2658  if (!component)
2659  continue;
2660 
2661  mxf_tc = (MXFTimecodeComponent*)component;
2662  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2663  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2664  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2665  break;
2666  }
2667  }
2668 
2669  /* TODO: handle multiple source clips, only finds first valid source clip */
2670  if(material_track->sequence->structural_components_count > 1)
2671  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2672  material_track->track_id, material_track->sequence->structural_components_count);
2673 
2674  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2675  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2676  if (!component)
2677  continue;
2678 
2679  source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2680  if (!source_package) {
2681  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2682  continue;
2683  }
2684  for (k = 0; k < source_package->tracks_count; k++) {
2685  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2686  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2688  goto fail_and_free;
2689  }
2690  if (temp_track->track_id == component->source_track_id) {
2691  source_track = temp_track;
2692  break;
2693  }
2694  }
2695  if (!source_track) {
2696  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2697  break;
2698  }
2699 
2700  for (k = 0; k < mxf->essence_container_data_count; k++) {
2701  MXFEssenceContainerData *essence_data;
2702 
2703  if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2704  av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2705  continue;
2706  }
2707  if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2708  source_track->body_sid = essence_data->body_sid;
2709  source_track->index_sid = essence_data->index_sid;
2710  break;
2711  }
2712  }
2713 
2714  if(source_track && component)
2715  break;
2716  }
2717  if (!source_track || !component || !source_package) {
2718  if((ret = mxf_add_metadata_stream(mxf, material_track)))
2719  goto fail_and_free;
2720  continue;
2721  }
2722 
2723  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2724  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2726  goto fail_and_free;
2727  }
2728 
2729  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2730  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2731  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2732  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2733  continue;
2734  }
2735 
2736  st = avformat_new_stream(mxf->fc, NULL);
2737  if (!st) {
2738  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2739  ret = AVERROR(ENOMEM);
2740  goto fail_and_free;
2741  }
2742  sti = ffstream(st);
2743  st->id = material_track->track_id;
2744  st->priv_data = source_track;
2745 
2746  descriptor = mxf_resolve_descriptor(mxf, &source_package->descriptor_ref, source_track->track_id);
2747 
2748  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2749  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2750  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2751  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2752  else
2753  source_track->original_duration = st->duration = component->duration;
2754 
2755  if (st->duration == -1)
2756  st->duration = AV_NOPTS_VALUE;
2757  st->start_time = component->start_position;
2758  if (material_track->edit_rate.num <= 0 ||
2759  material_track->edit_rate.den <= 0) {
2760  av_log(mxf->fc, AV_LOG_WARNING,
2761  "Invalid edit rate (%d/%d) found on stream #%d, "
2762  "defaulting to 25/1\n",
2763  material_track->edit_rate.num,
2764  material_track->edit_rate.den, st->index);
2765  material_track->edit_rate = (AVRational){25, 1};
2766  }
2767  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2768 
2769  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2770  * the former is accessible via st->priv_data */
2771  source_track->edit_rate = material_track->edit_rate;
2772 
2773  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2775  st->codecpar->codec_type = codec_ul->id;
2776 
2777  if (!descriptor) {
2778  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2779  continue;
2780  }
2781  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2782  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2783  essence_container_ul = &descriptor->essence_container_ul;
2784  source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2785  if (source_track->wrapping == UnknownWrapped)
2786  av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2787  /* HACK: replacing the original key with mxf_encrypted_essence_container
2788  * is not allowed according to s429-6, try to find correct information anyway */
2789  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2791  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2792  if (mg->metadata_sets_count) {
2793  MXFMetadataSet *metadata = mg->metadata_sets[0];
2794  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2795  }
2796  }
2797 
2798  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2800  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2801  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2803  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2804  }
2805 
2806  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2808  for (k = 0; k < 16; k++) {
2809  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2810  descriptor->essence_codec_ul[k]);
2811  if (!(k+1 & 19) || k == 5)
2812  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2813  }
2814  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2815 
2816  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2817  if (source_package->name && source_package->name[0])
2818  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2819  if (material_track->name && material_track->name[0])
2820  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2821 
2822  mxf_parse_physical_source_package(mxf, source_track, st);
2823 
2824  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2825  source_track->intra_only = mxf_is_intra_only(descriptor);
2827  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2828  st->codecpar->codec_id = container_ul->id;
2829  st->codecpar->width = descriptor->width;
2830  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2831  switch (descriptor->frame_layout) {
2832  case FullFrame:
2834  break;
2835  case OneField:
2836  /* Every other line is stored and needs to be duplicated. */
2837  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2838  break; /* The correct thing to do here is fall through, but by breaking we might be
2839  able to decode some streams at half the vertical resolution, rather than not al all.
2840  It's also for compatibility with the old behavior. */
2841  case MixedFields:
2842  break;
2843  case SegmentedFrame:
2845  case SeparateFields:
2846  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2847  descriptor->video_line_map[0], descriptor->video_line_map[1],
2848  descriptor->field_dominance);
2849  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2850  /* Detect coded field order from VideoLineMap:
2851  * (even, even) => bottom field coded first
2852  * (even, odd) => top field coded first
2853  * (odd, even) => top field coded first
2854  * (odd, odd) => bottom field coded first
2855  */
2856  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2857  switch (descriptor->field_dominance) {
2861  break;
2864  break;
2865  default:
2867  "Field dominance %d support",
2868  descriptor->field_dominance);
2869  }
2870  } else {
2871  switch (descriptor->field_dominance) {
2875  break;
2878  break;
2879  default:
2881  "Field dominance %d support",
2882  descriptor->field_dominance);
2883  }
2884  }
2885  }
2886  /* Turn field height into frame height. */
2887  st->codecpar->height *= 2;
2888  break;
2889  default:
2890  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2891  }
2892 
2893  if (mxf_is_st_422(essence_container_ul)) {
2894  switch ((*essence_container_ul)[14]) {
2895  case 2: /* Cn: Clip- wrapped Picture Element */
2896  case 3: /* I1: Interlaced Frame, 1 field/KLV */
2897  case 4: /* I2: Interlaced Frame, 2 fields/KLV */
2898  case 6: /* P1: Frame- wrapped Picture Element */
2899  st->avg_frame_rate = source_track->edit_rate;
2900  st->r_frame_rate = st->avg_frame_rate;
2901  break;
2902  case 5: /* F1: Field-wrapped Picture Element */
2903  st->avg_frame_rate = av_mul_q(av_make_q(2, 1), source_track->edit_rate);
2904  st->r_frame_rate = st->avg_frame_rate;
2905  break;
2906  default:
2907  break;
2908  }
2909  }
2910 
2911  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2912  switch (descriptor->essence_codec_ul[14]) {
2913  case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2914  case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2915  case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2916  case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2917  case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2918  case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2919  }
2920  }
2921 
2922  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2923  st->codecpar->format = descriptor->pix_fmt;
2924  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2926  &descriptor->essence_codec_ul);
2927  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2928  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2930  &descriptor->essence_codec_ul)->id;
2931  if (!st->codecpar->codec_tag) {
2932  /* support files created before RP224v10 by defaulting to UYVY422
2933  if subsampling is 4:2:2 and component depth is 8-bit */
2934  if (descriptor->horiz_subsampling == 2 &&
2935  descriptor->vert_subsampling == 1 &&
2936  descriptor->component_depth == 8) {
2938  }
2939  }
2940  }
2941  }
2942  }
2944  if (material_track->sequence->origin) {
2945  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2946  }
2947  if (source_track->sequence->origin) {
2948  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2949  }
2950  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2951  sti->display_aspect_ratio = descriptor->aspect_ratio;
2952  st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2956  if (descriptor->mastering) {
2959  (uint8_t *)descriptor->mastering, descriptor->mastering_size, 0)) {
2960  ret = AVERROR(ENOMEM);
2961  goto fail_and_free;
2962  }
2963  descriptor->mastering = NULL;
2964  }
2965  if (descriptor->coll) {
2968  (uint8_t *)descriptor->coll, descriptor->coll_size, 0)) {
2969  ret = AVERROR(ENOMEM);
2970  goto fail_and_free;
2971  }
2972  descriptor->coll = NULL;
2973  }
2974  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2976  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2978  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2979  st->codecpar->ch_layout.nb_channels = descriptor->channels;
2980 
2981  if (descriptor->sample_rate.den > 0) {
2982  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2983  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2984  } else {
2985  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2986  "found for stream #%d, time base forced to 1/48000\n",
2987  descriptor->sample_rate.num, descriptor->sample_rate.den,
2988  st->index);
2989  avpriv_set_pts_info(st, 64, 1, 48000);
2990  }
2991 
2992  /* if duration is set, rescale it from EditRate to SampleRate */
2993  if (st->duration != AV_NOPTS_VALUE)
2994  st->duration = av_rescale_q(st->duration,
2995  av_inv_q(material_track->edit_rate),
2996  st->time_base);
2997 
2998  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2999  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
3000  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3002  else if (descriptor->bits_per_sample == 32)
3004  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
3005  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3007  else if (descriptor->bits_per_sample == 32)
3009  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
3011  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
3013  }
3015 
3016  if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
3017  av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
3018  return AVERROR_INVALIDDATA;
3019  }
3020 
3021  ret = parse_mca_labels(mxf, source_track, descriptor, st);
3022  if (ret < 0)
3023  return ret;
3024  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
3025  enum AVMediaType type;
3027  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
3028  st->codecpar->codec_id = container_ul->id;
3030  if (type == AVMEDIA_TYPE_SUBTITLE)
3031  st->codecpar->codec_type = type;
3032  if (container_ul->desc)
3033  av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
3034  if (mxf->eia608_extract &&
3035  container_ul->desc &&
3036  !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
3039  }
3040  }
3041  if (!descriptor->extradata)
3042  parse_ffv1_sub_descriptor(mxf, source_track, descriptor, st);
3043  if (descriptor->extradata) {
3044  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
3045  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
3046  }
3047  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3049  &descriptor->essence_codec_ul)->id;
3050  if (coded_width)
3051  st->codecpar->width = coded_width;
3053  if (ret < 0)
3054  return ret;
3055  }
3056  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
3057  /* TODO: decode timestamps */
3059  }
3060  }
3061 
3062  for (int i = 0; i < mxf->fc->nb_streams; i++) {
3063  MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
3064  if (track1 && track1->body_sid) {
3065  for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
3066  MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
3067  if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
3068  if (track1->wrapping == UnknownWrapped)
3069  track1->wrapping = track2->wrapping;
3070  else if (track2->wrapping == UnknownWrapped)
3071  track2->wrapping = track1->wrapping;
3072  else
3073  av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
3074  "with different wrapping\n", i, j, track1->body_sid);
3075  }
3076  }
3077  }
3078  }
3079 
3080  ret = 0;
3081 fail_and_free:
3082  return ret;
3083 }
3084 
3085 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
3086 {
3087  struct tm time = { 0 };
3088  int msecs;
3089  time.tm_year = (timestamp >> 48) - 1900;
3090  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
3091  time.tm_mday = (timestamp >> 32 & 0xFF);
3092  time.tm_hour = (timestamp >> 24 & 0xFF);
3093  time.tm_min = (timestamp >> 16 & 0xFF);
3094  time.tm_sec = (timestamp >> 8 & 0xFF);
3095  msecs = (timestamp & 0xFF) * 4;
3096 
3097  /* Clip values for legacy reasons. Maybe we should return error instead? */
3098  time.tm_mon = av_clip(time.tm_mon, 0, 11);
3099  time.tm_mday = av_clip(time.tm_mday, 1, 31);
3100  time.tm_hour = av_clip(time.tm_hour, 0, 23);
3101  time.tm_min = av_clip(time.tm_min, 0, 59);
3102  time.tm_sec = av_clip(time.tm_sec, 0, 59);
3103  msecs = av_clip(msecs, 0, 999);
3104 
3105  return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
3106 }
3107 
3108 #define SET_STR_METADATA(pb, name, str) do { \
3109  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
3110  return ret; \
3111  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3112 } while (0)
3113 
3114 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
3115  major = avio_rb16(pb); \
3116  minor = avio_rb16(pb); \
3117  tertiary = avio_rb16(pb); \
3118  patch = avio_rb16(pb); \
3119  release = avio_rb16(pb); \
3120  if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
3121  return ret; \
3122  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3123 } while (0)
3124 
3125 #define SET_UID_METADATA(pb, name, var, str) do { \
3126  char uuid_str[2 * AV_UUID_LEN + 4 + 1]; \
3127  avio_read(pb, var, 16); \
3128  av_uuid_unparse(uid, uuid_str); \
3129  av_dict_set(&s->metadata, name, uuid_str, 0); \
3130 } while (0)
3131 
3132 #define SET_TS_METADATA(pb, name, var, str) do { \
3133  var = avio_rb64(pb); \
3134  if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
3135  return ret; \
3136 } while (0)
3137 
3138 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
3139 {
3140  MXFContext *mxf = arg;
3141  AVFormatContext *s = mxf->fc;
3142  int ret;
3143  UID uid = { 0 };
3144  char *str = NULL;
3145  uint64_t ts;
3146  uint16_t major, minor, tertiary, patch, release;
3147  switch (tag) {
3148  case 0x3C01:
3149  SET_STR_METADATA(pb, "company_name", str);
3150  break;
3151  case 0x3C02:
3152  SET_STR_METADATA(pb, "product_name", str);
3153  break;
3154  case 0x3C03:
3155  SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
3156  break;
3157  case 0x3C04:
3158  SET_STR_METADATA(pb, "product_version", str);
3159  break;
3160  case 0x3C05:
3161  SET_UID_METADATA(pb, "product_uid", uid, str);
3162  break;
3163  case 0x3C06:
3164  SET_TS_METADATA(pb, "modification_date", ts, str);
3165  break;
3166  case 0x3C07:
3167  SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
3168  break;
3169  case 0x3C08:
3170  SET_STR_METADATA(pb, "application_platform", str);
3171  break;
3172  case 0x3C09:
3173  SET_UID_METADATA(pb, "generation_uid", uid, str);
3174  break;
3175  case 0x3C0A:
3176  SET_UID_METADATA(pb, "uid", uid, str);
3177  break;
3178  }
3179  return 0;
3180 }
3181 
3182 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
3183 {
3184  MXFContext *mxf = arg;
3185  AVFormatContext *s = mxf->fc;
3186  int ret;
3187  char *str = NULL;
3188 
3189  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
3190  SET_STR_METADATA(pb, "project_name", str);
3191  }
3192  return 0;
3193 }
3194 
3196  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
3197  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
3198  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
3199  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
3200  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
3201  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
3202  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
3203  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
3204  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
3205  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
3206  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
3207  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
3208  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
3209  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage },
3210  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
3211  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
3212  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
3213  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
3214  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
3215  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
3216  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
3217  { { 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 */
3218  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
3219  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
3220  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
3221  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
3222  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
3223  { { 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 */
3224  { { 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 */
3225  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
3226  { { 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 */
3227  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6b,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), AudioChannelLabelSubDescriptor },
3228  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6c,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), SoundfieldGroupLabelSubDescriptor },
3229  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6d,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor },
3230  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x81,0x03 }, mxf_read_ffv1_sub_descriptor, sizeof(MXFFFV1SubDescriptor), FFV1SubDescriptor },
3231  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
3232  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
3233  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
3234  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
3235  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
3236  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
3237  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
3238  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL },
3239 };
3240 
3242 {
3243  ctx->partition_score = partition_score(partition);
3244  switch (type){
3245  case MultipleDescriptor:
3246  case Descriptor:
3247  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
3248  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
3249  break;
3250  default:
3251  break;
3252  }
3253  return 0;
3254 }
3255 
3256 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
3257 {
3258  AVIOContext *pb = mxf->fc->pb;
3259  uint64_t klv_end = avio_tell(pb) + klv->length;
3260  MXFMetadataSet *meta;
3261  void *ctx;
3262 
3263  if (ctx_size) {
3264  meta = av_mallocz(ctx_size);
3265  if (!meta)
3266  return AVERROR(ENOMEM);
3267  ctx = meta;
3269  } else {
3270  meta = NULL;
3271  ctx = mxf;
3272  }
3273  while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
3274  int ret;
3275  int tag = avio_rb16(pb);
3276  int size = avio_rb16(pb); /* KLV specified by 0x53 */
3277  int64_t next = avio_tell(pb);
3278  UID uid = {0};
3279  if (next < 0 || next > INT64_MAX - size) {
3280  if (meta) {
3281  mxf_free_metadataset(&meta, type);
3282  }
3283  return next < 0 ? next : AVERROR_INVALIDDATA;
3284  }
3285  next += size;
3286 
3287  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
3288  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
3289  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
3290  continue;
3291  }
3292  if (tag > 0x7FFF) { /* dynamic tag */
3293  int i;
3294  for (i = 0; i < mxf->local_tags_count; i++) {
3295  int local_tag = AV_RB16(mxf->local_tags+i*18);
3296  if (local_tag == tag) {
3297  memcpy(uid, mxf->local_tags+i*18+2, 16);
3298  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
3299  PRINT_KEY(mxf->fc, "uid", uid);
3300  }
3301  }
3302  }
3303  if (meta && tag == 0x3C0A) {
3304  avio_read(pb, meta->uid, 16);
3305  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
3306  if (meta) {
3307  mxf_free_metadataset(&meta, type);
3308  }
3309  return ret;
3310  }
3311 
3312  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
3313  * it extending past the end of the KLV though (zzuf5.mxf). */
3314  if (avio_tell(pb) > klv_end) {
3315  if (meta) {
3316  mxf_free_metadataset(&meta, type);
3317  }
3318 
3319  av_log(mxf->fc, AV_LOG_ERROR,
3320  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
3321  tag, klv->offset);
3322  return AVERROR_INVALIDDATA;
3323  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
3324  avio_seek(pb, next, SEEK_SET);
3325  }
3326  return meta ? mxf_add_metadata_set(mxf, &meta, type) : 0;
3327 }
3328 
3329 /**
3330  * Matches any partition pack key, in other words:
3331  * - HeaderPartition
3332  * - BodyPartition
3333  * - FooterPartition
3334  * @return non-zero if the key is a partition pack key, zero otherwise
3335  */
3337 {
3338  //NOTE: this is a little lax since it doesn't constraint key[14]
3339  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
3340  key[13] >= 2 && key[13] <= 4;
3341 }
3342 
3343 /**
3344  * Parses a metadata KLV
3345  * @return <0 on error, 0 otherwise
3346  */
3348  int ctx_size, enum MXFMetadataSetType type)
3349 {
3350  AVFormatContext *s = mxf->fc;
3351  int res;
3352  if (klv.key[5] == 0x53) {
3353  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
3354  } else {
3355  uint64_t next = avio_tell(s->pb) + klv.length;
3356  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
3357 
3358  /* only seek forward, else this can loop for a long time */
3359  if (avio_tell(s->pb) > next) {
3360  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
3361  klv.offset);
3362  return AVERROR_INVALIDDATA;
3363  }
3364 
3365  avio_seek(s->pb, next, SEEK_SET);
3366  }
3367  if (res < 0) {
3368  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3369  return res;
3370  }
3371  return 0;
3372 }
3373 
3374 /**
3375  * Seeks to the previous partition and parses it, if possible
3376  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3377  */
3379 {
3380  AVIOContext *pb = mxf->fc->pb;
3381  KLVPacket klv;
3382  int64_t current_partition_ofs;
3383  int ret;
3384 
3385  if (!mxf->current_partition ||
3387  return 0; /* we've parsed all partitions */
3388 
3389  /* seek to previous partition */
3390  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3391  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3392  mxf->current_partition = NULL;
3393 
3394  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3395 
3396  /* Make sure this is actually a PartitionPack, and if so parse it.
3397  * See deadlock2.mxf
3398  */
3399  if ((ret = klv_read_packet(mxf, &klv, pb)) < 0) {
3400  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3401  return ret;
3402  }
3403 
3404  if (!mxf_is_partition_pack_key(klv.key)) {
3405  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3406  return AVERROR_INVALIDDATA;
3407  }
3408 
3409  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3410  * can point to just before the current partition, causing klv_read_packet()
3411  * to sync back up to it. See deadlock3.mxf
3412  */
3413  if (klv.offset >= current_partition_ofs) {
3414  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3415  PRIx64 " indirectly points to itself\n", current_partition_ofs);
3416  return AVERROR_INVALIDDATA;
3417  }
3418 
3419  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3420  return ret;
3421 
3422  return 1;
3423 }
3424 
3425 /**
3426  * Called when essence is encountered
3427  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3428  */
3430 {
3431  AVIOContext *pb = mxf->fc->pb;
3432  int64_t ret;
3433 
3434  if (mxf->parsing_backward) {
3435  return mxf_seek_to_previous_partition(mxf);
3436  } else {
3437  if (!mxf->footer_partition) {
3438  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3439  return 0;
3440  }
3441 
3442  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3443 
3444  /* remember where we were so we don't end up seeking further back than this */
3445  mxf->last_forward_tell = avio_tell(pb);
3446 
3447  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3448  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3449  return -1;
3450  }
3451 
3452  /* seek to FooterPartition and parse backward */
3453  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3454  av_log(mxf->fc, AV_LOG_ERROR,
3455  "failed to seek to FooterPartition @ 0x%" PRIx64
3456  " (%"PRId64") - partial file?\n",
3457  mxf->run_in + mxf->footer_partition, ret);
3458  return ret;
3459  }
3460 
3461  mxf->current_partition = NULL;
3462  mxf->parsing_backward = 1;
3463  }
3464 
3465  return 1;
3466 }
3467 
3468 /**
3469  * Called when the next partition or EOF is encountered
3470  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3471  */
3473 {
3474  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3475 }
3476 
3478 {
3479  for (int i = 0; i < s->nb_streams; i++) {
3480  MXFTrack *track = s->streams[i]->priv_data;
3481  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3482  return track->wrapping;
3483  }
3484  return UnknownWrapped;
3485 }
3486 
3487 /**
3488  * Figures out the proper offset and length of the essence container in each partition
3489  */
3491 {
3492  MXFContext *mxf = s->priv_data;
3493  int x;
3494 
3495  for (x = 0; x < mxf->partitions_count; x++) {
3496  MXFPartition *p = &mxf->partitions[x];
3497  MXFWrappingScheme wrapping;
3498 
3499  if (!p->body_sid)
3500  continue; /* BodySID == 0 -> no essence */
3501 
3502  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3503  * otherwise we point essence_offset at the key of the first essence KLV.
3504  */
3505 
3506  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3507 
3508  if (wrapping == ClipWrapped) {
3511  } else {
3513 
3514  /* essence container spans to the next partition */
3515  if (x < mxf->partitions_count - 1)
3516  p->essence_length = mxf->partitions[x+1].pack_ofs - mxf->run_in - p->essence_offset;
3517 
3518  if (p->essence_length < 0) {
3519  /* next ThisPartition < essence_offset */
3520  p->essence_length = 0;
3521  av_log(mxf->fc, AV_LOG_ERROR,
3522  "partition %i: bad ThisPartition = %"PRIX64"\n",
3523  x+1, mxf->partitions[x+1].pack_ofs - mxf->run_in);
3524  }
3525  }
3526  }
3527 }
3528 
3529 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3530 {
3531  int i;
3532  for (i = 0; i < mxf->nb_index_tables; i++)
3533  if (mxf->index_tables[i].index_sid == index_sid)
3534  return &mxf->index_tables[i];
3535  return NULL;
3536 }
3537 
3538 /**
3539  * Deal with the case where for some audio atoms EditUnitByteCount is
3540  * very small (2, 4..). In those cases we should read more than one
3541  * sample per call to mxf_read_packet().
3542  */
3544 {
3545  MXFTrack *track = st->priv_data;
3546  MXFIndexTable *t;
3547 
3548  if (!track)
3549  return;
3550  track->edit_units_per_packet = 1;
3551  if (track->wrapping != ClipWrapped)
3552  return;
3553 
3554  t = mxf_find_index_table(mxf, track->index_sid);
3555 
3556  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3557  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3558  !is_pcm(st->codecpar->codec_id) ||
3559  !t ||
3560  t->nb_segments != 1 ||
3561  t->segments[0]->edit_unit_byte_count >= 32)
3562  return;
3563 
3564  /* arbitrarily default to 48 kHz PAL audio frame size */
3565  /* TODO: We could compute this from the ratio between the audio
3566  * and video edit rates for 48 kHz NTSC we could use the
3567  * 1802-1802-1802-1802-1801 pattern. */
3568  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3569 }
3570 
3571 /**
3572  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3573  */
3575 {
3576  MXFTrack *track = st->priv_data;
3578  MXFPartition *p = NULL;
3579  int essence_partition_count = 0;
3580  int edit_unit_byte_count = 0;
3581  int i, ret;
3583 
3584  if (!track || track->wrapping != ClipWrapped)
3585  return 0;
3586 
3587  /* check if track already has an IndexTableSegment */
3588  for (i = 0; i < mg->metadata_sets_count; i++) {
3589  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
3590  if (s->body_sid == track->body_sid)
3591  return 0;
3592  }
3593 
3594  /* find the essence partition */
3595  for (i = 0; i < mxf->partitions_count; i++) {
3596  /* BodySID == 0 -> no essence */
3597  if (mxf->partitions[i].body_sid != track->body_sid)
3598  continue;
3599 
3600  p = &mxf->partitions[i];
3601  essence_partition_count++;
3602  }
3603 
3604  /* only handle files with a single essence partition */
3605  if (essence_partition_count != 1)
3606  return 0;
3607 
3609  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) *
3610  st->codecpar->ch_layout.nb_channels) >> 3;
3611  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3612  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3613  }
3614 
3615  if (edit_unit_byte_count <= 0)
3616  return 0;
3617 
3618  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);
3619 
3620  if (!(segment = av_mallocz(sizeof(*segment))))
3621  return AVERROR(ENOMEM);
3622 
3624  return ret;
3625 
3626  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3627  * using the same SID for index is forbidden in MXF. */
3628  if (!track->index_sid)
3629  track->index_sid = track->body_sid;
3630 
3631  /* stream will be treated as small EditUnitByteCount */
3632  segment->edit_unit_byte_count = edit_unit_byte_count;
3633  segment->index_start_position = 0;
3634  segment->index_duration = st->duration;
3635  segment->index_edit_rate = av_inv_q(st->time_base);
3636  segment->index_sid = track->index_sid;
3637  segment->body_sid = p->body_sid;
3638  return 0;
3639 }
3640 
3642 {
3643  MXFContext *mxf = s->priv_data;
3644  uint32_t length;
3645  int64_t file_size, max_rip_length, min_rip_length;
3646  KLVPacket klv;
3647 
3648  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3649  return;
3650 
3651  file_size = avio_size(s->pb);
3652 
3653  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3654  * The limit below assumes a file with nothing but partition packs and a RIP.
3655  * Before changing this, consider that a muxer may place each sample in its own partition.
3656  *
3657  * 105 is the size of the smallest possible PartitionPack
3658  * 12 is the size of each RIP entry
3659  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3660  */
3661  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3662  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3663 
3664  /* We're only interested in RIPs with at least two entries.. */
3665  min_rip_length = 16+1+24+4;
3666 
3667  /* See S377m section 11 */
3668  avio_seek(s->pb, file_size - 4, SEEK_SET);
3669  length = avio_rb32(s->pb);
3670 
3671  if (length < min_rip_length || length > max_rip_length)
3672  goto end;
3673  avio_seek(s->pb, file_size - length, SEEK_SET);
3674  if (klv_read_packet(mxf, &klv, s->pb) < 0 ||
3676  goto end;
3677  if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3678  av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3679  goto end;
3680  }
3681 
3682  avio_skip(s->pb, klv.length - 12);
3683  mxf->footer_partition = avio_rb64(s->pb);
3684 
3685  /* sanity check */
3686  if (mxf->run_in + mxf->footer_partition >= file_size) {
3687  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3688  mxf->footer_partition = 0;
3689  }
3690 
3691 end:
3692  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3693 }
3694 
3696 {
3697  MXFContext *mxf = s->priv_data;
3698  KLVPacket klv;
3699  int64_t essence_offset = 0;
3700  int ret;
3701  int64_t run_in;
3702 
3703  mxf->last_forward_tell = INT64_MAX;
3704 
3706  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3707  return AVERROR_INVALIDDATA;
3708  }
3709  avio_seek(s->pb, -14, SEEK_CUR);
3710  mxf->fc = s;
3711  run_in = avio_tell(s->pb);
3712  if (run_in < 0 || run_in > RUN_IN_MAX)
3713  return AVERROR_INVALIDDATA;
3714  mxf->run_in = run_in;
3715 
3717 
3718  while (!avio_feof(s->pb)) {
3719  const MXFMetadataReadTableEntry *metadata;
3720 
3721  ret = klv_read_packet(mxf, &klv, s->pb);
3722  if (ret < 0 || IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key)) {
3723  if (ret >= 0 && avio_size(s->pb) > klv.next_klv)
3724  av_log(s, AV_LOG_WARNING, "data after the RandomIndexPack, assuming end of file\n");
3725  /* EOF - seek to previous partition or stop */
3726  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3727  break;
3728  else
3729  continue;
3730  }
3731 
3732  PRINT_KEY(s, "read header", klv.key);
3733  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3740 
3741  if (!mxf->current_partition) {
3742  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3743  return AVERROR_INVALIDDATA;
3744  }
3745 
3748 
3749  if (!essence_offset)
3750  essence_offset = klv.offset;
3751 
3752  /* seek to footer, previous partition or stop */
3753  if (mxf_parse_handle_essence(mxf) <= 0)
3754  break;
3755  continue;
3756  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3757  /* next partition pack - keep going, seek to previous partition or stop */
3758  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3759  break;
3760  else if (mxf->parsing_backward)
3761  continue;
3762  /* we're still parsing forward. proceed to parsing this partition pack */
3763  }
3764 
3765  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3766  if (IS_KLV_KEY(klv.key, metadata->key)) {
3767  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3768  return ret;
3769  break;
3770  }
3771  }
3772  if (!metadata->read) {
3773  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3774  UID_ARG(klv.key));
3775  avio_skip(s->pb, klv.length);
3776  }
3777  }
3778  /* FIXME avoid seek */
3779  if (!essence_offset) {
3780  av_log(s, AV_LOG_ERROR, "no essence\n");
3781  return AVERROR_INVALIDDATA;
3782  }
3783  avio_seek(s->pb, essence_offset, SEEK_SET);
3784 
3785  /* we need to do this before computing the index tables
3786  * to be able to fill in zero IndexDurations with st->duration */
3787  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3788  return ret;
3789 
3790  for (int i = 0; i < s->nb_streams; i++)
3791  mxf_handle_missing_index_segment(mxf, s->streams[i]);
3792 
3793  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3794  return ret;
3795 
3796  if (mxf->nb_index_tables > 1) {
3797  /* TODO: look up which IndexSID to use via EssenceContainerData */
3798  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3799  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3800  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3801  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3802  return AVERROR_INVALIDDATA;
3803  }
3804 
3806 
3807  for (int i = 0; i < s->nb_streams; i++)
3808  mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3809 
3810  return 0;
3811 }
3812 
3813 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3814 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3815 {
3816  int64_t a, b, m, offset;
3817  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3818 
3819  if (!t || track->original_duration <= 0)
3820  return -1;
3821 
3822  a = -1;
3823  b = track->original_duration;
3824 
3825  while (b - a > 1) {
3826  m = (a + b) >> 1;
3827  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3828  return -1;
3829  if (offset < current_offset)
3830  a = m;
3831  else
3832  b = m;
3833  }
3834 
3835  *edit_unit_out = b;
3836 
3837  return 0;
3838 }
3839 
3841  int64_t edit_unit)
3842 {
3843  MXFTrack *track = st->priv_data;
3844  AVRational time_base = av_inv_q(track->edit_rate);
3846 
3847  // For non-audio sample_count equals current edit unit
3849  return edit_unit;
3850 
3851  if ((sample_rate.num / sample_rate.den) == 48000) {
3852  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3853  } else {
3854  int64_t remainder = (sample_rate.num * (int64_t) time_base.num) %
3855  ( time_base.den * (int64_t)sample_rate.den);
3856  if (remainder)
3857  av_log(mxf->fc, AV_LOG_WARNING,
3858  "seeking detected on stream #%d with time base (%d/%d) and "
3859  "sample rate (%d/%d), audio pts won't be accurate.\n",
3860  st->index, time_base.num, time_base.den,
3861  sample_rate.num, sample_rate.den);
3862  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3863  }
3864 }
3865 
3866 /**
3867  * Make sure track->sample_count is correct based on what offset we're currently at.
3868  * Also determine the next edit unit (or packet) offset.
3869  * @return next_ofs if OK, <0 on error
3870  */
3871 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3872 {
3873  int64_t next_ofs = -1;
3874  MXFTrack *track = st->priv_data;
3875  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3876  int64_t new_edit_unit;
3877  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3878 
3879  if (!t || track->wrapping == UnknownWrapped)
3880  return -1;
3881 
3882  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3883  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3884  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3885  return -1;
3886  }
3887 
3888  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3889  if (next_ofs > current_offset)
3890  return next_ofs;
3891 
3892  if (!resync) {
3893  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3894  return -1;
3895  }
3896 
3897  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3898  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3899  return -1;
3900  }
3901 
3902  new_edit_unit--;
3903  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3904  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);
3905 
3906  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3907 }
3908 
3910  AVPacket *pkt)
3911 {
3912  AVStream *st = mxf->fc->streams[pkt->stream_index];
3913  MXFTrack *track = st->priv_data;
3914  int64_t bits_per_sample = par->bits_per_coded_sample;
3915 
3916  if (!bits_per_sample)
3917  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3918 
3919  pkt->pts = track->sample_count;
3920 
3921  if (par->ch_layout.nb_channels <= 0 ||
3922  bits_per_sample <= 0 ||
3923  par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
3924  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);
3925  else
3926  track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
3927 
3928  return 0;
3929 }
3930 
3931 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3932 {
3933  AVCodecParameters *par = st->codecpar;
3934  MXFTrack *track = st->priv_data;
3935 
3936  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3937  /* see if we have an index table to derive timestamps from */
3938  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3939 
3940  if (t && track->sample_count < t->nb_ptses) {
3941  pkt->dts = track->sample_count + t->first_dts;
3942  pkt->pts = t->ptses[track->sample_count];
3943  } else if (track->intra_only) {
3944  /* intra-only -> PTS = EditUnit.
3945  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3946  pkt->pts = track->sample_count;
3947  }
3948  track->sample_count++;
3949  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3950  int ret = mxf_set_audio_pts(mxf, par, pkt);
3951  if (ret < 0)
3952  return ret;
3953  } else if (track) {
3954  pkt->dts = pkt->pts = track->sample_count;
3955  pkt->duration = 1;
3956  track->sample_count++;
3957  }
3958  return 0;
3959 }
3960 
3962 {
3963  KLVPacket klv;
3964  MXFContext *mxf = s->priv_data;
3965  int ret;
3966 
3967  while (1) {
3968  int64_t max_data_size;
3969  int64_t pos = avio_tell(s->pb);
3970 
3971  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3972  mxf->current_klv_data = (KLVPacket){{0}};
3973  ret = klv_read_packet(mxf, &klv, s->pb);
3974  if (ret < 0)
3975  break;
3976  max_data_size = klv.length;
3977  pos = klv.next_klv - klv.length;
3978  PRINT_KEY(s, "read packet", klv.key);
3979  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3981  ret = mxf_decrypt_triplet(s, pkt, &klv);
3982  if (ret < 0) {
3983  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3984  return ret;
3985  }
3986  return 0;
3987  }
3988  } else {
3989  klv = mxf->current_klv_data;
3990  max_data_size = klv.next_klv - pos;
3991  }
3995  int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3996  int index = mxf_get_stream_index(s, &klv, body_sid);
3997  int64_t next_ofs;
3998  AVStream *st;
3999  MXFTrack *track;
4000 
4001  if (index < 0) {
4003  "error getting stream index %"PRIu32"\n",
4004  AV_RB32(klv.key + 12));
4005  goto skip;
4006  }
4007 
4008  st = s->streams[index];
4009  track = st->priv_data;
4010 
4011  if (s->streams[index]->discard == AVDISCARD_ALL)
4012  goto skip;
4013 
4014  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
4015 
4016  if (track->wrapping != FrameWrapped) {
4017  int64_t size;
4018 
4019  if (next_ofs <= 0) {
4020  // If we have no way to packetize the data, then return it in chunks...
4021  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
4023  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
4024  }
4025  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
4026  } else {
4027  if ((size = next_ofs - pos) <= 0) {
4028  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
4029  mxf->current_klv_data = (KLVPacket){{0}};
4030  return AVERROR_INVALIDDATA;
4031  }
4032  // We must not overread, because the next edit unit might be in another KLV
4033  if (size > max_data_size)
4034  size = max_data_size;
4035  }
4036 
4037  mxf->current_klv_data = klv;
4038  klv.offset = pos;
4039  klv.length = size;
4040  klv.next_klv = klv.offset + klv.length;
4041  }
4042 
4043  /* check for 8 channels AES3 element */
4044  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
4045  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
4046  pkt, klv.length);
4047  if (ret < 0) {
4048  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
4049  mxf->current_klv_data = (KLVPacket){{0}};
4050  return ret;
4051  }
4052  } else if (mxf->eia608_extract &&
4053  s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4054  ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4055  if (ret < 0) {
4056  mxf->current_klv_data = (KLVPacket){{0}};
4057  return ret;
4058  }
4059  } else {
4060  ret = av_get_packet(s->pb, pkt, klv.length);
4061  if (ret < 0) {
4062  mxf->current_klv_data = (KLVPacket){{0}};
4063  return ret;
4064  }
4065  }
4066  pkt->stream_index = index;
4067  pkt->pos = klv.offset;
4068 
4069  ret = mxf_set_pts(mxf, st, pkt);
4070  if (ret < 0) {
4071  mxf->current_klv_data = (KLVPacket){{0}};
4072  return ret;
4073  }
4074 
4075  /* seek for truncated packets */
4076  avio_seek(s->pb, klv.next_klv, SEEK_SET);
4077 
4078  return 0;
4079  } else {
4080  skip:
4081  avio_skip(s->pb, max_data_size);
4082  mxf->current_klv_data = (KLVPacket){{0}};
4083  }
4084  }
4085  return avio_feof(s->pb) ? AVERROR_EOF : ret;
4086 }
4087 
4089 {
4090  MXFContext *mxf = s->priv_data;
4091  int i;
4092 
4093  av_freep(&mxf->packages_refs);
4095 
4096  for (i = 0; i < s->nb_streams; i++)
4097  s->streams[i]->priv_data = NULL;
4098 
4099  for (int type = 0; type < FF_ARRAY_ELEMS(mxf->metadata_set_groups); type++) {
4101  for (i = 0; i < mg->metadata_sets_count; i++)
4102  mxf_free_metadataset(mg->metadata_sets + i, type);
4103  mg->metadata_sets_count = 0;
4104  av_freep(&mg->metadata_sets);
4105  }
4106  av_freep(&mxf->partitions);
4107  av_freep(&mxf->aesc);
4108  av_freep(&mxf->local_tags);
4109 
4110  if (mxf->index_tables) {
4111  for (i = 0; i < mxf->nb_index_tables; i++) {
4112  av_freep(&mxf->index_tables[i].segments);
4113  av_freep(&mxf->index_tables[i].ptses);
4115  av_freep(&mxf->index_tables[i].offsets);
4116  }
4117  }
4118  av_freep(&mxf->index_tables);
4119 
4120  return 0;
4121 }
4122 
4123 static int mxf_probe(const AVProbeData *p) {
4124  const uint8_t *bufp = p->buf;
4125  const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4126 
4127  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4128  return 0;
4129 
4130  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4131  end -= sizeof(mxf_header_partition_pack_key);
4132 
4133  for (; bufp < end;) {
4134  if (!((bufp[13] - 1) & 0xF2)){
4135  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4136  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4137  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4139  return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4140  bufp ++;
4141  } else
4142  bufp += 10;
4143  }
4144 
4145  return 0;
4146 }
4147 
4148 /* rudimentary byte seek */
4149 /* XXX: use MXF Index */
4150 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4151 {
4152  AVStream *st = s->streams[stream_index];
4153  int64_t seconds;
4154  MXFContext* mxf = s->priv_data;
4155  int64_t seekpos;
4156  int i, ret;
4157  MXFIndexTable *t;
4158  MXFTrack *source_track = st->priv_data;
4159 
4160  if (!source_track)
4161  return 0;
4162 
4163  /* if audio then truncate sample_time to EditRate */
4165  sample_time = av_rescale_q(sample_time, st->time_base,
4166  av_inv_q(source_track->edit_rate));
4167 
4168  if (mxf->nb_index_tables <= 0) {
4169  if (!s->bit_rate)
4170  return AVERROR_INVALIDDATA;
4171  if (sample_time < 0)
4172  sample_time = 0;
4173  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4174 
4175  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4176  if (seekpos < 0)
4177