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