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