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