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