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