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