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