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  break;
1775  }
1776  /* Turn field height into frame height. */
1777  st->codec->height *= 2;
1778  break;
1779  default:
1780  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1781  }
1782  if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1783  st->codec->pix_fmt = descriptor->pix_fmt;
1784  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1786  &descriptor->essence_codec_ul);
1787  st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1788  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1789  /* support files created before RP224v10 by defaulting to UYVY422
1790  if subsampling is 4:2:2 and component depth is 8-bit */
1791  if (descriptor->horiz_subsampling == 2 &&
1792  descriptor->vert_subsampling == 1 &&
1793  descriptor->component_depth == 8) {
1795  }
1796  }
1797  }
1798  }
1800  if (material_track->sequence->origin) {
1801  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1802  }
1803  if (source_track->sequence->origin) {
1804  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1805  }
1806  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
1807  st->display_aspect_ratio = descriptor->aspect_ratio;
1808  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1809  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1810  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1811  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))
1812  st->codec->codec_id = (enum AVCodecID)container_ul->id;
1813  st->codec->channels = descriptor->channels;
1814  st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1815 
1816  if (descriptor->sample_rate.den > 0) {
1817  st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1818  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1819  } else {
1820  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1821  "found for stream #%d, time base forced to 1/48000\n",
1822  descriptor->sample_rate.num, descriptor->sample_rate.den,
1823  st->index);
1824  avpriv_set_pts_info(st, 64, 1, 48000);
1825  }
1826 
1827  /* if duration is set, rescale it from EditRate to SampleRate */
1828  if (st->duration != AV_NOPTS_VALUE)
1829  st->duration = av_rescale_q(st->duration,
1830  av_inv_q(material_track->edit_rate),
1831  st->time_base);
1832 
1833  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1834  if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1835  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1837  else if (descriptor->bits_per_sample == 32)
1839  } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1840  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1842  else if (descriptor->bits_per_sample == 32)
1844  } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1846  }
1847  } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1848  int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1849  essence_container_ul)->id;
1850  if (codec_id >= 0 &&
1851  codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1852  av_dict_set(&st->metadata, "data_type",
1853  mxf_data_essence_descriptor[codec_id], 0);
1854  }
1855  }
1856  if (descriptor->extradata) {
1857  if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1858  memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1859  }
1860  } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1861  ret = ff_generate_avci_extradata(st);
1862  if (ret < 0)
1863  return ret;
1864  }
1865  if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1866  /* TODO: decode timestamps */
1868  }
1869  }
1870 
1871  ret = 0;
1872 fail_and_free:
1873  return ret;
1874 }
1875 
1876 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1877 {
1878  struct tm time = { 0 };
1879  time.tm_year = (timestamp >> 48) - 1900;
1880  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1881  time.tm_mday = (timestamp >> 32 & 0xFF);
1882  time.tm_hour = (timestamp >> 24 & 0xFF);
1883  time.tm_min = (timestamp >> 16 & 0xFF);
1884  time.tm_sec = (timestamp >> 8 & 0xFF);
1885 
1886  /* msvcrt versions of strftime calls the invalid parameter handler
1887  * (aborting the process if one isn't set) if the parameters are out
1888  * of range. */
1889  time.tm_mon = av_clip(time.tm_mon, 0, 11);
1890  time.tm_mday = av_clip(time.tm_mday, 1, 31);
1891  time.tm_hour = av_clip(time.tm_hour, 0, 23);
1892  time.tm_min = av_clip(time.tm_min, 0, 59);
1893  time.tm_sec = av_clip(time.tm_sec, 0, 59);
1894 
1895  *str = av_mallocz(32);
1896  if (!*str)
1897  return AVERROR(ENOMEM);
1898  if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
1899  str[0] = '\0';
1900 
1901  return 0;
1902 }
1903 
1904 #define SET_STR_METADATA(pb, name, str) do { \
1905  if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1906  return ret; \
1907  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1908 } while (0)
1909 
1910 #define SET_UID_METADATA(pb, name, var, str) do { \
1911  avio_read(pb, var, 16); \
1912  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1913  return ret; \
1914  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1915 } while (0)
1916 
1917 #define SET_TS_METADATA(pb, name, var, str) do { \
1918  var = avio_rb64(pb); \
1919  if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1920  return ret; \
1921  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1922 } while (0)
1923 
1924 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1925 {
1926  MXFContext *mxf = arg;
1927  AVFormatContext *s = mxf->fc;
1928  int ret;
1929  UID uid = { 0 };
1930  char *str = NULL;
1931  uint64_t ts;
1932  switch (tag) {
1933  case 0x3C01:
1934  SET_STR_METADATA(pb, "company_name", str);
1935  break;
1936  case 0x3C02:
1937  SET_STR_METADATA(pb, "product_name", str);
1938  break;
1939  case 0x3C04:
1940  SET_STR_METADATA(pb, "product_version", str);
1941  break;
1942  case 0x3C05:
1943  SET_UID_METADATA(pb, "product_uid", uid, str);
1944  break;
1945  case 0x3C06:
1946  SET_TS_METADATA(pb, "modification_date", ts, str);
1947  break;
1948  case 0x3C08:
1949  SET_STR_METADATA(pb, "application_platform", str);
1950  break;
1951  case 0x3C09:
1952  SET_UID_METADATA(pb, "generation_uid", uid, str);
1953  break;
1954  case 0x3C0A:
1955  SET_UID_METADATA(pb, "uid", uid, str);
1956  break;
1957  }
1958  return 0;
1959 }
1960 
1962  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1963  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1964  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1965  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1966  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1967  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1968  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1969  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1970  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1971  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1972  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1973  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1974  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1975  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
1976  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
1977  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1978  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1979  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1980  { { 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 */
1981  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1982  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1983  { { 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 */
1984  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1985  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1986  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
1987  { { 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 */
1988  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
1989  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1990  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1991  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1992  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
1993  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1994  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1995  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1996 };
1997 
1998 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1999 {
2000  AVIOContext *pb = mxf->fc->pb;
2001  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2002  uint64_t klv_end = avio_tell(pb) + klv->length;
2003 
2004  if (!ctx)
2005  return AVERROR(ENOMEM);
2006  while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2007  int ret;
2008  int tag = avio_rb16(pb);
2009  int size = avio_rb16(pb); /* KLV specified by 0x53 */
2010  uint64_t next = avio_tell(pb) + size;
2011  UID uid = {0};
2012 
2013  av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
2014  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2015  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2016  continue;
2017  }
2018  if (tag > 0x7FFF) { /* dynamic tag */
2019  int i;
2020  for (i = 0; i < mxf->local_tags_count; i++) {
2021  int local_tag = AV_RB16(mxf->local_tags+i*18);
2022  if (local_tag == tag) {
2023  memcpy(uid, mxf->local_tags+i*18+2, 16);
2024  av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
2025  PRINT_KEY(mxf->fc, "uid", uid);
2026  }
2027  }
2028  }
2029  if (ctx_size && tag == 0x3C0A)
2030  avio_read(pb, ctx->uid, 16);
2031  else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
2032  return ret;
2033 
2034  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2035  * it extending past the end of the KLV though (zzuf5.mxf). */
2036  if (avio_tell(pb) > klv_end) {
2037  if (ctx_size)
2038  av_free(ctx);
2039 
2040  av_log(mxf->fc, AV_LOG_ERROR,
2041  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2042  tag, klv->offset);
2043  return AVERROR_INVALIDDATA;
2044  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2045  avio_seek(pb, next, SEEK_SET);
2046  }
2047  if (ctx_size) ctx->type = type;
2048  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2049 }
2050 
2051 /**
2052  * Matches any partition pack key, in other words:
2053  * - HeaderPartition
2054  * - BodyPartition
2055  * - FooterPartition
2056  * @return non-zero if the key is a partition pack key, zero otherwise
2057  */
2059 {
2060  //NOTE: this is a little lax since it doesn't constraint key[14]
2061  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2062  key[13] >= 2 && key[13] <= 4;
2063 }
2064 
2065 /**
2066  * Parses a metadata KLV
2067  * @return <0 on error, 0 otherwise
2068  */
2070  int ctx_size, enum MXFMetadataSetType type)
2071 {
2072  AVFormatContext *s = mxf->fc;
2073  int res;
2074  if (klv.key[5] == 0x53) {
2075  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2076  } else {
2077  uint64_t next = avio_tell(s->pb) + klv.length;
2078  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2079 
2080  /* only seek forward, else this can loop for a long time */
2081  if (avio_tell(s->pb) > next) {
2082  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2083  klv.offset);
2084  return AVERROR_INVALIDDATA;
2085  }
2086 
2087  avio_seek(s->pb, next, SEEK_SET);
2088  }
2089  if (res < 0) {
2090  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2091  return res;
2092  }
2093  return 0;
2094 }
2095 
2096 /**
2097  * Seeks to the previous partition and parses it, if possible
2098  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2099  */
2101 {
2102  AVIOContext *pb = mxf->fc->pb;
2103  KLVPacket klv;
2104  int64_t current_partition_ofs;
2105  int ret;
2106 
2107  if (!mxf->current_partition ||
2109  return 0; /* we've parsed all partitions */
2110 
2111  /* seek to previous partition */
2112  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2113  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2114  mxf->current_partition = NULL;
2115 
2116  av_dlog(mxf->fc, "seeking to previous partition\n");
2117 
2118  /* Make sure this is actually a PartitionPack, and if so parse it.
2119  * See deadlock2.mxf
2120  */
2121  if ((ret = klv_read_packet(&klv, pb)) < 0) {
2122  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2123  return ret;
2124  }
2125 
2126  if (!mxf_is_partition_pack_key(klv.key)) {
2127  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2128  return AVERROR_INVALIDDATA;
2129  }
2130 
2131  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2132  * can point to just before the current partition, causing klv_read_packet()
2133  * to sync back up to it. See deadlock3.mxf
2134  */
2135  if (klv.offset >= current_partition_ofs) {
2136  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2137  PRIx64 " indirectly points to itself\n", current_partition_ofs);
2138  return AVERROR_INVALIDDATA;
2139  }
2140 
2141  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2142  return ret;
2143 
2144  return 1;
2145 }
2146 
2147 /**
2148  * Called when essence is encountered
2149  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2150  */
2152 {
2153  AVIOContext *pb = mxf->fc->pb;
2154  int64_t ret;
2155 
2156  if (mxf->parsing_backward) {
2157  return mxf_seek_to_previous_partition(mxf);
2158  } else {
2159  if (!mxf->footer_partition) {
2160  av_dlog(mxf->fc, "no FooterPartition\n");
2161  return 0;
2162  }
2163 
2164  av_dlog(mxf->fc, "seeking to FooterPartition\n");
2165 
2166  /* remember where we were so we don't end up seeking further back than this */
2167  mxf->last_forward_tell = avio_tell(pb);
2168 
2169  if (!pb->seekable) {
2170  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2171  return -1;
2172  }
2173 
2174  /* seek to FooterPartition and parse backward */
2175  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2176  av_log(mxf->fc, AV_LOG_ERROR,
2177  "failed to seek to FooterPartition @ 0x%" PRIx64
2178  " (%"PRId64") - partial file?\n",
2179  mxf->run_in + mxf->footer_partition, ret);
2180  return ret;
2181  }
2182 
2183  mxf->current_partition = NULL;
2184  mxf->parsing_backward = 1;
2185  }
2186 
2187  return 1;
2188 }
2189 
2190 /**
2191  * Called when the next partition or EOF is encountered
2192  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2193  */
2195 {
2196  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2197 }
2198 
2199 /**
2200  * Figures out the proper offset and length of the essence container in each partition
2201  */
2203 {
2204  int x;
2205 
2206  /* everything is already correct */
2207  if (mxf->op == OPAtom)
2208  return;
2209 
2210  for (x = 0; x < mxf->partitions_count; x++) {
2211  MXFPartition *p = &mxf->partitions[x];
2212 
2213  if (!p->body_sid)
2214  continue; /* BodySID == 0 -> no essence */
2215 
2216  if (x >= mxf->partitions_count - 1)
2217  break; /* FooterPartition - can't compute length (and we don't need to) */
2218 
2219  /* essence container spans to the next partition */
2221 
2222  if (p->essence_length < 0) {
2223  /* next ThisPartition < essence_offset */
2224  p->essence_length = 0;
2225  av_log(mxf->fc, AV_LOG_ERROR,
2226  "partition %i: bad ThisPartition = %"PRIX64"\n",
2227  x+1, mxf->partitions[x+1].this_partition);
2228  }
2229  }
2230 }
2231 
2232 static int64_t round_to_kag(int64_t position, int kag_size)
2233 {
2234  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2235  /* NOTE: kag_size may be any integer between 1 - 2^10 */
2236  int64_t ret = (position / kag_size) * kag_size;
2237  return ret == position ? ret : ret + kag_size;
2238 }
2239 
2240 static int is_pcm(enum AVCodecID codec_id)
2241 {
2242  /* we only care about "normal" PCM codecs until we get samples */
2243  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2244 }
2245 
2246 /**
2247  * Deal with the case where for some audio atoms EditUnitByteCount is
2248  * very small (2, 4..). In those cases we should read more than one
2249  * sample per call to mxf_read_packet().
2250  */
2252 {
2253  MXFContext *mxf = s->priv_data;
2254 
2255  /* assuming non-OPAtom == frame wrapped
2256  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2257  if (mxf->op != OPAtom)
2258  return;
2259 
2260  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2261  if (s->nb_streams != 1 ||
2263  !is_pcm(s->streams[0]->codec->codec_id) ||
2264  mxf->nb_index_tables != 1 ||
2265  mxf->index_tables[0].nb_segments != 1 ||
2266  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2267  return;
2268 
2269  /* arbitrarily default to 48 kHz PAL audio frame size */
2270  /* TODO: We could compute this from the ratio between the audio
2271  * and video edit rates for 48 kHz NTSC we could use the
2272  * 1802-1802-1802-1802-1801 pattern. */
2273  mxf->edit_units_per_packet = 1920;
2274 }
2275 
2277 {
2278  MXFContext *mxf = s->priv_data;
2279  uint32_t length;
2280  int64_t file_size, max_rip_length, min_rip_length;
2281  KLVPacket klv;
2282 
2283  if (!s->pb->seekable)
2284  return;
2285 
2286  file_size = avio_size(s->pb);
2287 
2288  /* S377m says to check the RIP length for "silly" values, without defining "silly".
2289  * The limit below assumes a file with nothing but partition packs and a RIP.
2290  * Before changing this, consider that a muxer may place each sample in its own partition.
2291  *
2292  * 105 is the size of the smallest possible PartitionPack
2293  * 12 is the size of each RIP entry
2294  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2295  */
2296  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2297  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2298 
2299  /* We're only interested in RIPs with at least two entries.. */
2300  min_rip_length = 16+1+24+4;
2301 
2302  /* See S377m section 11 */
2303  avio_seek(s->pb, file_size - 4, SEEK_SET);
2304  length = avio_rb32(s->pb);
2305 
2306  if (length < min_rip_length || length > max_rip_length)
2307  goto end;
2308  avio_seek(s->pb, file_size - length, SEEK_SET);
2309  if (klv_read_packet(&klv, s->pb) < 0 ||
2311  klv.length != length - 20)
2312  goto end;
2313 
2314  avio_skip(s->pb, klv.length - 12);
2315  mxf->footer_partition = avio_rb64(s->pb);
2316 
2317  /* sanity check */
2318  if (mxf->run_in + mxf->footer_partition >= file_size) {
2319  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2320  mxf->footer_partition = 0;
2321  }
2322 
2323 end:
2324  avio_seek(s->pb, mxf->run_in, SEEK_SET);
2325 }
2326 
2328 {
2329  MXFContext *mxf = s->priv_data;
2330  KLVPacket klv;
2331  int64_t essence_offset = 0;
2332  int ret;
2333 
2334  mxf->last_forward_tell = INT64_MAX;
2335  mxf->edit_units_per_packet = 1;
2336 
2338  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2339  return AVERROR_INVALIDDATA;
2340  }
2341  avio_seek(s->pb, -14, SEEK_CUR);
2342  mxf->fc = s;
2343  mxf->run_in = avio_tell(s->pb);
2344 
2346 
2347  while (!avio_feof(s->pb)) {
2348  const MXFMetadataReadTableEntry *metadata;
2349 
2350  if (klv_read_packet(&klv, s->pb) < 0) {
2351  /* EOF - seek to previous partition or stop */
2352  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2353  break;
2354  else
2355  continue;
2356  }
2357 
2358  PRINT_KEY(s, "read header", klv.key);
2359  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2364 
2365  if (!mxf->current_partition) {
2366  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2367  return AVERROR_INVALIDDATA;
2368  }
2369 
2370  if (!mxf->current_partition->essence_offset) {
2371  /* for OP1a we compute essence_offset
2372  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2373  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2374  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2375  */
2376  int64_t op1a_essence_offset =
2381 
2382  if (mxf->op == OPAtom) {
2383  /* point essence_offset to the actual data
2384  * OPAtom has all the essence in one big KLV
2385  */
2388  } else {
2389  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2390  mxf->current_partition->essence_offset = op1a_essence_offset;
2391  }
2392  }
2393 
2394  if (!essence_offset)
2395  essence_offset = klv.offset;
2396 
2397  /* seek to footer, previous partition or stop */
2398  if (mxf_parse_handle_essence(mxf) <= 0)
2399  break;
2400  continue;
2401  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2402  /* next partition pack - keep going, seek to previous partition or stop */
2403  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2404  break;
2405  else if (mxf->parsing_backward)
2406  continue;
2407  /* we're still parsing forward. proceed to parsing this partition pack */
2408  }
2409 
2410  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2411  if (IS_KLV_KEY(klv.key, metadata->key)) {
2412  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2413  goto fail;
2414  break;
2415  } else {
2416  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2417  UID_ARG(klv.key));
2418  }
2419  }
2420  if (!metadata->read)
2421  avio_skip(s->pb, klv.length);
2422  }
2423  /* FIXME avoid seek */
2424  if (!essence_offset) {
2425  av_log(s, AV_LOG_ERROR, "no essence\n");
2426  return AVERROR_INVALIDDATA;
2427  }
2428  avio_seek(s->pb, essence_offset, SEEK_SET);
2429 
2431 
2432  /* we need to do this before computing the index tables
2433  * to be able to fill in zero IndexDurations with st->duration */
2434  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2435  goto fail;
2436 
2437  if ((ret = mxf_compute_index_tables(mxf)) < 0)
2438  goto fail;
2439 
2440  if (mxf->nb_index_tables > 1) {
2441  /* TODO: look up which IndexSID to use via EssenceContainerData */
2442  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2443  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2444  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2445  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2446  ret = AVERROR_INVALIDDATA;
2447  goto fail;
2448  }
2449 
2451 
2452  return 0;
2453 fail:
2454  mxf_read_close(s);
2455 
2456  return ret;
2457 }
2458 
2459 /**
2460  * Sets mxf->current_edit_unit based on what offset we're currently at.
2461  * @return next_ofs if OK, <0 on error
2462  */
2463 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2464 {
2465  int64_t last_ofs = -1, next_ofs = -1;
2466  MXFIndexTable *t = &mxf->index_tables[0];
2467 
2468  /* this is called from the OP1a demuxing logic, which means there
2469  * may be no index tables */
2470  if (mxf->nb_index_tables <= 0)
2471  return -1;
2472 
2473  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2474  while (mxf->current_edit_unit >= 0) {
2475  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2476  return -1;
2477 
2478  if (next_ofs <= last_ofs) {
2479  /* large next_ofs didn't change or current_edit_unit wrapped
2480  * around this fixes the infinite loop on zzuf3.mxf */
2481  av_log(mxf->fc, AV_LOG_ERROR,
2482  "next_ofs didn't change. not deriving packet timestamps\n");
2483  return -1;
2484  }
2485 
2486  if (next_ofs > current_offset)
2487  break;
2488 
2489  last_ofs = next_ofs;
2490  mxf->current_edit_unit++;
2491  }
2492 
2493  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2494  if (mxf->current_edit_unit < 0)
2495  return -1;
2496 
2497  return next_ofs;
2498 }
2499 
2500 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2501  uint64_t *sample_count)
2502 {
2503  int i, total = 0, size = 0;
2504  AVStream *st = mxf->fc->streams[stream_index];
2505  MXFTrack *track = st->priv_data;
2506  AVRational time_base = av_inv_q(track->edit_rate);
2508  const MXFSamplesPerFrame *spf = NULL;
2509 
2510  if ((sample_rate.num / sample_rate.den) == 48000)
2511  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2512  if (!spf) {
2513  int remainder = (sample_rate.num * time_base.num) %
2514  (time_base.den * sample_rate.den);
2515  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2516  av_mul_q(sample_rate, time_base)));
2517  if (remainder)
2518  av_log(mxf->fc, AV_LOG_WARNING,
2519  "seeking detected on stream #%d with time base (%d/%d) and "
2520  "sample rate (%d/%d), audio pts won't be accurate.\n",
2521  stream_index, time_base.num, time_base.den,
2522  sample_rate.num, sample_rate.den);
2523  return 0;
2524  }
2525 
2526  while (spf->samples_per_frame[size]) {
2527  total += spf->samples_per_frame[size];
2528  size++;
2529  }
2530 
2531  av_assert2(size);
2532 
2533  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2534  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2535  *sample_count += spf->samples_per_frame[i];
2536  }
2537 
2538  return 0;
2539 }
2540 
2542  AVPacket *pkt)
2543 {
2544  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2545  int64_t bits_per_sample = codec->bits_per_coded_sample;
2546 
2547  if (!bits_per_sample)
2548  bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2549 
2550  pkt->pts = track->sample_count;
2551 
2552  if ( codec->channels <= 0
2553  || bits_per_sample <= 0
2554  || codec->channels * (int64_t)bits_per_sample < 8)
2555  return AVERROR(EINVAL);
2556  track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2557  return 0;
2558 }
2559 
2561 {
2562  KLVPacket klv;
2563  MXFContext *mxf = s->priv_data;
2564  int ret;
2565 
2566  while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2567  PRINT_KEY(s, "read packet", klv.key);
2568  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2570  ret = mxf_decrypt_triplet(s, pkt, &klv);
2571  if (ret < 0) {
2572  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2573  return ret;
2574  }
2575  return 0;
2576  }
2579  int index = mxf_get_stream_index(s, &klv);
2580  int64_t next_ofs, next_klv;
2581  AVStream *st;
2582  MXFTrack *track;
2583  AVCodecContext *codec;
2584 
2585  if (index < 0) {
2586  av_log(s, AV_LOG_ERROR,
2587  "error getting stream index %"PRIu32"\n",
2588  AV_RB32(klv.key + 12));
2589  goto skip;
2590  }
2591 
2592  st = s->streams[index];
2593  track = st->priv_data;
2594 
2595  if (s->streams[index]->discard == AVDISCARD_ALL)
2596  goto skip;
2597 
2598  next_klv = avio_tell(s->pb) + klv.length;
2599  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2600 
2601  if (next_ofs >= 0 && next_klv > next_ofs) {
2602  /* if this check is hit then it's possible OPAtom was treated as OP1a
2603  * truncate the packet since it's probably very large (>2 GiB is common) */
2605  "OPAtom misinterpreted as OP1a?"
2606  "KLV for edit unit %i extending into "
2607  "next edit unit",
2608  mxf->current_edit_unit);
2609  klv.length = next_ofs - avio_tell(s->pb);
2610  }
2611 
2612  /* check for 8 channels AES3 element */
2613  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2614  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2615  pkt, klv.length);
2616  if (ret < 0) {
2617  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2618  return ret;
2619  }
2620  } else {
2621  ret = av_get_packet(s->pb, pkt, klv.length);
2622  if (ret < 0)
2623  return ret;
2624  }
2625  pkt->stream_index = index;
2626  pkt->pos = klv.offset;
2627 
2628  codec = st->codec;
2629 
2630  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2631  /* mxf->current_edit_unit good - see if we have an
2632  * index table to derive timestamps from */
2633  MXFIndexTable *t = &mxf->index_tables[0];
2634 
2635  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2636  pkt->dts = mxf->current_edit_unit + t->first_dts;
2637  pkt->pts = t->ptses[mxf->current_edit_unit];
2638  } else if (track->intra_only) {
2639  /* intra-only -> PTS = EditUnit.
2640  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2641  pkt->pts = mxf->current_edit_unit;
2642  }
2643  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2644  ret = mxf_set_audio_pts(mxf, codec, pkt);
2645  if (ret < 0)
2646  return ret;
2647  }
2648 
2649  /* seek for truncated packets */
2650  avio_seek(s->pb, next_klv, SEEK_SET);
2651 
2652  return 0;
2653  } else
2654  skip:
2655  avio_skip(s->pb, klv.length);
2656  }
2657  return avio_feof(s->pb) ? AVERROR_EOF : ret;
2658 }
2659 
2661 {
2662  MXFContext *mxf = s->priv_data;
2663  int ret, size;
2664  int64_t ret64, pos, next_pos;
2665  AVStream *st;
2666  MXFIndexTable *t;
2667  int edit_units;
2668 
2669  if (mxf->op != OPAtom)
2670  return mxf_read_packet_old(s, pkt);
2671 
2672  /* OPAtom - clip wrapped demuxing */
2673  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2674  st = s->streams[0];
2675  t = &mxf->index_tables[0];
2676 
2677  if (mxf->current_edit_unit >= st->duration)
2678  return AVERROR_EOF;
2679 
2680  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2681 
2682  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2683  return ret;
2684 
2685  /* compute size by finding the next edit unit or the end of the essence container
2686  * not pretty, but it works */
2687  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2688  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2689  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2690  return AVERROR_INVALIDDATA;
2691  }
2692 
2693  if ((size = next_pos - pos) <= 0) {
2694  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2695  return AVERROR_INVALIDDATA;
2696  }
2697 
2698  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2699  return ret64;
2700 
2701  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2702  return size;
2703 
2704  pkt->stream_index = 0;
2705 
2706  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2707  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2708  pkt->dts = mxf->current_edit_unit + t->first_dts;
2709  pkt->pts = t->ptses[mxf->current_edit_unit];
2710  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2711  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2712  if (ret < 0)
2713  return ret;
2714  }
2715 
2716  mxf->current_edit_unit += edit_units;
2717 
2718  return 0;
2719 }
2720 
2722 {
2723  MXFContext *mxf = s->priv_data;
2724  MXFIndexTableSegment *seg;
2725  int i;
2726 
2727  av_freep(&mxf->packages_refs);
2728 
2729  for (i = 0; i < s->nb_streams; i++)
2730  s->streams[i]->priv_data = NULL;
2731 
2732  for (i = 0; i < mxf->metadata_sets_count; i++) {
2733  switch (mxf->metadata_sets[i]->type) {
2734  case Descriptor:
2735  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2736  break;
2737  case MultipleDescriptor:
2738  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2739  break;
2740  case Sequence:
2741  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2742  break;
2743  case SourcePackage:
2744  case MaterialPackage:
2745  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2746  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->name);
2747  break;
2748  case IndexTableSegment:
2749  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2751  av_freep(&seg->flag_entries);
2753  break;
2754  default:
2755  break;
2756  }
2757  av_freep(&mxf->metadata_sets[i]);
2758  }
2759  av_freep(&mxf->partitions);
2760  av_freep(&mxf->metadata_sets);
2761  av_freep(&mxf->aesc);
2762  av_freep(&mxf->local_tags);
2763 
2764  if (mxf->index_tables) {
2765  for (i = 0; i < mxf->nb_index_tables; i++) {
2766  av_freep(&mxf->index_tables[i].segments);
2767  av_freep(&mxf->index_tables[i].ptses);
2768  av_freep(&mxf->index_tables[i].fake_index);
2769  }
2770  }
2771  av_freep(&mxf->index_tables);
2772 
2773  return 0;
2774 }
2775 
2776 static int mxf_probe(AVProbeData *p) {
2777  const uint8_t *bufp = p->buf;
2778  const uint8_t *end = p->buf + p->buf_size;
2779 
2780  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2781  return 0;
2782 
2783  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2784  end -= sizeof(mxf_header_partition_pack_key);
2785 
2786  for (; bufp < end;) {
2787  if (!((bufp[13] - 1) & 0xF2)){
2788  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2789  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2790  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2792  return AVPROBE_SCORE_MAX;
2793  bufp ++;
2794  } else
2795  bufp += 10;
2796  }
2797 
2798  return 0;
2799 }
2800 
2801 /* rudimentary byte seek */
2802 /* XXX: use MXF Index */
2803 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2804 {
2805  AVStream *st = s->streams[stream_index];
2806  int64_t seconds;
2807  MXFContext* mxf = s->priv_data;
2808  int64_t seekpos;
2809  int i, ret;
2810  MXFIndexTable *t;
2811  MXFTrack *source_track = st->priv_data;
2812 
2813  /* if audio then truncate sample_time to EditRate */
2814  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2815  sample_time = av_rescale_q(sample_time, st->time_base,
2816  av_inv_q(source_track->edit_rate));
2817 
2818  if (mxf->nb_index_tables <= 0) {
2819  if (!s->bit_rate)
2820  return AVERROR_INVALIDDATA;
2821  if (sample_time < 0)
2822  sample_time = 0;
2823  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2824 
2825  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2826  if (seekpos < 0)
2827  return seekpos;
2828 
2829  ff_update_cur_dts(s, st, sample_time);
2830  mxf->current_edit_unit = sample_time;
2831  } else {
2832  t = &mxf->index_tables[0];
2833 
2834  /* clamp above zero, else ff_index_search_timestamp() returns negative
2835  * this also means we allow seeking before the start */
2836  sample_time = FFMAX(sample_time, 0);
2837 
2838  if (t->fake_index) {
2839  /* behave as if we have a proper index */
2840  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2841  return sample_time;
2842  } else {
2843  /* no IndexEntryArray (one or more CBR segments)
2844  * make sure we don't seek past the end */
2845  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2846  }
2847 
2848  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2849  return ret;
2850 
2851  ff_update_cur_dts(s, st, sample_time);
2852  mxf->current_edit_unit = sample_time;
2853  avio_seek(s->pb, seekpos, SEEK_SET);
2854  }
2855 
2856  // Update all tracks sample count
2857  for (i = 0; i < s->nb_streams; i++) {
2858  AVStream *cur_st = s->streams[i];
2859  MXFTrack *cur_track = cur_st->priv_data;
2860  uint64_t current_sample_count = 0;
2861  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2862  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2863  if (ret < 0)
2864  return ret;
2865 
2866  cur_track->sample_count = current_sample_count;
2867  }
2868  }
2869  return 0;
2870 }
2871 
2873  .name = "mxf",
2874  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2875  .priv_data_size = sizeof(MXFContext),
2876  .read_probe = mxf_probe,
2881 };