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