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