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