FFmpeg
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  *
32  * Principle
33  * Search for Track numbers which will identify essence element KLV packets.
34  * Search for SourcePackage which define tracks which contains Track numbers.
35  * Material Package contains tracks with reference to SourcePackage tracks.
36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37  * Assign Descriptors to correct Tracks.
38  *
39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40  * Metadata parsing resolves Strong References to objects.
41  *
42  * Simple demuxer, only OP1A supported and some files might not work at all.
43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
44  */
45 
46 #include <inttypes.h>
47 
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/timecode.h"
55 #include "libavutil/opt.h"
56 #include "avformat.h"
57 #include "internal.h"
58 #include "mxf.h"
59 
60 #define MXF_MAX_CHUNK_SIZE (32 << 20)
61 
62 typedef enum {
67 
68 typedef enum {
69  OP1a = 1,
79  OPSONYOpt, /* FATE sample, violates the spec in places */
80 } MXFOP;
81 
82 typedef enum {
87 
88 typedef struct MXFPartition {
89  int closed;
90  int complete;
93  int index_sid;
94  int body_sid;
95  int64_t this_partition;
96  int64_t essence_offset; ///< absolute offset of essence
97  int64_t essence_length;
102  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
103  int64_t body_offset;
105 } MXFPartition;
106 
107 typedef struct MXFCryptoContext {
112 
113 typedef struct MXFStructuralComponent {
119  int64_t duration;
120  int64_t start_position;
123 
124 typedef struct MXFSequence {
130  int64_t duration;
132 } MXFSequence;
133 
134 typedef struct 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 */
193  int video_line_map[2];
194 #define MXF_FIELD_DOMINANCE_DEFAULT 0
195 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
196 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
198  int channels;
200  int64_t duration; /* ContainerDuration optional property */
201  unsigned int component_depth;
202  unsigned int horiz_subsampling;
203  unsigned int vert_subsampling;
210 } MXFDescriptor;
211 
212 typedef struct MXFIndexTableSegment {
217  int body_sid;
220  uint64_t index_duration;
226 
227 typedef struct MXFPackage {
234  MXFDescriptor *descriptor; /* only one */
236  char *name;
239 } MXFPackage;
240 
241 typedef struct MXFEssenceContainerData {
247  int body_sid;
249 
250 typedef struct MXFMetadataSet {
254 
255 /* decoded index table */
256 typedef struct MXFIndexTable {
258  int body_sid;
259  int nb_ptses; /* number of PTSes or total duration of index */
260  int64_t first_dts; /* DTS = EditUnit + first_dts */
261  int64_t *ptses; /* maps EditUnit -> PTS */
263  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
264  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
265  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
266 } MXFIndexTable;
267 
268 typedef struct MXFContext {
269  const AVClass *class; /**< Class for private options. */
280  struct AVAES *aesc;
285  int run_in;
293 } MXFContext;
294 
295 /* NOTE: klv_offset is not set (-1) for local keys */
296 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
297 
299  const UID key;
301  int ctx_size;
304 
305 static int mxf_read_close(AVFormatContext *s);
306 
307 /* partial keys to match */
308 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
309 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
310 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
311 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
312 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
313 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
314 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
315 /* complete keys to match */
316 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
317 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
318 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
319 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
320 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
321 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
322 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
323 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
324 static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
325 
326 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
327 
328 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
329 {
331  switch ((*ctx)->type) {
332  case Descriptor:
333  av_freep(&((MXFDescriptor *)*ctx)->extradata);
334  break;
335  case MultipleDescriptor:
336  av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
337  break;
338  case Sequence:
339  av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
340  break;
341  case EssenceGroup:
342  av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
343  break;
344  case SourcePackage:
345  case MaterialPackage:
346  av_freep(&((MXFPackage *)*ctx)->tracks_refs);
347  av_freep(&((MXFPackage *)*ctx)->name);
348  av_freep(&((MXFPackage *)*ctx)->comment_refs);
349  break;
350  case TaggedValue:
351  av_freep(&((MXFTaggedValue *)*ctx)->name);
352  av_freep(&((MXFTaggedValue *)*ctx)->value);
353  break;
354  case Track:
355  av_freep(&((MXFTrack *)*ctx)->name);
356  break;
357  case IndexTableSegment:
358  seg = (MXFIndexTableSegment *)*ctx;
360  av_freep(&seg->flag_entries);
362  default:
363  break;
364  }
365  if (freectx)
366  av_freep(ctx);
367 }
368 
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 
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,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16, AV_CODEC_ID_HEVC, NULL, 15 }, /* Canon XF-HEVC */
1332  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1333  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1334 };
1335 
1336 /* EC ULs for intra-only formats */
1338  { { 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 */
1339  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1340 };
1341 
1342 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1344  { { 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 */
1345  { { 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 */
1346  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1347 };
1348 
1349 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1351  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1352  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1353  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1354  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1355  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1356 };
1357 
1359  // sound essence container uls
1360  { { 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 */
1361  { { 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 */
1362  { { 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 */
1363  { { 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 */
1364  { { 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) */
1365  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1366 };
1367 
1369  { { 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 },
1370  { { 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 },
1371  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1372  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1373 };
1374 
1375 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1376 {
1377  int val;
1378  const MXFCodecUL *codec_ul;
1379 
1380  codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1381  if (!codec_ul->uid[0])
1382  codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1383  if (!codec_ul->uid[0])
1384  codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1385  if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1386  return UnknownWrapped;
1387 
1388  val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1389  switch (codec_ul->wrapping_indicator_type) {
1390  case RawVWrap:
1391  val = val % 4;
1392  break;
1393  case RawAWrap:
1394  if (val == 0x03 || val == 0x04)
1395  val -= 0x02;
1396  break;
1397  case D10D11Wrap:
1398  if (val == 0x02)
1399  val = 0x01;
1400  break;
1401  }
1402  if (val == 0x01)
1403  return FrameWrapped;
1404  if (val == 0x02)
1405  return ClipWrapped;
1406  return UnknownWrapped;
1407 }
1408 
1409 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1410 {
1411  int i, j, nb_segments = 0;
1412  MXFIndexTableSegment **unsorted_segments;
1413  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1414 
1415  /* count number of segments, allocate arrays and copy unsorted segments */
1416  for (i = 0; i < mxf->metadata_sets_count; i++)
1417  if (mxf->metadata_sets[i]->type == IndexTableSegment)
1418  nb_segments++;
1419 
1420  if (!nb_segments)
1421  return AVERROR_INVALIDDATA;
1422 
1423  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1424  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1425  av_freep(sorted_segments);
1426  av_free(unsorted_segments);
1427  return AVERROR(ENOMEM);
1428  }
1429 
1430  for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1431  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1434  unsorted_segments[nb_segments++] = s;
1435  else
1436  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1438  }
1439  }
1440 
1441  if (!nb_segments) {
1442  av_freep(sorted_segments);
1443  av_free(unsorted_segments);
1444  return AVERROR_INVALIDDATA;
1445  }
1446 
1447  *nb_sorted_segments = 0;
1448 
1449  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1450  for (i = 0; i < nb_segments; i++) {
1451  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1452  uint64_t best_index_duration = 0;
1453 
1454  for (j = 0; j < nb_segments; j++) {
1455  MXFIndexTableSegment *s = unsorted_segments[j];
1456 
1457  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1458  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1459  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1460  */
1461  if ((i == 0 ||
1462  s->body_sid > last_body_sid ||
1463  s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1464  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1465  (best == -1 ||
1466  s->body_sid < best_body_sid ||
1467  s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1468  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1469  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)) {
1470  best = j;
1471  best_body_sid = s->body_sid;
1472  best_index_sid = s->index_sid;
1473  best_index_start = s->index_start_position;
1474  best_index_duration = s->index_duration;
1475  }
1476  }
1477 
1478  /* no suitable entry found -> we're done */
1479  if (best == -1)
1480  break;
1481 
1482  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1483  last_body_sid = best_body_sid;
1484  last_index_sid = best_index_sid;
1485  last_index_start = best_index_start;
1486  }
1487 
1488  av_free(unsorted_segments);
1489 
1490  return 0;
1491 }
1492 
1493 /**
1494  * Computes the absolute file offset of the given essence container offset
1495  */
1496 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1497 {
1498  MXFPartition *last_p = NULL;
1499  int a, b, m, m0;
1500 
1501  if (offset < 0)
1502  return AVERROR(EINVAL);
1503 
1504  a = -1;
1505  b = mxf->partitions_count;
1506 
1507  while (b - a > 1) {
1508  m0 = m = (a + b) >> 1;
1509 
1510  while (m < b && mxf->partitions[m].body_sid != body_sid)
1511  m++;
1512 
1513  if (m < b && mxf->partitions[m].body_offset <= offset)
1514  a = m;
1515  else
1516  b = m0;
1517  }
1518 
1519  if (a >= 0)
1520  last_p = &mxf->partitions[a];
1521 
1522  if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1523  *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1524  if (partition_out)
1525  *partition_out = last_p;
1526  return 0;
1527  }
1528 
1529  av_log(mxf->fc, AV_LOG_ERROR,
1530  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1531  offset, body_sid);
1532 
1533  return AVERROR_INVALIDDATA;
1534 }
1535 
1536 /**
1537  * Returns the end position of the essence container with given BodySID, or zero if unknown
1538  */
1540 {
1541  int x;
1542  int64_t ret = 0;
1543 
1544  for (x = 0; x < mxf->partitions_count; x++) {
1545  MXFPartition *p = &mxf->partitions[x];
1546 
1547  if (p->body_sid != body_sid)
1548  continue;
1549 
1550  if (!p->essence_length)
1551  return 0;
1552 
1553  ret = p->essence_offset + p->essence_length;
1554  }
1555 
1556  return ret;
1557 }
1558 
1559 /* EditUnit -> absolute offset */
1560 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)
1561 {
1562  int i;
1563  int64_t offset_temp = 0;
1564 
1565  edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1566 
1567  for (i = 0; i < index_table->nb_segments; i++) {
1568  MXFIndexTableSegment *s = index_table->segments[i];
1569 
1570  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1571 
1572  if (edit_unit < s->index_start_position + s->index_duration) {
1573  int64_t index = edit_unit - s->index_start_position;
1574 
1575  if (s->edit_unit_byte_count)
1576  offset_temp += s->edit_unit_byte_count * index;
1577  else {
1578  if (s->nb_index_entries == 2 * s->index_duration + 1)
1579  index *= 2; /* Avid index */
1580 
1581  if (index < 0 || index >= s->nb_index_entries) {
1582  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1583  index_table->index_sid, s->index_start_position);
1584  return AVERROR_INVALIDDATA;
1585  }
1586 
1587  offset_temp = s->stream_offset_entries[index];
1588  }
1589 
1590  if (edit_unit_out)
1591  *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1592 
1593  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1594  } else {
1595  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1596  offset_temp += s->edit_unit_byte_count * s->index_duration;
1597  }
1598  }
1599 
1600  if (nag)
1601  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);
1602 
1603  return AVERROR_INVALIDDATA;
1604 }
1605 
1607 {
1608  int i, j, x;
1609  int8_t max_temporal_offset = -128;
1610  uint8_t *flags;
1611 
1612  /* first compute how many entries we have */
1613  for (i = 0; i < index_table->nb_segments; i++) {
1614  MXFIndexTableSegment *s = index_table->segments[i];
1615 
1616  if (!s->nb_index_entries) {
1617  index_table->nb_ptses = 0;
1618  return 0; /* no TemporalOffsets */
1619  }
1620 
1621  if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1622  index_table->nb_ptses = 0;
1623  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1624  return 0;
1625  }
1626 
1627  index_table->nb_ptses += s->index_duration;
1628  }
1629 
1630  /* paranoid check */
1631  if (index_table->nb_ptses <= 0)
1632  return 0;
1633 
1634  if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1635  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1636  !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1637  !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1638  av_freep(&index_table->ptses);
1639  av_freep(&index_table->fake_index);
1640  av_freep(&index_table->offsets);
1641  return AVERROR(ENOMEM);
1642  }
1643 
1644  /* we may have a few bad TemporalOffsets
1645  * make sure the corresponding PTSes don't have the bogus value 0 */
1646  for (x = 0; x < index_table->nb_ptses; x++)
1647  index_table->ptses[x] = AV_NOPTS_VALUE;
1648 
1649  /**
1650  * We have this:
1651  *
1652  * x TemporalOffset
1653  * 0: 0
1654  * 1: 1
1655  * 2: 1
1656  * 3: -2
1657  * 4: 1
1658  * 5: 1
1659  * 6: -2
1660  *
1661  * We want to transform it into this:
1662  *
1663  * x DTS PTS
1664  * 0: -1 0
1665  * 1: 0 3
1666  * 2: 1 1
1667  * 3: 2 2
1668  * 4: 3 6
1669  * 5: 4 4
1670  * 6: 5 5
1671  *
1672  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1673  * then settings mxf->first_dts = -max(TemporalOffset[x]).
1674  * The latter makes DTS <= PTS.
1675  */
1676  for (i = x = 0; i < index_table->nb_segments; i++) {
1677  MXFIndexTableSegment *s = index_table->segments[i];
1678  int index_delta = 1;
1679  int n = s->nb_index_entries;
1680 
1681  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1682  index_delta = 2; /* Avid index */
1683  /* ignore the last entry - it's the size of the essence container */
1684  n--;
1685  }
1686 
1687  for (j = 0; j < n; j += index_delta, x++) {
1688  int offset = s->temporal_offset_entries[j] / index_delta;
1689  int index = x + offset;
1690 
1691  if (x >= index_table->nb_ptses) {
1692  av_log(mxf->fc, AV_LOG_ERROR,
1693  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1695  break;
1696  }
1697 
1698  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1699 
1700  if (index < 0 || index >= index_table->nb_ptses) {
1701  av_log(mxf->fc, AV_LOG_ERROR,
1702  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1703  x, offset, index);
1704  continue;
1705  }
1706 
1707  index_table->offsets[x] = offset;
1708  index_table->ptses[index] = x;
1709  max_temporal_offset = FFMAX(max_temporal_offset, offset);
1710  }
1711  }
1712 
1713  /* calculate the fake index table in display order */
1714  for (x = 0; x < index_table->nb_ptses; x++) {
1715  index_table->fake_index[x].timestamp = x;
1716  if (index_table->ptses[x] != AV_NOPTS_VALUE)
1717  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1718  }
1719  av_freep(&flags);
1720 
1721  index_table->first_dts = -max_temporal_offset;
1722 
1723  return 0;
1724 }
1725 
1726 /**
1727  * Sorts and collects index table segments into index tables.
1728  * Also computes PTSes if possible.
1729  */
1731 {
1732  int i, j, k, ret, nb_sorted_segments;
1733  MXFIndexTableSegment **sorted_segments = NULL;
1734 
1735  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1736  nb_sorted_segments <= 0) {
1737  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1738  return 0;
1739  }
1740 
1741  /* sanity check and count unique BodySIDs/IndexSIDs */
1742  for (i = 0; i < nb_sorted_segments; i++) {
1743  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1744  mxf->nb_index_tables++;
1745  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1746  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1747  ret = AVERROR_INVALIDDATA;
1748  goto finish_decoding_index;
1749  }
1750  }
1751 
1753  sizeof(*mxf->index_tables));
1754  if (!mxf->index_tables) {
1755  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1756  ret = AVERROR(ENOMEM);
1757  goto finish_decoding_index;
1758  }
1759 
1760  /* distribute sorted segments to index tables */
1761  for (i = j = 0; i < nb_sorted_segments; i++) {
1762  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1763  /* next IndexSID */
1764  j++;
1765  }
1766 
1767  mxf->index_tables[j].nb_segments++;
1768  }
1769 
1770  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1771  MXFIndexTable *t = &mxf->index_tables[j];
1772  MXFTrack *mxf_track = NULL;
1773 
1775  sizeof(*t->segments));
1776 
1777  if (!t->segments) {
1778  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1779  " pointer array\n");
1780  ret = AVERROR(ENOMEM);
1781  goto finish_decoding_index;
1782  }
1783 
1784  if (sorted_segments[i]->index_start_position)
1785  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1786  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1787 
1788  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1789  t->index_sid = sorted_segments[i]->index_sid;
1790  t->body_sid = sorted_segments[i]->body_sid;
1791 
1792  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1793  goto finish_decoding_index;
1794 
1795  for (k = 0; k < mxf->fc->nb_streams; k++) {
1796  MXFTrack *track = mxf->fc->streams[k]->priv_data;
1797  if (track && track->index_sid == t->index_sid) {
1798  mxf_track = track;
1799  break;
1800  }
1801  }
1802 
1803  /* fix zero IndexDurations */
1804  for (k = 0; k < t->nb_segments; k++) {
1805  if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
1806  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
1807  t->index_sid, k);
1808  if (mxf_track)
1809  t->segments[k]->index_edit_rate = mxf_track->edit_rate;
1810  }
1811 
1812  if (t->segments[k]->index_duration)
1813  continue;
1814 
1815  if (t->nb_segments > 1)
1816  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1817  t->index_sid, k);
1818 
1819  if (!mxf_track) {
1820  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1821  break;
1822  }
1823 
1824  /* assume the first stream's duration is reasonable
1825  * leave index_duration = 0 on further segments in case we have any (unlikely)
1826  */
1827  t->segments[k]->index_duration = mxf_track->original_duration;
1828  break;
1829  }
1830  }
1831 
1832  ret = 0;
1833 finish_decoding_index:
1834  av_free(sorted_segments);
1835  return ret;
1836 }
1837 
1838 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1839 {
1840  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1841  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1842  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1843  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1844 }
1845 
1846 static int mxf_uid_to_str(UID uid, char **str)
1847 {
1848  int i;
1849  char *p;
1850  p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1851  if (!p)
1852  return AVERROR(ENOMEM);
1853  for (i = 0; i < sizeof(UID); i++) {
1854  snprintf(p, 2 + 1, "%.2x", uid[i]);
1855  p += 2;
1856  if (i == 3 || i == 5 || i == 7 || i == 9) {
1857  snprintf(p, 1 + 1, "-");
1858  p++;
1859  }
1860  }
1861  return 0;
1862 }
1863 
1864 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1865 {
1866  int i;
1867  char *p;
1868  p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1869  if (!p)
1870  return AVERROR(ENOMEM);
1871  snprintf(p, 2 + 1, "0x");
1872  p += 2;
1873  for (i = 0; i < sizeof(UID); i++) {
1874  snprintf(p, 2 + 1, "%.2X", ul[i]);
1875  p += 2;
1876 
1877  }
1878  for (i = 0; i < sizeof(UID); i++) {
1879  snprintf(p, 2 + 1, "%.2X", uid[i]);
1880  p += 2;
1881  }
1882  return 0;
1883 }
1884 
1885 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1886 {
1887  char *str;
1888  int ret;
1889  if (!package)
1890  return 0;
1891  if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1892  return ret;
1893  av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1894  return 0;
1895 }
1896 
1897 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1898 {
1899  char buf[AV_TIMECODE_STR_SIZE];
1900  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1901 
1902  return 0;
1903 }
1904 
1906 {
1907  MXFStructuralComponent *component = NULL;
1908  MXFPulldownComponent *pulldown = NULL;
1909 
1910  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1911  if (!component)
1912  return NULL;
1913 
1914  switch (component->type) {
1915  case TimecodeComponent:
1916  return (MXFTimecodeComponent*)component;
1917  case PulldownComponent: /* timcode component may be located on a pulldown component */
1918  pulldown = (MXFPulldownComponent*)component;
1920  default:
1921  break;
1922  }
1923  return NULL;
1924 }
1925 
1926 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1927 {
1928  MXFPackage *package = NULL;
1929  int i;
1930 
1931  for (i = 0; i < mxf->packages_count; i++) {
1932  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1933  if (!package)
1934  continue;
1935 
1936  if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1937  return package;
1938  }
1939  return NULL;
1940 }
1941 
1942 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1943 {
1944  MXFDescriptor *sub_descriptor = NULL;
1945  int i;
1946 
1947  if (!descriptor)
1948  return NULL;
1949 
1950  if (descriptor->type == MultipleDescriptor) {
1951  for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1952  sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1953 
1954  if (!sub_descriptor) {
1955  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1956  continue;
1957  }
1958  if (sub_descriptor->linked_track_id == track_id) {
1959  return sub_descriptor;
1960  }
1961  }
1962  } else if (descriptor->type == Descriptor)
1963  return descriptor;
1964 
1965  return NULL;
1966 }
1967 
1969 {
1970  MXFStructuralComponent *component = NULL;
1971  MXFPackage *package = NULL;
1972  MXFDescriptor *descriptor = NULL;
1973  int i;
1974 
1975  if (!essence_group || !essence_group->structural_components_count)
1976  return NULL;
1977 
1978  /* essence groups contains multiple representations of the same media,
1979  this return the first components with a valid Descriptor typically index 0 */
1980  for (i =0; i < essence_group->structural_components_count; i++){
1981  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1982  if (!component)
1983  continue;
1984 
1985  if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1986  continue;
1987 
1988  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1989  if (descriptor)
1990  return component;
1991  }
1992  return NULL;
1993 }
1994 
1996 {
1997  MXFStructuralComponent *component = NULL;
1998 
1999  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2000  if (!component)
2001  return NULL;
2002  switch (component->type) {
2003  case SourceClip:
2004  return component;
2005  case EssenceGroup:
2006  return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2007  default:
2008  break;
2009  }
2010  return NULL;
2011 }
2012 
2014 {
2016  int size, i;
2017  char *key = NULL;
2018 
2019  for (i = 0; i < package->comment_count; i++) {
2020  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2021  if (!tag || !tag->name || !tag->value)
2022  continue;
2023 
2024  size = strlen(tag->name) + 8 + 1;
2025  key = av_mallocz(size);
2026  if (!key)
2027  return AVERROR(ENOMEM);
2028 
2029  snprintf(key, size, "comment_%s", tag->name);
2030  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2031  }
2032  return 0;
2033 }
2034 
2036 {
2037  MXFPackage *physical_package = NULL;
2038  MXFTrack *physical_track = NULL;
2039  MXFStructuralComponent *sourceclip = NULL;
2040  MXFTimecodeComponent *mxf_tc = NULL;
2041  int i, j, k;
2042  AVTimecode tc;
2043  int flags;
2044  int64_t start_position;
2045 
2046  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2047  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2048  if (!sourceclip)
2049  continue;
2050 
2051  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2052  break;
2053 
2054  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2055 
2056  /* the name of physical source package is name of the reel or tape */
2057  if (physical_package->name && physical_package->name[0])
2058  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2059 
2060  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2061  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2062  */
2063  for (j = 0; j < physical_package->tracks_count; j++) {
2064  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2065  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2066  continue;
2067  }
2068 
2069  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2070  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2071  continue;
2072  }
2073 
2074  if (physical_track->edit_rate.num <= 0 ||
2075  physical_track->edit_rate.den <= 0) {
2076  av_log(mxf->fc, AV_LOG_WARNING,
2077  "Invalid edit rate (%d/%d) found on structural"
2078  " component #%d, defaulting to 25/1\n",
2079  physical_track->edit_rate.num,
2080  physical_track->edit_rate.den, i);
2081  physical_track->edit_rate = (AVRational){25, 1};
2082  }
2083 
2084  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2085  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2086  continue;
2087 
2088  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2089  /* scale sourceclip start_position to match physical track edit rate */
2090  start_position = av_rescale_q(sourceclip->start_position,
2091  physical_track->edit_rate,
2092  source_track->edit_rate);
2093 
2094  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2095  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2096  return 0;
2097  }
2098  }
2099  }
2100  }
2101 
2102  return 0;
2103 }
2104 
2106 {
2107  MXFStructuralComponent *component = NULL;
2108  const MXFCodecUL *codec_ul = NULL;
2109  MXFPackage tmp_package;
2110  AVStream *st;
2111  int j;
2112 
2113  for (j = 0; j < track->sequence->structural_components_count; j++) {
2114  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2115  if (!component)
2116  continue;
2117  break;
2118  }
2119  if (!component)
2120  return 0;
2121 
2122  st = avformat_new_stream(mxf->fc, NULL);
2123  if (!st) {
2124  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2125  return AVERROR(ENOMEM);
2126  }
2127 
2130  st->id = track->track_id;
2131 
2132  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2133  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2134  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2135  if (track->name && track->name[0])
2136  av_dict_set(&st->metadata, "track_name", track->name, 0);
2137 
2139  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2140  return 0;
2141 }
2142 
2144 {
2145  MXFPackage *material_package = NULL;
2146  int i, j, k, ret;
2147 
2148  av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2149  /* TODO: handle multiple material packages (OP3x) */
2150  for (i = 0; i < mxf->packages_count; i++) {
2151  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2152  if (material_package) break;
2153  }
2154  if (!material_package) {
2155  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2156  return AVERROR_INVALIDDATA;
2157  }
2158 
2159  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2160  if (material_package->name && material_package->name[0])
2161  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2162  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2163 
2164  for (i = 0; i < material_package->tracks_count; i++) {
2165  MXFPackage *source_package = NULL;
2166  MXFTrack *material_track = NULL;
2167  MXFTrack *source_track = NULL;
2168  MXFTrack *temp_track = NULL;
2169  MXFDescriptor *descriptor = NULL;
2170  MXFStructuralComponent *component = NULL;
2171  MXFTimecodeComponent *mxf_tc = NULL;
2172  UID *essence_container_ul = NULL;
2173  const MXFCodecUL *codec_ul = NULL;
2174  const MXFCodecUL *container_ul = NULL;
2175  const MXFCodecUL *pix_fmt_ul = NULL;
2176  AVStream *st;
2177  AVTimecode tc;
2178  int flags;
2179 
2180  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2181  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2182  continue;
2183  }
2184 
2185  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2186  mxf_tc = (MXFTimecodeComponent*)component;
2187  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2188  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2189  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2190  }
2191  }
2192 
2193  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2194  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2195  continue;
2196  }
2197 
2198  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2199  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2200  if (!component)
2201  continue;
2202 
2203  mxf_tc = (MXFTimecodeComponent*)component;
2204  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2205  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2206  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2207  break;
2208  }
2209  }
2210 
2211  /* TODO: handle multiple source clips, only finds first valid source clip */
2212  if(material_track->sequence->structural_components_count > 1)
2213  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2214  material_track->track_id, material_track->sequence->structural_components_count);
2215 
2216  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2217  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2218  if (!component)
2219  continue;
2220 
2221  source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2222  if (!source_package) {
2223  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2224  continue;
2225  }
2226  for (k = 0; k < source_package->tracks_count; k++) {
2227  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2228  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2229  ret = AVERROR_INVALIDDATA;
2230  goto fail_and_free;
2231  }
2232  if (temp_track->track_id == component->source_track_id) {
2233  source_track = temp_track;
2234  break;
2235  }
2236  }
2237  if (!source_track) {
2238  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2239  break;
2240  }
2241 
2242  for (k = 0; k < mxf->essence_container_data_count; k++) {
2243  MXFEssenceContainerData *essence_data;
2244 
2245  if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2246  av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2247  continue;
2248  }
2249  if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2250  source_track->body_sid = essence_data->body_sid;
2251  source_track->index_sid = essence_data->index_sid;
2252  break;
2253  }
2254  }
2255 
2256  if(source_track && component)
2257  break;
2258  }
2259  if (!source_track || !component || !source_package) {
2260  if((ret = mxf_add_metadata_stream(mxf, material_track)))
2261  goto fail_and_free;
2262  continue;
2263  }
2264 
2265  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2266  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2267  ret = AVERROR_INVALIDDATA;
2268  goto fail_and_free;
2269  }
2270 
2271  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2272  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2273  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2274  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2275  continue;
2276  }
2277 
2278  st = avformat_new_stream(mxf->fc, NULL);
2279  if (!st) {
2280  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2281  ret = AVERROR(ENOMEM);
2282  goto fail_and_free;
2283  }
2284  st->id = material_track->track_id;
2285  st->priv_data = source_track;
2286 
2287  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2288  descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2289 
2290  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2291  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2292  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2293  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2294  else
2295  source_track->original_duration = st->duration = component->duration;
2296 
2297  if (st->duration == -1)
2298  st->duration = AV_NOPTS_VALUE;
2299  st->start_time = component->start_position;
2300  if (material_track->edit_rate.num <= 0 ||
2301  material_track->edit_rate.den <= 0) {
2302  av_log(mxf->fc, AV_LOG_WARNING,
2303  "Invalid edit rate (%d/%d) found on stream #%d, "
2304  "defaulting to 25/1\n",
2305  material_track->edit_rate.num,
2306  material_track->edit_rate.den, st->index);
2307  material_track->edit_rate = (AVRational){25, 1};
2308  }
2309  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2310 
2311  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2312  * the former is accessible via st->priv_data */
2313  source_track->edit_rate = material_track->edit_rate;
2314 
2315  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2317  st->codecpar->codec_type = codec_ul->id;
2318 
2319  if (!descriptor) {
2320  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2321  continue;
2322  }
2323  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2324  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2325  essence_container_ul = &descriptor->essence_container_ul;
2326  source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2327  if (source_track->wrapping == UnknownWrapped)
2328  av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2329  /* HACK: replacing the original key with mxf_encrypted_essence_container
2330  * is not allowed according to s429-6, try to find correct information anyway */
2331  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2332  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2333  for (k = 0; k < mxf->metadata_sets_count; k++) {
2334  MXFMetadataSet *metadata = mxf->metadata_sets[k];
2335  if (metadata->type == CryptoContext) {
2336  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2337  break;
2338  }
2339  }
2340  }
2341 
2342  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2343  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2344  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2345  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2346  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2347  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2348  }
2349 
2350  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2352  for (k = 0; k < 16; k++) {
2353  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2354  descriptor->essence_codec_ul[k]);
2355  if (!(k+1 & 19) || k == 5)
2356  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2357  }
2358  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2359 
2360  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2361  if (source_package->name && source_package->name[0])
2362  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2363  if (material_track->name && material_track->name[0])
2364  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2365 
2366  mxf_parse_physical_source_package(mxf, source_track, st);
2367 
2368  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2369  source_track->intra_only = mxf_is_intra_only(descriptor);
2370  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2371  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2372  st->codecpar->codec_id = container_ul->id;
2373  st->codecpar->width = descriptor->width;
2374  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2375  switch (descriptor->frame_layout) {
2376  case FullFrame:
2378  break;
2379  case OneField:
2380  /* Every other line is stored and needs to be duplicated. */
2381  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2382  break; /* The correct thing to do here is fall through, but by breaking we might be
2383  able to decode some streams at half the vertical resolution, rather than not al all.
2384  It's also for compatibility with the old behavior. */
2385  case MixedFields:
2386  break;
2387  case SegmentedFrame:
2389  case SeparateFields:
2390  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2391  descriptor->video_line_map[0], descriptor->video_line_map[1],
2392  descriptor->field_dominance);
2393  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2394  /* Detect coded field order from VideoLineMap:
2395  * (even, even) => bottom field coded first
2396  * (even, odd) => top field coded first
2397  * (odd, even) => top field coded first
2398  * (odd, odd) => bottom field coded first
2399  */
2400  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2401  switch (descriptor->field_dominance) {
2405  break;
2408  break;
2409  default:
2411  "Field dominance %d support",
2412  descriptor->field_dominance);
2413  }
2414  } else {
2415  switch (descriptor->field_dominance) {
2419  break;
2422  break;
2423  default:
2425  "Field dominance %d support",
2426  descriptor->field_dominance);
2427  }
2428  }
2429  }
2430  /* Turn field height into frame height. */
2431  st->codecpar->height *= 2;
2432  break;
2433  default:
2434  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2435  }
2436 
2437  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2438  switch (descriptor->essence_codec_ul[14]) {
2439  case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2440  case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2441  case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2442  case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2443  case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2444  case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2445  }
2446  }
2447 
2448  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2449  st->codecpar->format = descriptor->pix_fmt;
2450  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2452  &descriptor->essence_codec_ul);
2453  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2454  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2456  &descriptor->essence_codec_ul)->id;
2457  if (!st->codecpar->codec_tag) {
2458  /* support files created before RP224v10 by defaulting to UYVY422
2459  if subsampling is 4:2:2 and component depth is 8-bit */
2460  if (descriptor->horiz_subsampling == 2 &&
2461  descriptor->vert_subsampling == 1 &&
2462  descriptor->component_depth == 8) {
2464  }
2465  }
2466  }
2467  }
2468  }
2470  if (material_track->sequence->origin) {
2471  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2472  }
2473  if (source_track->sequence->origin) {
2474  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2475  }
2476  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2477  st->display_aspect_ratio = descriptor->aspect_ratio;
2478  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2479  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2480  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2481  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))
2482  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2483  st->codecpar->channels = descriptor->channels;
2484 
2485  if (descriptor->sample_rate.den > 0) {
2486  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2487  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2488  } else {
2489  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2490  "found for stream #%d, time base forced to 1/48000\n",
2491  descriptor->sample_rate.num, descriptor->sample_rate.den,
2492  st->index);
2493  avpriv_set_pts_info(st, 64, 1, 48000);
2494  }
2495 
2496  /* if duration is set, rescale it from EditRate to SampleRate */
2497  if (st->duration != AV_NOPTS_VALUE)
2498  st->duration = av_rescale_q(st->duration,
2499  av_inv_q(material_track->edit_rate),
2500  st->time_base);
2501 
2502  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2503  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2504  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2506  else if (descriptor->bits_per_sample == 32)
2508  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2509  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2511  else if (descriptor->bits_per_sample == 32)
2513  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2515  }
2517  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2518  enum AVMediaType type;
2519  container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2520  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2521  st->codecpar->codec_id = container_ul->id;
2522  type = avcodec_get_type(st->codecpar->codec_id);
2523  if (type == AVMEDIA_TYPE_SUBTITLE)
2524  st->codecpar->codec_type = type;
2525  if (container_ul->desc)
2526  av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2527  if (mxf->eia608_extract &&
2528  !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2531  }
2532  }
2533  if (descriptor->extradata) {
2534  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2535  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2536  }
2537  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2538  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2539  &descriptor->essence_codec_ul)->id;
2540  if (coded_width)
2541  st->codecpar->width = coded_width;
2542  ret = ff_generate_avci_extradata(st);
2543  if (ret < 0)
2544  return ret;
2545  }
2546  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2547  /* TODO: decode timestamps */
2549  }
2550  }
2551 
2552  ret = 0;
2553 fail_and_free:
2554  return ret;
2555 }
2556 
2557 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2558 {
2559  struct tm time = { 0 };
2560  int msecs;
2561  time.tm_year = (timestamp >> 48) - 1900;
2562  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2563  time.tm_mday = (timestamp >> 32 & 0xFF);
2564  time.tm_hour = (timestamp >> 24 & 0xFF);
2565  time.tm_min = (timestamp >> 16 & 0xFF);
2566  time.tm_sec = (timestamp >> 8 & 0xFF);
2567  msecs = (timestamp & 0xFF) * 4;
2568 
2569  /* Clip values for legacy reasons. Maybe we should return error instead? */
2570  time.tm_mon = av_clip(time.tm_mon, 0, 11);
2571  time.tm_mday = av_clip(time.tm_mday, 1, 31);
2572  time.tm_hour = av_clip(time.tm_hour, 0, 23);
2573  time.tm_min = av_clip(time.tm_min, 0, 59);
2574  time.tm_sec = av_clip(time.tm_sec, 0, 59);
2575  msecs = av_clip(msecs, 0, 999);
2576 
2577  return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
2578 }
2579 
2580 #define SET_STR_METADATA(pb, name, str) do { \
2581  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2582  return ret; \
2583  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2584 } while (0)
2585 
2586 #define SET_UID_METADATA(pb, name, var, str) do { \
2587  avio_read(pb, var, 16); \
2588  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2589  return ret; \
2590  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2591 } while (0)
2592 
2593 #define SET_TS_METADATA(pb, name, var, str) do { \
2594  var = avio_rb64(pb); \
2595  if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2596  return ret; \
2597 } while (0)
2598 
2599 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2600 {
2601  MXFContext *mxf = arg;
2602  AVFormatContext *s = mxf->fc;
2603  int ret;
2604  UID uid = { 0 };
2605  char *str = NULL;
2606  uint64_t ts;
2607  switch (tag) {
2608  case 0x3C01:
2609  SET_STR_METADATA(pb, "company_name", str);
2610  break;
2611  case 0x3C02:
2612  SET_STR_METADATA(pb, "product_name", str);
2613  break;
2614  case 0x3C04:
2615  SET_STR_METADATA(pb, "product_version", str);
2616  break;
2617  case 0x3C05:
2618  SET_UID_METADATA(pb, "product_uid", uid, str);
2619  break;
2620  case 0x3C06:
2621  SET_TS_METADATA(pb, "modification_date", ts, str);
2622  break;
2623  case 0x3C08:
2624  SET_STR_METADATA(pb, "application_platform", str);
2625  break;
2626  case 0x3C09:
2627  SET_UID_METADATA(pb, "generation_uid", uid, str);
2628  break;
2629  case 0x3C0A:
2630  SET_UID_METADATA(pb, "uid", uid, str);
2631  break;
2632  }
2633  return 0;
2634 }
2635 
2636 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2637 {
2638  MXFContext *mxf = arg;
2639  AVFormatContext *s = mxf->fc;
2640  int ret;
2641  char *str = NULL;
2642 
2643  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2644  SET_STR_METADATA(pb, "project_name", str);
2645  }
2646  return 0;
2647 }
2648 
2650  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2651  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2652  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2653  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2654  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2655  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2656  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2657  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2658  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2659  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2660  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2661  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2662  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2663  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2664  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2665  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2666  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2667  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2668  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2669  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2670  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2671  { { 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 */
2672  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2673  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2674  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2675  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2676  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2677  { { 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 */
2678  { { 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 */
2679  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2680  { { 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 */
2681  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2682  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2683  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2684  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2685  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2686  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2687  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2688  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2689 };
2690 
2692 {
2693  switch (type){
2694  case MultipleDescriptor:
2695  case Descriptor:
2696  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2697  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2698  break;
2699  default:
2700  break;
2701  }
2702  return 0;
2703 }
2704 
2705 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2706 {
2707  AVIOContext *pb = mxf->fc->pb;
2708  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2709  uint64_t klv_end = avio_tell(pb) + klv->length;
2710 
2711  if (!ctx)
2712  return AVERROR(ENOMEM);
2713  mxf_metadataset_init(ctx, type);
2714  while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2715  int ret;
2716  int tag = avio_rb16(pb);
2717  int size = avio_rb16(pb); /* KLV specified by 0x53 */
2718  uint64_t next = avio_tell(pb) + size;
2719  UID uid = {0};
2720 
2721  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2722  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2723  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2724  continue;
2725  }
2726  if (tag > 0x7FFF) { /* dynamic tag */
2727  int i;
2728  for (i = 0; i < mxf->local_tags_count; i++) {
2729  int local_tag = AV_RB16(mxf->local_tags+i*18);
2730  if (local_tag == tag) {
2731  memcpy(uid, mxf->local_tags+i*18+2, 16);
2732  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2733  PRINT_KEY(mxf->fc, "uid", uid);
2734  }
2735  }
2736  }
2737  if (ctx_size && tag == 0x3C0A) {
2738  avio_read(pb, ctx->uid, 16);
2739  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2740  if (ctx_size)
2741  mxf_free_metadataset(&ctx, 1);
2742  return ret;
2743  }
2744 
2745  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2746  * it extending past the end of the KLV though (zzuf5.mxf). */
2747  if (avio_tell(pb) > klv_end) {
2748  if (ctx_size) {
2749  ctx->type = type;
2750  mxf_free_metadataset(&ctx, 1);
2751  }
2752 
2753  av_log(mxf->fc, AV_LOG_ERROR,
2754  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2755  tag, klv->offset);
2756  return AVERROR_INVALIDDATA;
2757  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2758  avio_seek(pb, next, SEEK_SET);
2759  }
2760  if (ctx_size) ctx->type = type;
2761  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2762 }
2763 
2764 /**
2765  * Matches any partition pack key, in other words:
2766  * - HeaderPartition
2767  * - BodyPartition
2768  * - FooterPartition
2769  * @return non-zero if the key is a partition pack key, zero otherwise
2770  */
2772 {
2773  //NOTE: this is a little lax since it doesn't constraint key[14]
2774  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2775  key[13] >= 2 && key[13] <= 4;
2776 }
2777 
2778 /**
2779  * Parses a metadata KLV
2780  * @return <0 on error, 0 otherwise
2781  */
2783  int ctx_size, enum MXFMetadataSetType type)
2784 {
2785  AVFormatContext *s = mxf->fc;
2786  int res;
2787  if (klv.key[5] == 0x53) {
2788  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2789  } else {
2790  uint64_t next = avio_tell(s->pb) + klv.length;
2791  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2792 
2793  /* only seek forward, else this can loop for a long time */
2794  if (avio_tell(s->pb) > next) {
2795  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2796  klv.offset);
2797  return AVERROR_INVALIDDATA;
2798  }
2799 
2800  avio_seek(s->pb, next, SEEK_SET);
2801  }
2802  if (res < 0) {
2803  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2804  return res;
2805  }
2806  return 0;
2807 }
2808 
2809 /**
2810  * Seeks to the previous partition and parses it, if possible
2811  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2812  */
2814 {
2815  AVIOContext *pb = mxf->fc->pb;
2816  KLVPacket klv;
2817  int64_t current_partition_ofs;
2818  int ret;
2819 
2820  if (!mxf->current_partition ||
2822  return 0; /* we've parsed all partitions */
2823 
2824  /* seek to previous partition */
2825  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2826  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2827  mxf->current_partition = NULL;
2828 
2829  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2830 
2831  /* Make sure this is actually a PartitionPack, and if so parse it.
2832  * See deadlock2.mxf
2833  */
2834  if ((ret = klv_read_packet(&klv, pb)) < 0) {
2835  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2836  return ret;
2837  }
2838 
2839  if (!mxf_is_partition_pack_key(klv.key)) {
2840  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2841  return AVERROR_INVALIDDATA;
2842  }
2843 
2844  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2845  * can point to just before the current partition, causing klv_read_packet()
2846  * to sync back up to it. See deadlock3.mxf
2847  */
2848  if (klv.offset >= current_partition_ofs) {
2849  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2850  PRIx64 " indirectly points to itself\n", current_partition_ofs);
2851  return AVERROR_INVALIDDATA;
2852  }
2853 
2854  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2855  return ret;
2856 
2857  return 1;
2858 }
2859 
2860 /**
2861  * Called when essence is encountered
2862  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2863  */
2865 {
2866  AVIOContext *pb = mxf->fc->pb;
2867  int64_t ret;
2868 
2869  if (mxf->parsing_backward) {
2870  return mxf_seek_to_previous_partition(mxf);
2871  } else {
2872  if (!mxf->footer_partition) {
2873  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2874  return 0;
2875  }
2876 
2877  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2878 
2879  /* remember where we were so we don't end up seeking further back than this */
2880  mxf->last_forward_tell = avio_tell(pb);
2881 
2882  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2883  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2884  return -1;
2885  }
2886 
2887  /* seek to FooterPartition and parse backward */
2888  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2889  av_log(mxf->fc, AV_LOG_ERROR,
2890  "failed to seek to FooterPartition @ 0x%" PRIx64
2891  " (%"PRId64") - partial file?\n",
2892  mxf->run_in + mxf->footer_partition, ret);
2893  return ret;
2894  }
2895 
2896  mxf->current_partition = NULL;
2897  mxf->parsing_backward = 1;
2898  }
2899 
2900  return 1;
2901 }
2902 
2903 /**
2904  * Called when the next partition or EOF is encountered
2905  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2906  */
2908 {
2909  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2910 }
2911 
2913 {
2914  for (int i = 0; i < s->nb_streams; i++) {
2915  MXFTrack *track = s->streams[i]->priv_data;
2916  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2917  return track->wrapping;
2918  }
2919  return UnknownWrapped;
2920 }
2921 
2922 /**
2923  * Figures out the proper offset and length of the essence container in each partition
2924  */
2926 {
2927  MXFContext *mxf = s->priv_data;
2928  int x;
2929 
2930  for (x = 0; x < mxf->partitions_count; x++) {
2931  MXFPartition *p = &mxf->partitions[x];
2932  MXFWrappingScheme wrapping;
2933 
2934  if (!p->body_sid)
2935  continue; /* BodySID == 0 -> no essence */
2936 
2937  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2938  * otherwise we point essence_offset at the key of the first essence KLV.
2939  */
2940 
2941  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2942 
2943  if (wrapping == ClipWrapped) {
2946  } else {
2948 
2949  /* essence container spans to the next partition */
2950  if (x < mxf->partitions_count - 1)
2952 
2953  if (p->essence_length < 0) {
2954  /* next ThisPartition < essence_offset */
2955  p->essence_length = 0;
2956  av_log(mxf->fc, AV_LOG_ERROR,
2957  "partition %i: bad ThisPartition = %"PRIX64"\n",
2958  x+1, mxf->partitions[x+1].this_partition);
2959  }
2960  }
2961  }
2962 }
2963 
2964 static int is_pcm(enum AVCodecID codec_id)
2965 {
2966  /* we only care about "normal" PCM codecs until we get samples */
2967  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2968 }
2969 
2971 {
2972  int i;
2973  for (i = 0; i < mxf->nb_index_tables; i++)
2974  if (mxf->index_tables[i].index_sid == index_sid)
2975  return &mxf->index_tables[i];
2976  return NULL;
2977 }
2978 
2979 /**
2980  * Deal with the case where for some audio atoms EditUnitByteCount is
2981  * very small (2, 4..). In those cases we should read more than one
2982  * sample per call to mxf_read_packet().
2983  */
2985 {
2986  MXFTrack *track = st->priv_data;
2987  MXFIndexTable *t;
2988 
2989  if (!track)
2990  return;
2991  track->edit_units_per_packet = 1;
2992  if (track->wrapping != ClipWrapped)
2993  return;
2994 
2995  t = mxf_find_index_table(mxf, track->index_sid);
2996 
2997  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2998  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
2999  !is_pcm(st->codecpar->codec_id) ||
3000  !t ||
3001  t->nb_segments != 1 ||
3002  t->segments[0]->edit_unit_byte_count >= 32)
3003  return;
3004 
3005  /* arbitrarily default to 48 kHz PAL audio frame size */
3006  /* TODO: We could compute this from the ratio between the audio
3007  * and video edit rates for 48 kHz NTSC we could use the
3008  * 1802-1802-1802-1802-1801 pattern. */
3009  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3010 }
3011 
3012 /**
3013  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3014  */
3016 {
3017  MXFTrack *track = st->priv_data;
3019  MXFPartition *p = NULL;
3020  int essence_partition_count = 0;
3021  int edit_unit_byte_count = 0;
3022  int i, ret;
3023 
3024  if (!track || track->wrapping != ClipWrapped)
3025  return 0;
3026 
3027  /* check if track already has an IndexTableSegment */
3028  for (i = 0; i < mxf->metadata_sets_count; i++) {
3029  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3031  if (s->body_sid == track->body_sid)
3032  return 0;
3033  }
3034  }
3035 
3036  /* find the essence partition */
3037  for (i = 0; i < mxf->partitions_count; i++) {
3038  /* BodySID == 0 -> no essence */
3039  if (mxf->partitions[i].body_sid != track->body_sid)
3040  continue;
3041 
3042  p = &mxf->partitions[i];
3043  essence_partition_count++;
3044  }
3045 
3046  /* only handle files with a single essence partition */
3047  if (essence_partition_count != 1)
3048  return 0;
3049 
3051  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3052  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3053  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3054  }
3055 
3056  if (edit_unit_byte_count <= 0)
3057  return 0;
3058 
3059  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);
3060 
3061  if (!(segment = av_mallocz(sizeof(*segment))))
3062  return AVERROR(ENOMEM);
3063 
3064  if ((ret = mxf_add_metadata_set(mxf, segment))) {
3065  mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
3066  return ret;
3067  }
3068 
3069  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3070  * using the same SID for index is forbidden in MXF. */
3071  if (!track->index_sid)
3072  track->index_sid = track->body_sid;
3073 
3074  segment->type = IndexTableSegment;
3075  /* stream will be treated as small EditUnitByteCount */
3076  segment->edit_unit_byte_count = edit_unit_byte_count;
3077  segment->index_start_position = 0;
3078  segment->index_duration = st->duration;
3079  segment->index_edit_rate = av_inv_q(st->time_base);
3080  segment->index_sid = track->index_sid;
3081  segment->body_sid = p->body_sid;
3082  return 0;
3083 }
3084 
3086 {
3087  MXFContext *mxf = s->priv_data;
3088  uint32_t length;
3089  int64_t file_size, max_rip_length, min_rip_length;
3090  KLVPacket klv;
3091 
3092  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3093  return;
3094 
3095  file_size = avio_size(s->pb);
3096 
3097  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3098  * The limit below assumes a file with nothing but partition packs and a RIP.
3099  * Before changing this, consider that a muxer may place each sample in its own partition.
3100  *
3101  * 105 is the size of the smallest possible PartitionPack
3102  * 12 is the size of each RIP entry
3103  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3104  */
3105  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3106  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3107 
3108  /* We're only interested in RIPs with at least two entries.. */
3109  min_rip_length = 16+1+24+4;
3110 
3111  /* See S377m section 11 */
3112  avio_seek(s->pb, file_size - 4, SEEK_SET);
3113  length = avio_rb32(s->pb);
3114 
3115  if (length < min_rip_length || length > max_rip_length)
3116  goto end;
3117  avio_seek(s->pb, file_size - length, SEEK_SET);
3118  if (klv_read_packet(&klv, s->pb) < 0 ||
3120  klv.length != length - 20)
3121  goto end;
3122 
3123  avio_skip(s->pb, klv.length - 12);
3124  mxf->footer_partition = avio_rb64(s->pb);
3125 
3126  /* sanity check */
3127  if (mxf->run_in + mxf->footer_partition >= file_size) {
3128  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3129  mxf->footer_partition = 0;
3130  }
3131 
3132 end:
3133  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3134 }
3135 
3137 {
3138  MXFContext *mxf = s->priv_data;
3139  KLVPacket klv;
3140  int64_t essence_offset = 0;
3141  int ret;
3142 
3143  mxf->last_forward_tell = INT64_MAX;
3144 
3146  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3147  return AVERROR_INVALIDDATA;
3148  }
3149  avio_seek(s->pb, -14, SEEK_CUR);
3150  mxf->fc = s;
3151  mxf->run_in = avio_tell(s->pb);
3152 
3154 
3155  while (!avio_feof(s->pb)) {
3156  const MXFMetadataReadTableEntry *metadata;
3157 
3158  if (klv_read_packet(&klv, s->pb) < 0) {
3159  /* EOF - seek to previous partition or stop */
3160  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3161  break;
3162  else
3163  continue;
3164  }
3165 
3166  PRINT_KEY(s, "read header", klv.key);
3167  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3174 
3175  if (!mxf->current_partition) {
3176  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3177  return AVERROR_INVALIDDATA;
3178  }
3179 
3182 
3183  if (!essence_offset)
3184  essence_offset = klv.offset;
3185 
3186  /* seek to footer, previous partition or stop */
3187  if (mxf_parse_handle_essence(mxf) <= 0)
3188  break;
3189  continue;
3190  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3191  /* next partition pack - keep going, seek to previous partition or stop */
3192  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3193  break;
3194  else if (mxf->parsing_backward)
3195  continue;
3196  /* we're still parsing forward. proceed to parsing this partition pack */
3197  }
3198 
3199  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3200  if (IS_KLV_KEY(klv.key, metadata->key)) {
3201  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3202  goto fail;
3203  break;
3204  }
3205  }
3206  if (!metadata->read) {
3207  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3208  UID_ARG(klv.key));
3209  avio_skip(s->pb, klv.length);
3210  }
3211  }
3212  /* FIXME avoid seek */
3213  if (!essence_offset) {
3214  av_log(s, AV_LOG_ERROR, "no essence\n");
3215  ret = AVERROR_INVALIDDATA;
3216  goto fail;
3217  }
3218  avio_seek(s->pb, essence_offset, SEEK_SET);
3219 
3220  /* we need to do this before computing the index tables
3221  * to be able to fill in zero IndexDurations with st->duration */
3222  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3223  goto fail;
3224 
3225  for (int i = 0; i < s->nb_streams; i++)
3227 
3228  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3229  goto fail;
3230 
3231  if (mxf->nb_index_tables > 1) {
3232  /* TODO: look up which IndexSID to use via EssenceContainerData */
3233  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3234  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3235  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3236  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3237  ret = AVERROR_INVALIDDATA;
3238  goto fail;
3239  }
3240 
3242 
3243  for (int i = 0; i < s->nb_streams; i++)
3245 
3246  return 0;
3247 fail:
3248  mxf_read_close(s);
3249 
3250  return ret;
3251 }
3252 
3253 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3254 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3255 {
3256  int64_t a, b, m, offset;
3257  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3258 
3259  if (!t || track->original_duration <= 0)
3260  return -1;
3261 
3262  a = -1;
3263  b = track->original_duration;
3264 
3265  while (b - a > 1) {
3266  m = (a + b) >> 1;
3267  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3268  return -1;
3269  if (offset < current_offset)
3270  a = m;
3271  else
3272  b = m;
3273  }
3274 
3275  *edit_unit_out = b;
3276 
3277  return 0;
3278 }
3279 
3281  int64_t edit_unit)
3282 {
3283  int i, total = 0, size = 0;
3284  MXFTrack *track = st->priv_data;
3285  AVRational time_base = av_inv_q(track->edit_rate);
3287  const MXFSamplesPerFrame *spf = NULL;
3288  int64_t sample_count;
3289 
3290  // For non-audio sample_count equals current edit unit
3292  return edit_unit;
3293 
3294  if ((sample_rate.num / sample_rate.den) == 48000)
3295  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3296  if (!spf) {
3297  int remainder = (sample_rate.num * time_base.num) %
3298  (time_base.den * sample_rate.den);
3299  if (remainder)
3300  av_log(mxf->fc, AV_LOG_WARNING,
3301  "seeking detected on stream #%d with time base (%d/%d) and "
3302  "sample rate (%d/%d), audio pts won't be accurate.\n",
3303  st->index, time_base.num, time_base.den,
3304  sample_rate.num, sample_rate.den);
3305  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3306  }
3307 
3308  while (spf->samples_per_frame[size]) {
3309  total += spf->samples_per_frame[size];
3310  size++;
3311  }
3312 
3313  av_assert2(size);
3314 
3315  sample_count = (edit_unit / size) * (uint64_t)total;
3316  for (i = 0; i < edit_unit % size; i++) {
3317  sample_count += spf->samples_per_frame[i];
3318  }
3319 
3320  return sample_count;
3321 }
3322 
3323 /**
3324  * Make sure track->sample_count is correct based on what offset we're currently at.
3325  * Also determine the next edit unit (or packet) offset.
3326  * @return next_ofs if OK, <0 on error
3327  */
3328 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3329 {
3330  int64_t next_ofs = -1;
3331  MXFTrack *track = st->priv_data;
3332  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3333  int64_t new_edit_unit;
3334  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3335 
3336  if (!t || track->wrapping == UnknownWrapped)
3337  return -1;
3338 
3339  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3340  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3341  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3342  return -1;
3343  }
3344 
3345  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3346  if (next_ofs > current_offset)
3347  return next_ofs;
3348 
3349  if (!resync) {
3350  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3351  return -1;
3352  }
3353 
3354  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3355  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3356  return -1;
3357  }
3358 
3359  new_edit_unit--;
3360  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3361  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);
3362 
3363  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3364 }
3365 
3367  AVPacket *pkt)
3368 {
3369  AVStream *st = mxf->fc->streams[pkt->stream_index];
3370  MXFTrack *track = st->priv_data;
3371  int64_t bits_per_sample = par->bits_per_coded_sample;
3372 
3373  if (!bits_per_sample)
3374  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3375 
3376  pkt->pts = track->sample_count;
3377 
3378  if ( par->channels <= 0
3379  || bits_per_sample <= 0
3380  || par->channels * (int64_t)bits_per_sample < 8)
3381  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);
3382  else
3383  track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3384 
3385  return 0;
3386 }
3387 
3388 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3389 {
3390  AVCodecParameters *par = st->codecpar;
3391  MXFTrack *track = st->priv_data;
3392 
3393  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3394  /* see if we have an index table to derive timestamps from */
3395  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3396 
3397  if (t && track->sample_count < t->nb_ptses) {
3398  pkt->dts = track->sample_count + t->first_dts;
3399  pkt->pts = t->ptses[track->sample_count];
3400  } else if (track->intra_only) {
3401  /* intra-only -> PTS = EditUnit.
3402  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3403  pkt->pts = track->sample_count;
3404  }
3405  track->sample_count++;
3406  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3407  int ret = mxf_set_audio_pts(mxf, par, pkt);
3408  if (ret < 0)
3409  return ret;
3410  } else if (track) {
3411  pkt->dts = pkt->pts = track->sample_count;
3412  pkt->duration = 1;
3413  track->sample_count++;
3414  }
3415  return 0;
3416 }
3417 
3419 {
3420  KLVPacket klv;
3421  MXFContext *mxf = s->priv_data;
3422  int ret;
3423 
3424  while (1) {
3425  int64_t max_data_size;
3426  int64_t pos = avio_tell(s->pb);
3427 
3428  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3429  mxf->current_klv_data = (KLVPacket){{0}};
3430  ret = klv_read_packet(&klv, s->pb);
3431  if (ret < 0)
3432  break;
3433  max_data_size = klv.length;
3434  pos = klv.next_klv - klv.length;
3435  PRINT_KEY(s, "read packet", klv.key);
3436  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3438  ret = mxf_decrypt_triplet(s, pkt, &klv);
3439  if (ret < 0) {
3440  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3441  return ret;
3442  }
3443  return 0;
3444  }
3445  } else {
3446  klv = mxf->current_klv_data;
3447  max_data_size = klv.next_klv - pos;
3448  }
3452  int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3453  int index = mxf_get_stream_index(s, &klv, body_sid);
3454  int64_t next_ofs;
3455  AVStream *st;
3456  MXFTrack *track;
3457 
3458  if (index < 0) {
3459  av_log(s, AV_LOG_ERROR,
3460  "error getting stream index %"PRIu32"\n",
3461  AV_RB32(klv.key + 12));
3462  goto skip;
3463  }
3464 
3465  st = s->streams[index];
3466  track = st->priv_data;
3467 
3468  if (s->streams[index]->discard == AVDISCARD_ALL)
3469  goto skip;
3470 
3471  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3472 
3473  if (track->wrapping != FrameWrapped) {
3474  int64_t size;
3475 
3476  if (next_ofs <= 0) {
3477  // If we have no way to packetize the data, then return it in chunks...
3478  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3480  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3481  }
3482  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3483  } else {
3484  if ((size = next_ofs - pos) <= 0) {
3485  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3486  ret = AVERROR_INVALIDDATA;
3487  goto skip;
3488  }
3489  // We must not overread, because the next edit unit might be in another KLV
3490  if (size > max_data_size)
3491  size = max_data_size;
3492  }
3493 
3494  mxf->current_klv_data = klv;
3495  klv.offset = pos;
3496  klv.length = size;
3497  klv.next_klv = klv.offset + klv.length;
3498  }
3499 
3500  /* check for 8 channels AES3 element */
3501  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3502  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3503  pkt, klv.length);
3504  if (ret < 0) {
3505  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3506  mxf->current_klv_data = (KLVPacket){{0}};
3507  return ret;
3508  }
3509  } else if (mxf->eia608_extract &&
3510  s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3511  ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3512  if (ret < 0) {
3513  mxf->current_klv_data = (KLVPacket){{0}};
3514  return ret;
3515  }
3516  } else {
3517  ret = av_get_packet(s->pb, pkt, klv.length);
3518  if (ret < 0) {
3519  mxf->current_klv_data = (KLVPacket){{0}};
3520  return ret;
3521  }
3522  }
3523  pkt->stream_index = index;
3524  pkt->pos = klv.offset;
3525 
3526  ret = mxf_set_pts(mxf, st, pkt);
3527  if (ret < 0) {
3528  mxf->current_klv_data = (KLVPacket){{0}};
3529  return ret;
3530  }
3531 
3532  /* seek for truncated packets */
3533  avio_seek(s->pb, klv.next_klv, SEEK_SET);
3534 
3535  return 0;
3536  } else {
3537  skip:
3538  avio_skip(s->pb, max_data_size);
3539  mxf->current_klv_data = (KLVPacket){{0}};
3540  }
3541  }
3542  return avio_feof(s->pb) ? AVERROR_EOF : ret;
3543 }
3544 
3546 {
3547  MXFContext *mxf = s->priv_data;
3548  int i;
3549 
3550  av_freep(&mxf->packages_refs);
3552 
3553  for (i = 0; i < s->nb_streams; i++)
3554  s->streams[i]->priv_data = NULL;
3555 
3556  for (i = 0; i < mxf->metadata_sets_count; i++) {
3557  mxf_free_metadataset(mxf->metadata_sets + i, 1);
3558  }
3559  av_freep(&mxf->partitions);
3560  av_freep(&mxf->metadata_sets);
3561  av_freep(&mxf->aesc);
3562  av_freep(&mxf->local_tags);
3563 
3564  if (mxf->index_tables) {
3565  for (i = 0; i < mxf->nb_index_tables; i++) {
3566  av_freep(&mxf->index_tables[i].segments);
3567  av_freep(&mxf->index_tables[i].ptses);
3568  av_freep(&mxf->index_tables[i].fake_index);
3569  av_freep(&mxf->index_tables[i].offsets);
3570  }
3571  }
3572  av_freep(&mxf->index_tables);
3573 
3574  return 0;
3575 }
3576 
3577 static int mxf_probe(const AVProbeData *p) {
3578  const uint8_t *bufp = p->buf;
3579  const uint8_t *end = p->buf + p->buf_size;
3580 
3581  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3582  return 0;
3583 
3584  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3585  end -= sizeof(mxf_header_partition_pack_key);
3586 
3587  for (; bufp < end;) {
3588  if (!((bufp[13] - 1) & 0xF2)){
3589  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3590  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3591  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3593  return AVPROBE_SCORE_MAX;
3594  bufp ++;
3595  } else
3596  bufp += 10;
3597  }
3598 
3599  return 0;
3600 }
3601 
3602 /* rudimentary byte seek */
3603 /* XXX: use MXF Index */
3604 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3605 {
3606  AVStream *st = s->streams[stream_index];
3607  int64_t seconds;
3608  MXFContext* mxf = s->priv_data;
3609  int64_t seekpos;
3610  int i, ret;
3611  MXFIndexTable *t;
3612  MXFTrack *source_track = st->priv_data;
3613 
3614  if (!source_track)
3615  return 0;
3616 
3617  /* if audio then truncate sample_time to EditRate */
3619  sample_time = av_rescale_q(sample_time, st->time_base,
3620  av_inv_q(source_track->edit_rate));
3621 
3622  if (mxf->nb_index_tables <= 0) {
3623  if (!s->bit_rate)
3624  return AVERROR_INVALIDDATA;
3625  if (sample_time < 0)
3626  sample_time = 0;
3627  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3628 
3629  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3630  if (seekpos < 0)
3631  return seekpos;
3632 
3633  ff_update_cur_dts(s, st, sample_time);
3634  mxf->current_klv_data = (KLVPacket){{0}};
3635  } else {
3636  MXFPartition *partition;
3637 
3638  t = &mxf->index_tables[0];
3639  if (t->index_sid != source_track->index_sid) {
3640  /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3641  for (i = 0; i < s->nb_streams; i++) {
3642  MXFTrack *new_source_track = s->streams[i]->priv_data;
3643  if (new_source_track && new_source_track->index_sid == t->index_sid) {
3644  sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3645  source_track = new_source_track;
3646  st = s->streams[i];
3647  break;
3648  }
3649  }
3650  if (i == s->nb_streams)
3651  return AVERROR_INVALIDDATA;
3652  }
3653 
3654  /* clamp above zero, else ff_index_search_timestamp() returns negative
3655  * this also means we allow seeking before the start */
3656  sample_time = FFMAX(sample_time, 0);
3657 
3658  if (t->fake_index) {
3659  /* The first frames may not be keyframes in presentation order, so
3660  * we have to advance the target to be able to find the first
3661  * keyframe backwards... */
3662  if (!(flags & AVSEEK_FLAG_ANY) &&
3663  (flags & AVSEEK_FLAG_BACKWARD) &&
3664  t->ptses[0] != AV_NOPTS_VALUE &&
3665  sample_time < t->ptses[0] &&
3666  (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3667  sample_time = t->ptses[0];
3668 
3669  /* behave as if we have a proper index */
3670  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3671  return sample_time;
3672  /* get the stored order index from the display order index */
3673  sample_time += t->offsets[sample_time];
3674  } else {
3675  /* no IndexEntryArray (one or more CBR segments)
3676  * make sure we don't seek past the end */
3677  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3678  }
3679 
3680  if (source_track->wrapping == UnknownWrapped)
3681  av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3682 
3683  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3684  return ret;
3685 
3686  ff_update_cur_dts(s, st, sample_time);
3687  if (source_track->wrapping == ClipWrapped) {
3688  KLVPacket klv = partition->first_essence_klv;
3689  if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3690  av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3691  return AVERROR_INVALIDDATA;
3692  }
3693  mxf->current_klv_data = klv;
3694  } else {
3695  mxf->current_klv_data = (KLVPacket){{0}};
3696  }
3697  avio_seek(s->pb, seekpos, SEEK_SET);
3698  }
3699 
3700  // Update all tracks sample count
3701  for (i = 0; i < s->nb_streams; i++) {
3702  AVStream *cur_st = s->streams[i];
3703  MXFTrack *cur_track = cur_st->priv_data;
3704  if (cur_track) {
3705  int64_t track_edit_unit = sample_time;
3706  if (st != cur_st)
3707  mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3708  cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3709  }
3710  }
3711  return 0;
3712 }
3713 
3714 static const AVOption options[] = {
3715  { "eia608_extract", "extract eia 608 captions from s436m track",
3716  offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3718  { NULL },
3719 };
3720 
3721 static const AVClass demuxer_class = {
3722  .class_name = "mxf",
3723  .item_name = av_default_item_name,
3724  .option = options,
3725  .version = LIBAVUTIL_VERSION_INT,
3726  .category = AV_CLASS_CATEGORY_DEMUXER,
3727 };
3728 
3730  .name = "mxf",
3731  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3732  .flags = AVFMT_SEEK_TO_PTS,
3733  .priv_data_size = sizeof(MXFContext),
3734  .read_probe = mxf_probe,
3739  .priv_class = &demuxer_class,
3740 };
static const uint8_t mxf_crypto_source_container_ul[]
Definition: mxfdec.c:316
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:568
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2511
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:802
const char const char void * val
Definition: avisynth_c.h:771
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:2143
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4025
MXFMetadataSetType
Definition: mxf.h:30
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c: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:2649
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
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:2813
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:1488
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:2513
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:3085
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:3944
#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:882
#define SET_TS_METADATA(pb, name, var, str)
Definition: mxfdec.c:2593
int size
Definition: avcodec.h:1469
Definition: mxf.h:34
uint64_t footer_partition
Definition: mxfdec.c:283
int closed
Definition: mxfdec.c:89
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c: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:3604
static int mxf_uid_to_str(UID uid, char **str)
Definition: mxfdec.c:1846
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1480
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
Definition: mxfdec.c:531
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
MXFSequence * sequence
Definition: mxfdec.c:167
#define tc
Definition: regdef.h:69
int linked_track_id
Definition: mxfdec.c:206
UID key
Definition: mxf.h:62
static int mxf_umid_to_str(UID ul, UID uid, char **str)
Definition: mxfdec.c:1864
int64_t offset
Definition: mxf.h:63
GLint GLenum type
Definition: opengl_enc.c:105
void * priv_data
Definition: avformat.h:896
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:2984
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:807
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:1838
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:3136
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:3936
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:2782
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:1560
enum MXFMetadataSetType type
Definition: mxfdec.c:184
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that&#39;s been allocated with av_malloc() or another memory allocation function...
Definition: dict.h:73
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:2907
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition: mxfdec.c:2705
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:3418
Format I/O context.
Definition: avformat.h:1358
Definition: mxfdec.c:72
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:2964
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:4010
#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
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
timecode is drop frame
Definition: timecode.h:36
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1486
AVRational index_edit_rate
Definition: mxfdec.c:218
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
int id
Format-specific stream ID.
Definition: avformat.h:888
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:3545
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
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:1885
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:1426
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:1730
MXFIndexTableSegment ** segments
Definition: mxfdec.c:263
const MXFCodecUL ff_mxf_codec_uls[]
Definition: mxf.c:37
uint8_t * data
Definition: avcodec.h:1468
static const uint8_t mxf_sony_mpeg4_extradata[]
Definition: mxfdec.c:320
uint32_t tag
Definition: movenc.c:1501
#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:1337
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:1409
static MXFDescriptor * mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
Definition: mxfdec.c:1942
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:2586
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:386
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
Definition: mxfdec.c:3280
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:1506
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
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:2925
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:1905
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:1897
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:811
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:1343
Definition: mxf.h:56
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3940
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:1358
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:3254
GLsizei GLsizei * length
Definition: opengl_enc.c:115
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
Definition: mxfdec.c:2864
#define IS_KLV_KEY(x, y)
Definition: mxfdec.c:326
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:31
int track_id
Definition: mxfdec.c:169
GLsizei count
Definition: opengl_enc.c: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:118
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:801
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:639
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:1995
int64_t index_byte_count
Definition: mxfdec.c:100
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
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:448
static int mxf_probe(const AVProbeData *p)
Definition: mxfdec.c:3577
Definition: hls.c:68
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
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:5301
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
#define b
Definition: input.c:41
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int local_tags_count
Definition: mxfdec.c:282
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c: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:1968
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:3254
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
enum AVPixelFormat pix_fmt
Definition: mxfdec.c:209
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:2013
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
Definition: mxfdec.c:1926
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:1350
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:2692
int n
Definition: avisynth_c.h:684
AVDictionary * metadata
Definition: avformat.h:945
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:2966
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:2599
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:2970
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
if(ret)
static const AVClass demuxer_class
Definition: mxfdec.c:3721
Stream structure.
Definition: avformat.h:881
#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:3015
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:1400
static int resync(AVFormatContext *s)
Definition: flvdec.c:911
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:2691
Definition: mxfdec.c:69
int samples_per_frame[6]
Definition: mxf.h:86
#define AV_RN16(p)
Definition: intreadwrite.h:360
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now.Options-------Then comes the options array.This is what will define the user accessible options.For example
void * buf
Definition: avisynth_c.h:690
int run_in
Definition: mxfdec.c:285
KLVPacket first_essence_klv
Definition: mxfdec.c:104
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int comment_count
Definition: mxfdec.c:238
static const MXFCodecUL mxf_data_essence_container_uls[]
Definition: mxfdec.c:1368
#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:3714
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:1232
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:498
uint8_t * extradata
Definition: mxfdec.c:207
UID package_ul
Definition: mxfdec.c:231
unsigned partitions_count
Definition: mxfdec.c:271
AVRational sample_rate
Definition: mxfdec.c:188
#define snprintf
Definition: snprintf.h:34
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
Computes the absolute file offset of the given essence container offset.
Definition: mxfdec.c:1496
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
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:606
static const uint8_t mxf_indirect_value_utf16be[]
Definition: mxfdec.c:324
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static int64_t klv_decode_ber_length(AVIOContext *pb)
Definition: mxfdec.c: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 int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
Definition: mxfdec.c:1375
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:930
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:4054
Definition: mxfdec.c:76
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
Definition: mxfdec.c:2035
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
const uint8_t * key
Definition: avformat.h:1534
static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
Definition: mxfdec.c:3388
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:800
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
const char * desc
Definition: mxf.h:79
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition: mxfdec.c:1315