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