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