FFmpeg  4.3.8
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  *
32  * Principle
33  * Search for Track numbers which will identify essence element KLV packets.
34  * Search for SourcePackage which define tracks which contains Track numbers.
35  * Material Package contains tracks with reference to SourcePackage tracks.
36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37  * Assign Descriptors to correct Tracks.
38  *
39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40  * Metadata parsing resolves Strong References to objects.
41  *
42  * Simple demuxer, only OP1A supported and some files might not work at all.
43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
44  */
45 
46 #include <inttypes.h>
47 
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/timecode.h"
55 #include "libavutil/opt.h"
56 #include "avformat.h"
57 #include "internal.h"
58 #include "mxf.h"
59 
60 #define MXF_MAX_CHUNK_SIZE (32 << 20)
61 #define RUN_IN_MAX (65535+1) // S377m-2004 section 5.5 and S377-1-2009 section 6.5, the +1 is to be slightly more tolerant
62 
63 typedef enum {
68 
69 typedef enum {
70  OP1a = 1,
80  OPSONYOpt, /* FATE sample, violates the spec in places */
81 } MXFOP;
82 
83 typedef enum {
88 
89 typedef struct MXFPartition {
90  int closed;
91  int complete;
94  int index_sid;
95  int body_sid;
97  int64_t essence_offset; ///< absolute offset of essence
103  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
106 } MXFPartition;
107 
108 typedef struct MXFCryptoContext {
113 
114 typedef struct MXFStructuralComponent {
124 
125 typedef struct MXFSequence {
133 } MXFSequence;
134 
135 typedef struct MXFTimecodeComponent {
140  struct AVRational rate;
143 
144 typedef struct {
149 
150 typedef struct {
157 
158 typedef struct {
161  char *name;
162  char *value;
164 
165 typedef struct {
168  MXFSequence *sequence; /* mandatory, and only one */
170  int track_id;
171  char *name;
172  uint8_t track_number[4];
175  uint64_t sample_count;
176  int64_t original_duration; /* st->duration in SampleRate/EditRate units */
178  int body_sid;
180  int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
181 } MXFTrack;
182 
183 typedef struct MXFDescriptor {
191  int width;
192  int height; /* Field height, not frame height */
193  int frame_layout; /* See MXFFrameLayout enum */
194  int video_line_map[2];
195 #define MXF_FIELD_DOMINANCE_DEFAULT 0
196 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
197 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
199  int channels;
201  int64_t duration; /* ContainerDuration optional property */
202  unsigned int component_depth;
203  unsigned int horiz_subsampling;
204  unsigned int vert_subsampling;
211 } MXFDescriptor;
212 
213 typedef struct MXFIndexTableSegment {
218  int body_sid;
221  uint64_t index_duration;
227 
228 typedef struct MXFPackage {
235  MXFDescriptor *descriptor; /* only one */
237  char *name;
240 } MXFPackage;
241 
242 typedef struct MXFEssenceContainerData {
248  int body_sid;
250 
251 typedef struct MXFMetadataSet {
255 
256 /* decoded index table */
257 typedef struct MXFIndexTable {
259  int body_sid;
260  int nb_ptses; /* number of PTSes or total duration of index */
261  int64_t first_dts; /* DTS = EditUnit + first_dts */
262  int64_t *ptses; /* maps EditUnit -> PTS */
264  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
265  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
266  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
267 } MXFIndexTable;
268 
269 typedef struct MXFContext {
270  const AVClass *class; /**< Class for private options. */
281  struct AVAES *aesc;
286  int run_in;
294 } MXFContext;
295 
296 /* NOTE: klv_offset is not set (-1) for local keys */
297 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
298 
300  const UID key;
302  int ctx_size;
305 
306 static int mxf_read_close(AVFormatContext *s);
307 
308 /* partial keys to match */
309 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
310 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
311 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
312 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
313 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
314 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
315 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
316 /* complete keys to match */
317 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
318 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
319 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
320 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
321 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
322 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
323 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
324 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
325 static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
326 
327 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
328 
329 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
330 {
332  switch ((*ctx)->type) {
333  case Descriptor:
334  case MultipleDescriptor:
335  av_freep(&((MXFDescriptor *)*ctx)->extradata);
336  av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
337  break;
338  case Sequence:
339  av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
340  break;
341  case EssenceGroup:
342  av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
343  break;
344  case SourcePackage:
345  case MaterialPackage:
346  av_freep(&((MXFPackage *)*ctx)->tracks_refs);
347  av_freep(&((MXFPackage *)*ctx)->name);
348  av_freep(&((MXFPackage *)*ctx)->comment_refs);
349  break;
350  case TaggedValue:
351  av_freep(&((MXFTaggedValue *)*ctx)->name);
352  av_freep(&((MXFTaggedValue *)*ctx)->value);
353  break;
354  case Track:
355  av_freep(&((MXFTrack *)*ctx)->name);
356  break;
357  case IndexTableSegment:
358  seg = (MXFIndexTableSegment *)*ctx;
360  av_freep(&seg->flag_entries);
362  default:
363  break;
364  }
365  if (freectx) {
366  av_freep(ctx);
367  }
368 }
369 
371 {
372  uint64_t size = avio_r8(pb);
373  if (size & 0x80) { /* long form */
374  int bytes_num = size & 0x7f;
375  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
376  if (bytes_num > 8)
377  return AVERROR_INVALIDDATA;
378  size = 0;
379  while (bytes_num--)
380  size = size << 8 | avio_r8(pb);
381  }
382  if (size > INT64_MAX)
383  return AVERROR_INVALIDDATA;
384  return size;
385 }
386 
387 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
388 {
389  int i, b;
390  for (i = 0; i < size && !avio_feof(pb); i++) {
391  b = avio_r8(pb);
392  if (b == key[0])
393  i = 0;
394  else if (b != key[i])
395  i = -1;
396  }
397  return i == size;
398 }
399 
400 static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
401 {
402  int64_t length, pos;
403  if (!mxf_read_sync(pb, mxf_klv_key, 4))
404  return AVERROR_INVALIDDATA;
405  klv->offset = avio_tell(pb) - 4;
406  if (klv->offset < mxf->run_in)
407  return AVERROR_INVALIDDATA;
408 
409  memcpy(klv->key, mxf_klv_key, 4);
410  avio_read(pb, klv->key + 4, 12);
411  length = klv_decode_ber_length(pb);
412  if (length < 0)
413  return length;
414  klv->length = length;
415  pos = avio_tell(pb);
416  if (pos > INT64_MAX - length)
417  return AVERROR_INVALIDDATA;
418  klv->next_klv = pos + length;
419  return 0;
420 }
421 
423 {
424  int i;
425 
426  for (i = 0; i < s->nb_streams; i++) {
427  MXFTrack *track = s->streams[i]->priv_data;
428  /* SMPTE 379M 7.3 */
429  if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
430  return i;
431  }
432  /* return 0 if only one stream, for OP Atom files with 0 as track number */
433  return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
434 }
435 
437 {
438  // we look for partition where the offset is placed
439  int a, b, m;
441 
442  a = -1;
443  b = mxf->partitions_count;
444 
445  while (b - a > 1) {
446  m = (a + b) >> 1;
447  pack_ofs = mxf->partitions[m].pack_ofs;
448  if (pack_ofs <= offset)
449  a = m;
450  else
451  b = m;
452  }
453 
454  if (a == -1)
455  return 0;
456  return mxf->partitions[a].body_sid;
457 }
458 
460 {
461  int count = avio_rb16(s->pb);
462  int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
463  int line_num, sample_coding, sample_count;
464  int did, sdid, data_length;
465  int i, ret;
466 
467  if (count != 1)
468  av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
469 
470  for (i = 0; i < count; i++) {
471  if (length < 6) {
472  av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
473  return AVERROR_INVALIDDATA;
474  }
475  line_num = avio_rb16(s->pb);
476  avio_r8(s->pb); // wrapping type
477  sample_coding = avio_r8(s->pb);
478  sample_count = avio_rb16(s->pb);
479  length -= 6 + 8 + sample_count;
480  if (line_num != 9 && line_num != 11)
481  continue;
482  if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
483  av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
484  continue;
485  }
486  if (length < 0)
487  return AVERROR_INVALIDDATA;
488 
489  avio_rb32(s->pb); // array count
490  avio_rb32(s->pb); // array elem size
491  did = avio_r8(s->pb);
492  sdid = avio_r8(s->pb);
493  data_length = avio_r8(s->pb);
494  if (did != 0x61 || sdid != 1) {
495  av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
496  continue;
497  }
498  cdp_identifier = avio_rb16(s->pb); // cdp id
499  if (cdp_identifier != 0x9669) {
500  av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
501  return AVERROR_INVALIDDATA;
502  }
503  cdp_length = avio_r8(s->pb);
504  avio_r8(s->pb); // cdp_frame_rate
505  avio_r8(s->pb); // cdp_flags
506  avio_rb16(s->pb); // cdp_hdr_sequence_cntr
507  ccdata_id = avio_r8(s->pb); // ccdata_id
508  if (ccdata_id != 0x72) {
509  av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
510  return AVERROR_INVALIDDATA;
511  }
512  cc_count = avio_r8(s->pb) & 0x1f;
513  ret = av_get_packet(s->pb, pkt, cc_count * 3);
514  if (ret < 0)
515  return ret;
516  if (cdp_length - 9 - 4 < cc_count * 3) {
517  av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
518  return AVERROR_INVALIDDATA;
519  }
520  avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
521  cdp_footer_id = avio_r8(s->pb);
522  if (cdp_footer_id != 0x74) {
523  av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
524  return AVERROR_INVALIDDATA;
525  }
526  avio_rb16(s->pb); // cdp_ftr_sequence_cntr
527  avio_r8(s->pb); // packet_checksum
528  break;
529  }
530 
531  return 0;
532 }
533 
534 /* XXX: use AVBitStreamFilter */
536 {
537  const uint8_t *buf_ptr, *end_ptr;
538  uint8_t *data_ptr;
539  int i;
540 
541  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
542  return AVERROR_INVALIDDATA;
543  length = av_get_packet(pb, pkt, length);
544  if (length < 0)
545  return length;
546  data_ptr = pkt->data;
547  end_ptr = pkt->data + length;
548  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
549 
550  if (st->codecpar->channels > 8)
551  return AVERROR_INVALIDDATA;
552 
553  for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
554  for (i = 0; i < st->codecpar->channels; i++) {
555  uint32_t sample = bytestream_get_le32(&buf_ptr);
556  if (st->codecpar->bits_per_coded_sample == 24)
557  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
558  else
559  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
560  }
561  buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
562  }
563  av_shrink_packet(pkt, data_ptr - pkt->data);
564  return 0;
565 }
566 
568 {
569  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
570  MXFContext *mxf = s->priv_data;
571  AVIOContext *pb = s->pb;
572  int64_t end = avio_tell(pb) + klv->length;
573  int64_t size;
574  uint64_t orig_size;
575  uint64_t plaintext_size;
576  uint8_t ivec[16];
577  uint8_t tmpbuf[16];
578  int index;
579  int body_sid;
580 
581  if (!mxf->aesc && s->key && s->keylen == 16) {
582  mxf->aesc = av_aes_alloc();
583  if (!mxf->aesc)
584  return AVERROR(ENOMEM);
585  av_aes_init(mxf->aesc, s->key, 128, 1);
586  }
587  // crypto context
588  size = klv_decode_ber_length(pb);
589  if (size < 0)
590  return size;
591  avio_skip(pb, size);
592  // plaintext offset
594  plaintext_size = avio_rb64(pb);
595  // source klv key
597  avio_read(pb, klv->key, 16);
599  return AVERROR_INVALIDDATA;
600 
601  body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
602  index = mxf_get_stream_index(s, klv, body_sid);
603  if (index < 0)
604  return AVERROR_INVALIDDATA;
605  // source size
607  orig_size = avio_rb64(pb);
608  if (orig_size < plaintext_size)
609  return AVERROR_INVALIDDATA;
610  // enc. code
611  size = klv_decode_ber_length(pb);
612  if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)
613  return AVERROR_INVALIDDATA;
614  avio_read(pb, ivec, 16);
615  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  container_ul->desc &&
2566  !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2569  }
2570  }
2571  if (descriptor->extradata) {
2572  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2573  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2574  }
2575  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2576  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2577  &descriptor->essence_codec_ul)->id;
2578  if (coded_width)
2579  st->codecpar->width = coded_width;
2580  ret = ff_generate_avci_extradata(st);
2581  if (ret < 0)
2582  return ret;
2583  }
2584  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2585  /* TODO: decode timestamps */
2587  }
2588  }
2589 
2590  for (int i = 0; i < mxf->fc->nb_streams; i++) {
2591  MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
2592  if (track1 && track1->body_sid) {
2593  for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
2594  MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
2595  if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
2596  if (track1->wrapping == UnknownWrapped)
2597  track1->wrapping = track2->wrapping;
2598  else if (track2->wrapping == UnknownWrapped)
2599  track2->wrapping = track1->wrapping;
2600  else
2601  av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
2602  "with different wrapping\n", i, j, track1->body_sid);
2603  }
2604  }
2605  }
2606  }
2607 
2608  ret = 0;
2609 fail_and_free:
2610  return ret;
2611 }
2612 
2613 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2614 {
2615  struct tm time = { 0 };
2616  int msecs;
2617  time.tm_year = (timestamp >> 48) - 1900;
2618  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2619  time.tm_mday = (timestamp >> 32 & 0xFF);
2620  time.tm_hour = (timestamp >> 24 & 0xFF);
2621  time.tm_min = (timestamp >> 16 & 0xFF);
2622  time.tm_sec = (timestamp >> 8 & 0xFF);
2623  msecs = (timestamp & 0xFF) * 4;
2624 
2625  /* Clip values for legacy reasons. Maybe we should return error instead? */
2626  time.tm_mon = av_clip(time.tm_mon, 0, 11);
2627  time.tm_mday = av_clip(time.tm_mday, 1, 31);
2628  time.tm_hour = av_clip(time.tm_hour, 0, 23);
2629  time.tm_min = av_clip(time.tm_min, 0, 59);
2630  time.tm_sec = av_clip(time.tm_sec, 0, 59);
2631  msecs = av_clip(msecs, 0, 999);
2632 
2633  return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
2634 }
2635 
2636 #define SET_STR_METADATA(pb, name, str) do { \
2637  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2638  return ret; \
2639  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2640 } while (0)
2641 
2642 #define SET_UID_METADATA(pb, name, var, str) do { \
2643  avio_read(pb, var, 16); \
2644  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2645  return ret; \
2646  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2647 } while (0)
2648 
2649 #define SET_TS_METADATA(pb, name, var, str) do { \
2650  var = avio_rb64(pb); \
2651  if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2652  return ret; \
2653 } while (0)
2654 
2655 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2656 {
2657  MXFContext *mxf = arg;
2658  AVFormatContext *s = mxf->fc;
2659  int ret;
2660  UID uid = { 0 };
2661  char *str = NULL;
2662  uint64_t ts;
2663  switch (tag) {
2664  case 0x3C01:
2665  SET_STR_METADATA(pb, "company_name", str);
2666  break;
2667  case 0x3C02:
2668  SET_STR_METADATA(pb, "product_name", str);
2669  break;
2670  case 0x3C04:
2671  SET_STR_METADATA(pb, "product_version", str);
2672  break;
2673  case 0x3C05:
2674  SET_UID_METADATA(pb, "product_uid", uid, str);
2675  break;
2676  case 0x3C06:
2677  SET_TS_METADATA(pb, "modification_date", ts, str);
2678  break;
2679  case 0x3C08:
2680  SET_STR_METADATA(pb, "application_platform", str);
2681  break;
2682  case 0x3C09:
2683  SET_UID_METADATA(pb, "generation_uid", uid, str);
2684  break;
2685  case 0x3C0A:
2686  SET_UID_METADATA(pb, "uid", uid, str);
2687  break;
2688  }
2689  return 0;
2690 }
2691 
2692 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2693 {
2694  MXFContext *mxf = arg;
2695  AVFormatContext *s = mxf->fc;
2696  int ret;
2697  char *str = NULL;
2698 
2699  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2700  SET_STR_METADATA(pb, "project_name", str);
2701  }
2702  return 0;
2703 }
2704 
2706  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2707  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2708  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2709  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2710  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2711  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2712  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2713  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2714  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2715  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2716  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2717  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2718  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2719  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2720  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2721  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2722  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2723  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2724  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2725  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2726  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2727  { { 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 */
2728  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2729  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2730  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2731  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2732  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2733  { { 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 */
2734  { { 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 */
2735  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2736  { { 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 */
2737  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2738  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2739  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2740  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2741  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2742  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2743  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2744  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2745 };
2746 
2748 {
2749  ctx->type = type;
2750  switch (type){
2751  case MultipleDescriptor:
2752  case Descriptor:
2753  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2754  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2755  break;
2756  default:
2757  break;
2758  }
2759  return 0;
2760 }
2761 
2762 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2763 {
2764  AVIOContext *pb = mxf->fc->pb;
2765  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2766  uint64_t klv_end = avio_tell(pb) + klv->length;
2767 
2768  if (!ctx)
2769  return AVERROR(ENOMEM);
2770  if (ctx_size)
2771  mxf_metadataset_init(ctx, type);
2772  while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2773  int ret;
2774  int tag = avio_rb16(pb);
2775  int size = avio_rb16(pb); /* KLV specified by 0x53 */
2776  int64_t next = avio_tell(pb);
2777  UID uid = {0};
2778  if (next < 0 || next > INT64_MAX - size)
2779  return next < 0 ? next : AVERROR_INVALIDDATA;
2780  next += size;
2781 
2782  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2783  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2784  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2785  continue;
2786  }
2787  if (tag > 0x7FFF) { /* dynamic tag */
2788  int i;
2789  for (i = 0; i < mxf->local_tags_count; i++) {
2790  int local_tag = AV_RB16(mxf->local_tags+i*18);
2791  if (local_tag == tag) {
2792  memcpy(uid, mxf->local_tags+i*18+2, 16);
2793  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2794  PRINT_KEY(mxf->fc, "uid", uid);
2795  }
2796  }
2797  }
2798  if (ctx_size && tag == 0x3C0A) {
2799  avio_read(pb, ctx->uid, 16);
2800  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2801  if (ctx_size)
2802  mxf_free_metadataset(&ctx, 1);
2803  return ret;
2804  }
2805 
2806  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2807  * it extending past the end of the KLV though (zzuf5.mxf). */
2808  if (avio_tell(pb) > klv_end) {
2809  if (ctx_size) {
2810  mxf_free_metadataset(&ctx, 1);
2811  }
2812 
2813  av_log(mxf->fc, AV_LOG_ERROR,
2814  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2815  tag, klv->offset);
2816  return AVERROR_INVALIDDATA;
2817  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2818  avio_seek(pb, next, SEEK_SET);
2819  }
2820  return ctx_size ? mxf_add_metadata_set(mxf, &ctx) : 0;
2821 }
2822 
2823 /**
2824  * Matches any partition pack key, in other words:
2825  * - HeaderPartition
2826  * - BodyPartition
2827  * - FooterPartition
2828  * @return non-zero if the key is a partition pack key, zero otherwise
2829  */
2831 {
2832  //NOTE: this is a little lax since it doesn't constraint key[14]
2833  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2834  key[13] >= 2 && key[13] <= 4;
2835 }
2836 
2837 /**
2838  * Parses a metadata KLV
2839  * @return <0 on error, 0 otherwise
2840  */
2842  int ctx_size, enum MXFMetadataSetType type)
2843 {
2844  AVFormatContext *s = mxf->fc;
2845  int res;
2846  if (klv.key[5] == 0x53) {
2847  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2848  } else {
2849  uint64_t next = avio_tell(s->pb) + klv.length;
2850  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2851 
2852  /* only seek forward, else this can loop for a long time */
2853  if (avio_tell(s->pb) > next) {
2854  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2855  klv.offset);
2856  return AVERROR_INVALIDDATA;
2857  }
2858 
2859  avio_seek(s->pb, next, SEEK_SET);
2860  }
2861  if (res < 0) {
2862  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2863  return res;
2864  }
2865  return 0;
2866 }
2867 
2868 /**
2869  * Seeks to the previous partition and parses it, if possible
2870  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2871  */
2873 {
2874  AVIOContext *pb = mxf->fc->pb;
2875  KLVPacket klv;
2876  int64_t current_partition_ofs;
2877  int ret;
2878 
2879  if (!mxf->current_partition ||
2881  return 0; /* we've parsed all partitions */
2882 
2883  /* seek to previous partition */
2884  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2885  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2886  mxf->current_partition = NULL;
2887 
2888  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2889 
2890  /* Make sure this is actually a PartitionPack, and if so parse it.
2891  * See deadlock2.mxf
2892  */
2893  if ((ret = klv_read_packet(mxf, &klv, pb)) < 0) {
2894  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2895  return ret;
2896  }
2897 
2898  if (!mxf_is_partition_pack_key(klv.key)) {
2899  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2900  return AVERROR_INVALIDDATA;
2901  }
2902 
2903  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2904  * can point to just before the current partition, causing klv_read_packet()
2905  * to sync back up to it. See deadlock3.mxf
2906  */
2907  if (klv.offset >= current_partition_ofs) {
2908  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2909  PRIx64 " indirectly points to itself\n", current_partition_ofs);
2910  return AVERROR_INVALIDDATA;
2911  }
2912 
2913  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2914  return ret;
2915 
2916  return 1;
2917 }
2918 
2919 /**
2920  * Called when essence is encountered
2921  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2922  */
2924 {
2925  AVIOContext *pb = mxf->fc->pb;
2926  int64_t ret;
2927 
2928  if (mxf->parsing_backward) {
2929  return mxf_seek_to_previous_partition(mxf);
2930  } else {
2931  if (!mxf->footer_partition) {
2932  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2933  return 0;
2934  }
2935 
2936  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2937 
2938  /* remember where we were so we don't end up seeking further back than this */
2939  mxf->last_forward_tell = avio_tell(pb);
2940 
2941  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2942  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2943  return -1;
2944  }
2945 
2946  /* seek to FooterPartition and parse backward */
2947  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2948  av_log(mxf->fc, AV_LOG_ERROR,
2949  "failed to seek to FooterPartition @ 0x%" PRIx64
2950  " (%"PRId64") - partial file?\n",
2951  mxf->run_in + mxf->footer_partition, ret);
2952  return ret;
2953  }
2954 
2955  mxf->current_partition = NULL;
2956  mxf->parsing_backward = 1;
2957  }
2958 
2959  return 1;
2960 }
2961 
2962 /**
2963  * Called when the next partition or EOF is encountered
2964  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2965  */
2967 {
2968  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2969 }
2970 
2972 {
2973  for (int i = 0; i < s->nb_streams; i++) {
2974  MXFTrack *track = s->streams[i]->priv_data;
2975  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2976  return track->wrapping;
2977  }
2978  return UnknownWrapped;
2979 }
2980 
2981 /**
2982  * Figures out the proper offset and length of the essence container in each partition
2983  */
2985 {
2986  MXFContext *mxf = s->priv_data;
2987  int x;
2988 
2989  for (x = 0; x < mxf->partitions_count; x++) {
2990  MXFPartition *p = &mxf->partitions[x];
2991  MXFWrappingScheme wrapping;
2992 
2993  if (!p->body_sid)
2994  continue; /* BodySID == 0 -> no essence */
2995 
2996  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2997  * otherwise we point essence_offset at the key of the first essence KLV.
2998  */
2999 
3000  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3001 
3002  if (wrapping == ClipWrapped) {
3005  } else {
3007 
3008  /* essence container spans to the next partition */
3009  if (x < mxf->partitions_count - 1)
3011 
3012  if (p->essence_length < 0) {
3013  /* next ThisPartition < essence_offset */
3014  p->essence_length = 0;
3015  av_log(mxf->fc, AV_LOG_ERROR,
3016  "partition %i: bad ThisPartition = %"PRIX64"\n",
3017  x+1, mxf->partitions[x+1].this_partition);
3018  }
3019  }
3020  }
3021 }
3022 
3023 static int is_pcm(enum AVCodecID codec_id)
3024 {
3025  /* we only care about "normal" PCM codecs until we get samples */
3026  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
3027 }
3028 
3030 {
3031  int i;
3032  for (i = 0; i < mxf->nb_index_tables; i++)
3033  if (mxf->index_tables[i].index_sid == index_sid)
3034  return &mxf->index_tables[i];
3035  return NULL;
3036 }
3037 
3038 /**
3039  * Deal with the case where for some audio atoms EditUnitByteCount is
3040  * very small (2, 4..). In those cases we should read more than one
3041  * sample per call to mxf_read_packet().
3042  */
3044 {
3045  MXFTrack *track = st->priv_data;
3046  MXFIndexTable *t;
3047 
3048  if (!track)
3049  return;
3050  track->edit_units_per_packet = 1;
3051  if (track->wrapping != ClipWrapped)
3052  return;
3053 
3054  t = mxf_find_index_table(mxf, track->index_sid);
3055 
3056  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3057  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3058  !is_pcm(st->codecpar->codec_id) ||
3059  !t ||
3060  t->nb_segments != 1 ||
3061  t->segments[0]->edit_unit_byte_count >= 32)
3062  return;
3063 
3064  /* arbitrarily default to 48 kHz PAL audio frame size */
3065  /* TODO: We could compute this from the ratio between the audio
3066  * and video edit rates for 48 kHz NTSC we could use the
3067  * 1802-1802-1802-1802-1801 pattern. */
3068  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3069 }
3070 
3071 /**
3072  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3073  */
3075 {
3076  MXFTrack *track = st->priv_data;
3078  MXFPartition *p = NULL;
3079  int essence_partition_count = 0;
3080  int edit_unit_byte_count = 0;
3081  int i, ret;
3082 
3083  if (!track || track->wrapping != ClipWrapped)
3084  return 0;
3085 
3086  /* check if track already has an IndexTableSegment */
3087  for (i = 0; i < mxf->metadata_sets_count; i++) {
3088  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3090  if (s->body_sid == track->body_sid)
3091  return 0;
3092  }
3093  }
3094 
3095  /* find the essence partition */
3096  for (i = 0; i < mxf->partitions_count; i++) {
3097  /* BodySID == 0 -> no essence */
3098  if (mxf->partitions[i].body_sid != track->body_sid)
3099  continue;
3100 
3101  p = &mxf->partitions[i];
3102  essence_partition_count++;
3103  }
3104 
3105  /* only handle files with a single essence partition */
3106  if (essence_partition_count != 1)
3107  return 0;
3108 
3110  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3111  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3112  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3113  }
3114 
3115  if (edit_unit_byte_count <= 0)
3116  return 0;
3117 
3118  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);
3119 
3120  if (!(segment = av_mallocz(sizeof(*segment))))
3121  return AVERROR(ENOMEM);
3122 
3123  if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3124  return ret;
3125 
3126  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3127  * using the same SID for index is forbidden in MXF. */
3128  if (!track->index_sid)
3129  track->index_sid = track->body_sid;
3130 
3131  segment->type = IndexTableSegment;
3132  /* stream will be treated as small EditUnitByteCount */
3133  segment->edit_unit_byte_count = edit_unit_byte_count;
3134  segment->index_start_position = 0;
3135  segment->index_duration = st->duration;
3136  segment->index_edit_rate = av_inv_q(st->time_base);
3137  segment->index_sid = track->index_sid;
3138  segment->body_sid = p->body_sid;
3139  return 0;
3140 }
3141 
3143 {
3144  MXFContext *mxf = s->priv_data;
3145  uint32_t length;
3146  int64_t file_size, max_rip_length, min_rip_length;
3147  KLVPacket klv;
3148 
3149  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3150  return;
3151 
3152  file_size = avio_size(s->pb);
3153 
3154  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3155  * The limit below assumes a file with nothing but partition packs and a RIP.
3156  * Before changing this, consider that a muxer may place each sample in its own partition.
3157  *
3158  * 105 is the size of the smallest possible PartitionPack
3159  * 12 is the size of each RIP entry
3160  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3161  */
3162  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3163  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3164 
3165  /* We're only interested in RIPs with at least two entries.. */
3166  min_rip_length = 16+1+24+4;
3167 
3168  /* See S377m section 11 */
3169  avio_seek(s->pb, file_size - 4, SEEK_SET);
3170  length = avio_rb32(s->pb);
3171 
3172  if (length < min_rip_length || length > max_rip_length)
3173  goto end;
3174  avio_seek(s->pb, file_size - length, SEEK_SET);
3175  if (klv_read_packet(mxf, &klv, s->pb) < 0 ||
3177  goto end;
3178  if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3179  av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3180  goto end;
3181  }
3182 
3183  avio_skip(s->pb, klv.length - 12);
3184  mxf->footer_partition = avio_rb64(s->pb);
3185 
3186  /* sanity check */
3187  if (mxf->run_in + mxf->footer_partition >= file_size) {
3188  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3189  mxf->footer_partition = 0;
3190  }
3191 
3192 end:
3193  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3194 }
3195 
3197 {
3198  MXFContext *mxf = s->priv_data;
3199  KLVPacket klv;
3200  int64_t essence_offset = 0;
3201  int ret;
3202  int64_t run_in;
3203 
3204  mxf->last_forward_tell = INT64_MAX;
3205 
3207  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3208  //goto fail should not be needed as no metadata sets will have been parsed yet
3209  return AVERROR_INVALIDDATA;
3210  }
3211  avio_seek(s->pb, -14, SEEK_CUR);
3212  mxf->fc = s;
3213  run_in = avio_tell(s->pb);
3214  if (run_in < 0 || run_in > RUN_IN_MAX)
3215  return AVERROR_INVALIDDATA;
3216  mxf->run_in = run_in;
3217 
3219 
3220  while (!avio_feof(s->pb)) {
3221  const MXFMetadataReadTableEntry *metadata;
3222 
3223  if (klv_read_packet(mxf, &klv, s->pb) < 0) {
3224  /* EOF - seek to previous partition or stop */
3225  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3226  break;
3227  else
3228  continue;
3229  }
3230 
3231  PRINT_KEY(s, "read header", klv.key);
3232  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3239 
3240  if (!mxf->current_partition) {
3241  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3242  ret = AVERROR_INVALIDDATA;
3243  goto fail;
3244  }
3245 
3248 
3249  if (!essence_offset)
3250  essence_offset = klv.offset;
3251 
3252  /* seek to footer, previous partition or stop */
3253  if (mxf_parse_handle_essence(mxf) <= 0)
3254  break;
3255  continue;
3256  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3257  /* next partition pack - keep going, seek to previous partition or stop */
3258  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3259  break;
3260  else if (mxf->parsing_backward)
3261  continue;
3262  /* we're still parsing forward. proceed to parsing this partition pack */
3263  }
3264 
3265  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3266  if (IS_KLV_KEY(klv.key, metadata->key)) {
3267  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3268  goto fail;
3269  break;
3270  }
3271  }
3272  if (!metadata->read) {
3273  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3274  UID_ARG(klv.key));
3275  avio_skip(s->pb, klv.length);
3276  }
3277  }
3278  /* FIXME avoid seek */
3279  if (!essence_offset) {
3280  av_log(s, AV_LOG_ERROR, "no essence\n");
3281  ret = AVERROR_INVALIDDATA;
3282  goto fail;
3283  }
3284  avio_seek(s->pb, essence_offset, SEEK_SET);
3285 
3286  /* we need to do this before computing the index tables
3287  * to be able to fill in zero IndexDurations with st->duration */
3288  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3289  goto fail;
3290 
3291  for (int i = 0; i < s->nb_streams; i++)
3293 
3294  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3295  goto fail;
3296 
3297  if (mxf->nb_index_tables > 1) {
3298  /* TODO: look up which IndexSID to use via EssenceContainerData */
3299  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3300  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3301  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3302  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3303  ret = AVERROR_INVALIDDATA;
3304  goto fail;
3305  }
3306 
3308 
3309  for (int i = 0; i < s->nb_streams; i++)
3311 
3312  return 0;
3313 fail:
3314  mxf_read_close(s);
3315 
3316  return ret;
3317 }
3318 
3319 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3320 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3321 {
3322  int64_t a, b, m, offset;
3323  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3324 
3325  if (!t || track->original_duration <= 0)
3326  return -1;
3327 
3328  a = -1;
3329  b = track->original_duration;
3330  while (b - 1 > a) {
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:2705
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:2872
#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:3142
#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:2649
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:3043
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:3196
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:2841
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:2966
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition: mxfdec.c:2762
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:3023
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:2642
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:1583
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c: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:2984
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:2923
#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:3320
#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:2655
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:3029
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:3074
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:2747
Definition: mxfdec.c:70
#define AV_RN16(p)
Definition: intreadwrite.h:360
long long int64_t
Definition: coverity.c:34
int run_in
Definition: mxfdec.c:286
KLVPacket first_essence_klv
Definition: mxfdec.c:105
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int comment_count
Definition: mxfdec.c:239
double value
Definition: eval.c:98
static const MXFCodecUL mxf_data_essence_container_uls[]
Definition: mxfdec.c: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:576
static const uint8_t mxf_indirect_value_utf16be[]
Definition: mxfdec.c:325
static int64_t klv_decode_ber_length(AVIOContext *pb)
Definition: mxfdec.c:370
MXFWrappingScheme
Definition: mxfdec.c:83
int64_t duration
Definition: mxfdec.c:155
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:84
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
Definition: mxfdec.c: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:1215
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:2613
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:2830
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:2692
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:2971
#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:2636
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