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