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