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