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