FFmpeg  1.2.12
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 //#define DEBUG
47 
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/timecode.h"
53 #include "avformat.h"
54 #include "internal.h"
55 #include "mxf.h"
56 
57 typedef enum {
62 
63 typedef enum {
64  OP1a = 1,
74  OPSONYOpt, /* FATE sample, violates the spec in places */
75 } MXFOP;
76 
77 typedef struct {
78  int closed;
79  int complete;
82  int index_sid;
83  int body_sid;
84  int64_t this_partition;
85  int64_t essence_offset;
86  int64_t essence_length;
91 } MXFPartition;
92 
93 typedef struct {
98 
99 typedef struct {
104  int64_t duration;
105  int64_t start_position;
108 
109 typedef struct {
115  int64_t duration;
116 } MXFSequence;
117 
118 typedef struct {
123  struct AVRational rate;
126 
127 typedef struct {
130  MXFSequence *sequence; /* mandatory, and only one */
132  int track_id;
133  uint8_t track_number[4];
136  uint64_t sample_count;
138 } MXFTrack;
139 
140 typedef struct {
147  int width;
148  int height; /* Field height, not frame height */
149  int frame_layout; /* See MXFFrameLayout enum */
150  int channels;
152  unsigned int component_depth;
153  unsigned int horiz_subsampling;
154  unsigned int vert_subsampling;
161 } MXFDescriptor;
162 
163 typedef struct {
168  int body_sid;
171  uint64_t index_duration;
177 
178 typedef struct {
184  MXFDescriptor *descriptor; /* only one */
186 } MXFPackage;
187 
188 typedef struct {
192 
193 /* decoded index table */
194 typedef struct {
196  int body_sid;
197  int nb_ptses; /* number of PTSes or total duration of index */
198  int64_t first_dts; /* DTS = EditUnit + first_dts */
199  int64_t *ptses; /* maps EditUnit -> PTS */
201  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
202  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
203 } MXFIndexTable;
204 
205 typedef struct {
214  struct AVAES *aesc;
220  int run_in;
229 } MXFContext;
230 
234 };
235 
236 /* NOTE: klv_offset is not set (-1) for local keys */
237 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
238 
239 typedef struct {
240  const UID key;
242  int ctx_size;
245 
246 static int mxf_read_close(AVFormatContext *s);
247 
248 /* partial keys to match */
249 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
250 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
251 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
252 static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
253 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
254 /* complete keys to match */
255 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 };
256 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
257 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
258 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
259 
260 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
261 
263 {
264  uint64_t size = avio_r8(pb);
265  if (size & 0x80) { /* long form */
266  int bytes_num = size & 0x7f;
267  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
268  if (bytes_num > 8)
269  return AVERROR_INVALIDDATA;
270  size = 0;
271  while (bytes_num--)
272  size = size << 8 | avio_r8(pb);
273  }
274  return size;
275 }
276 
277 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
278 {
279  int i, b;
280  for (i = 0; i < size && !url_feof(pb); i++) {
281  b = avio_r8(pb);
282  if (b == key[0])
283  i = 0;
284  else if (b != key[i])
285  i = -1;
286  }
287  return i == size;
288 }
289 
290 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
291 {
292  if (!mxf_read_sync(pb, mxf_klv_key, 4))
293  return AVERROR_INVALIDDATA;
294  klv->offset = avio_tell(pb) - 4;
295  memcpy(klv->key, mxf_klv_key, 4);
296  avio_read(pb, klv->key + 4, 12);
297  klv->length = klv_decode_ber_length(pb);
298  return klv->length == -1 ? -1 : 0;
299 }
300 
302 {
303  int i;
304 
305  for (i = 0; i < s->nb_streams; i++) {
306  MXFTrack *track = s->streams[i]->priv_data;
307  /* SMPTE 379M 7.3 */
308  if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
309  return i;
310  }
311  /* return 0 if only one stream, for OP Atom files with 0 as track number */
312  return s->nb_streams == 1 ? 0 : -1;
313 }
314 
315 /* XXX: use AVBitStreamFilter */
316 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
317 {
318  const uint8_t *buf_ptr, *end_ptr;
319  uint8_t *data_ptr;
320  int i;
321 
322  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
323  return AVERROR_INVALIDDATA;
324  length = av_get_packet(pb, pkt, length);
325  if (length < 0)
326  return length;
327  data_ptr = pkt->data;
328  end_ptr = pkt->data + length;
329  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
330  for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
331  for (i = 0; i < st->codec->channels; i++) {
332  uint32_t sample = bytestream_get_le32(&buf_ptr);
333  if (st->codec->bits_per_coded_sample == 24)
334  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
335  else
336  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
337  }
338  buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
339  }
340  av_shrink_packet(pkt, data_ptr - pkt->data);
341  return 0;
342 }
343 
345 {
346  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
347  MXFContext *mxf = s->priv_data;
348  AVIOContext *pb = s->pb;
349  int64_t end = avio_tell(pb) + klv->length;
350  int64_t size;
351  uint64_t orig_size;
352  uint64_t plaintext_size;
353  uint8_t ivec[16];
354  uint8_t tmpbuf[16];
355  int index;
356 
357  if (!mxf->aesc && s->key && s->keylen == 16) {
358  mxf->aesc = av_aes_alloc();
359  if (!mxf->aesc)
360  return AVERROR(ENOMEM);
361  av_aes_init(mxf->aesc, s->key, 128, 1);
362  }
363  // crypto context
365  // plaintext offset
367  plaintext_size = avio_rb64(pb);
368  // source klv key
370  avio_read(pb, klv->key, 16);
372  return AVERROR_INVALIDDATA;
373  index = mxf_get_stream_index(s, klv);
374  if (index < 0)
375  return AVERROR_INVALIDDATA;
376  // source size
378  orig_size = avio_rb64(pb);
379  if (orig_size < plaintext_size)
380  return AVERROR_INVALIDDATA;
381  // enc. code
382  size = klv_decode_ber_length(pb);
383  if (size < 32 || size - 32 < orig_size)
384  return AVERROR_INVALIDDATA;
385  avio_read(pb, ivec, 16);
386  avio_read(pb, tmpbuf, 16);
387  if (mxf->aesc)
388  av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
389  if (memcmp(tmpbuf, checkv, 16))
390  av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
391  size -= 32;
392  size = av_get_packet(pb, pkt, size);
393  if (size < 0)
394  return size;
395  else if (size < plaintext_size)
396  return AVERROR_INVALIDDATA;
397  size -= plaintext_size;
398  if (mxf->aesc)
399  av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
400  &pkt->data[plaintext_size], size >> 4, ivec, 1);
401  av_shrink_packet(pkt, orig_size);
402  pkt->stream_index = index;
403  avio_skip(pb, end - avio_tell(pb));
404  return 0;
405 }
406 
407 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
408 {
409  MXFContext *mxf = arg;
410  int item_num = avio_rb32(pb);
411  int item_len = avio_rb32(pb);
412 
413  if (item_len != 18) {
414  av_log_ask_for_sample(pb, "unsupported primer pack item length %d\n",
415  item_len);
416  return AVERROR_PATCHWELCOME;
417  }
418  if (item_num > 65536) {
419  av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
420  return AVERROR_INVALIDDATA;
421  }
422  mxf->local_tags = av_calloc(item_num, item_len);
423  if (!mxf->local_tags)
424  return AVERROR(ENOMEM);
425  mxf->local_tags_count = item_num;
426  avio_read(pb, mxf->local_tags, item_num*item_len);
427  return 0;
428 }
429 
430 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
431 {
432  MXFContext *mxf = arg;
433  MXFPartition *partition, *tmp_part;
434  UID op;
435  uint64_t footer_partition;
436  uint32_t nb_essence_containers;
437 
438  if (mxf->partitions_count+1 >= UINT_MAX / sizeof(*mxf->partitions))
439  return AVERROR(ENOMEM);
440 
441  tmp_part = av_realloc(mxf->partitions, (mxf->partitions_count + 1) * sizeof(*mxf->partitions));
442  if (!tmp_part)
443  return AVERROR(ENOMEM);
444  mxf->partitions = tmp_part;
445 
446  if (mxf->parsing_backward) {
447  /* insert the new partition pack in the middle
448  * this makes the entries in mxf->partitions sorted by offset */
449  memmove(&mxf->partitions[mxf->last_forward_partition+1],
451  (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
452  partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
453  } else {
454  mxf->last_forward_partition++;
455  partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
456  }
457 
458  memset(partition, 0, sizeof(*partition));
459  mxf->partitions_count++;
460  partition->pack_length = avio_tell(pb) - klv_offset + size;
461 
462  switch(uid[13]) {
463  case 2:
464  partition->type = Header;
465  break;
466  case 3:
467  partition->type = BodyPartition;
468  break;
469  case 4:
470  partition->type = Footer;
471  break;
472  default:
473  av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
474  return AVERROR_INVALIDDATA;
475  }
476 
477  /* consider both footers to be closed (there is only Footer and CompleteFooter) */
478  partition->closed = partition->type == Footer || !(uid[14] & 1);
479  partition->complete = uid[14] > 2;
480  avio_skip(pb, 4);
481  partition->kag_size = avio_rb32(pb);
482  partition->this_partition = avio_rb64(pb);
483  partition->previous_partition = avio_rb64(pb);
484  footer_partition = avio_rb64(pb);
485  partition->header_byte_count = avio_rb64(pb);
486  partition->index_byte_count = avio_rb64(pb);
487  partition->index_sid = avio_rb32(pb);
488  avio_skip(pb, 8);
489  partition->body_sid = avio_rb32(pb);
490  avio_read(pb, op, sizeof(UID));
491  nb_essence_containers = avio_rb32(pb);
492 
493  /* some files don'thave FooterPartition set in every partition */
494  if (footer_partition) {
495  if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
496  av_log(mxf->fc, AV_LOG_ERROR,
497  "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
498  mxf->footer_partition, footer_partition);
499  } else {
500  mxf->footer_partition = footer_partition;
501  }
502  }
503 
504  av_dlog(mxf->fc,
505  "PartitionPack: ThisPartition = 0x%"PRIX64
506  ", PreviousPartition = 0x%"PRIX64", "
507  "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
508  partition->this_partition,
509  partition->previous_partition, footer_partition,
510  partition->index_sid, partition->body_sid);
511 
512  /* sanity check PreviousPartition if set */
513  if (partition->previous_partition &&
514  mxf->run_in + partition->previous_partition >= klv_offset) {
515  av_log(mxf->fc, AV_LOG_ERROR,
516  "PreviousPartition points to this partition or forward\n");
517  return AVERROR_INVALIDDATA;
518  }
519 
520  if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
521  else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
522  else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
523  else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
524  else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
525  else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
526  else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
527  else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
528  else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
529  else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
530  else if (op[12] == 0x10) {
531  /* SMPTE 390m: "There shall be exactly one essence container"
532  * The following block deals with files that violate this, namely:
533  * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
534  * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
535  if (nb_essence_containers != 1) {
536  MXFOP op = nb_essence_containers ? OP1a : OPAtom;
537 
538  /* only nag once */
539  if (!mxf->op)
540  av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
541  nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
542 
543  mxf->op = op;
544  } else
545  mxf->op = OPAtom;
546  } else {
547  av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
548  mxf->op = OP1a;
549  }
550 
551  if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
552  av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
553 
554  if (mxf->op == OPSONYOpt)
555  partition->kag_size = 512;
556  else
557  partition->kag_size = 1;
558 
559  av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
560  }
561 
562  return 0;
563 }
564 
565 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
566 {
567  MXFMetadataSet **tmp;
568  if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets))
569  return AVERROR(ENOMEM);
570  tmp = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets));
571  if (!tmp)
572  return AVERROR(ENOMEM);
573  mxf->metadata_sets = tmp;
574  mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
575  mxf->metadata_sets_count++;
576  return 0;
577 }
578 
579 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
580 {
581  MXFCryptoContext *cryptocontext = arg;
582  if (size != 16)
583  return AVERROR_INVALIDDATA;
585  avio_read(pb, cryptocontext->source_container_ul, 16);
586  return 0;
587 }
588 
589 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
590 {
591  MXFContext *mxf = arg;
592  switch (tag) {
593  case 0x1901:
594  mxf->packages_count = avio_rb32(pb);
595  mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
596  if (!mxf->packages_refs)
597  return AVERROR(ENOMEM);
598  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
599  avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
600  break;
601  }
602  return 0;
603 }
604 
605 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
606 {
607  MXFStructuralComponent *source_clip = arg;
608  switch(tag) {
609  case 0x0202:
610  source_clip->duration = avio_rb64(pb);
611  break;
612  case 0x1201:
613  source_clip->start_position = avio_rb64(pb);
614  break;
615  case 0x1101:
616  /* UMID, only get last 16 bytes */
617  avio_skip(pb, 16);
618  avio_read(pb, source_clip->source_package_uid, 16);
619  break;
620  case 0x1102:
621  source_clip->source_track_id = avio_rb32(pb);
622  break;
623  }
624  return 0;
625 }
626 
627 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
628 {
629  MXFPackage *package = arg;
630  switch(tag) {
631  case 0x4403:
632  package->tracks_count = avio_rb32(pb);
633  package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
634  if (!package->tracks_refs)
635  return AVERROR(ENOMEM);
636  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
637  avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
638  break;
639  }
640  return 0;
641 }
642 
643 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
644 {
645  MXFTimecodeComponent *mxf_timecode = arg;
646  switch(tag) {
647  case 0x1501:
648  mxf_timecode->start_frame = avio_rb64(pb);
649  break;
650  case 0x1502:
651  mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
652  break;
653  case 0x1503:
654  mxf_timecode->drop_frame = avio_r8(pb);
655  break;
656  }
657  return 0;
658 }
659 
660 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
661 {
662  MXFTrack *track = arg;
663  switch(tag) {
664  case 0x4801:
665  track->track_id = avio_rb32(pb);
666  break;
667  case 0x4804:
668  avio_read(pb, track->track_number, 4);
669  break;
670  case 0x4B01:
671  track->edit_rate.num = avio_rb32(pb);
672  track->edit_rate.den = avio_rb32(pb);
673  break;
674  case 0x4803:
675  avio_read(pb, track->sequence_ref, 16);
676  break;
677  }
678  return 0;
679 }
680 
681 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
682 {
683  MXFSequence *sequence = arg;
684  switch(tag) {
685  case 0x0202:
686  sequence->duration = avio_rb64(pb);
687  break;
688  case 0x0201:
689  avio_read(pb, sequence->data_definition_ul, 16);
690  break;
691  case 0x1001:
692  sequence->structural_components_count = avio_rb32(pb);
694  if (!sequence->structural_components_refs)
695  return AVERROR(ENOMEM);
696  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
697  avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
698  break;
699  }
700  return 0;
701 }
702 
703 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
704 {
705  MXFPackage *package = arg;
706  switch(tag) {
707  case 0x4403:
708  package->tracks_count = avio_rb32(pb);
709  package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
710  if (!package->tracks_refs)
711  return AVERROR(ENOMEM);
712  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
713  avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
714  break;
715  case 0x4401:
716  /* UMID, only get last 16 bytes */
717  avio_skip(pb, 16);
718  avio_read(pb, package->package_uid, 16);
719  break;
720  case 0x4701:
721  avio_read(pb, package->descriptor_ref, 16);
722  break;
723  }
724  return 0;
725 }
726 
728 {
729  int i, length;
730 
731  segment->nb_index_entries = avio_rb32(pb);
732 
733  length = avio_rb32(pb);
734 
735  if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
736  !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
737  !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
738  return AVERROR(ENOMEM);
739 
740  for (i = 0; i < segment->nb_index_entries; i++) {
741  segment->temporal_offset_entries[i] = avio_r8(pb);
742  avio_r8(pb); /* KeyFrameOffset */
743  segment->flag_entries[i] = avio_r8(pb);
744  segment->stream_offset_entries[i] = avio_rb64(pb);
745  avio_skip(pb, length - 11);
746  }
747  return 0;
748 }
749 
750 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
751 {
753  switch(tag) {
754  case 0x3F05:
755  segment->edit_unit_byte_count = avio_rb32(pb);
756  av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
757  break;
758  case 0x3F06:
759  segment->index_sid = avio_rb32(pb);
760  av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
761  break;
762  case 0x3F07:
763  segment->body_sid = avio_rb32(pb);
764  av_dlog(NULL, "BodySID %d\n", segment->body_sid);
765  break;
766  case 0x3F0A:
767  av_dlog(NULL, "IndexEntryArray found\n");
768  return mxf_read_index_entry_array(pb, segment);
769  case 0x3F0B:
770  segment->index_edit_rate.num = avio_rb32(pb);
771  segment->index_edit_rate.den = avio_rb32(pb);
772  av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
773  segment->index_edit_rate.den);
774  break;
775  case 0x3F0C:
776  segment->index_start_position = avio_rb64(pb);
777  av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
778  break;
779  case 0x3F0D:
780  segment->index_duration = avio_rb64(pb);
781  av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
782  break;
783  }
784  return 0;
785 }
786 
787 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
788 {
789  int code, value, ofs = 0;
790  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
791 
792  do {
793  code = avio_r8(pb);
794  value = avio_r8(pb);
795  av_dlog(NULL, "pixel layout: code %#x\n", code);
796 
797  if (ofs <= 14) {
798  layout[ofs++] = code;
799  layout[ofs++] = value;
800  } else
801  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
802  } while (code != 0); /* SMPTE 377M E.2.46 */
803 
804  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
805 }
806 
807 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
808 {
809  MXFDescriptor *descriptor = arg;
810  descriptor->pix_fmt = AV_PIX_FMT_NONE;
811  switch(tag) {
812  case 0x3F01:
813  descriptor->sub_descriptors_count = avio_rb32(pb);
814  descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
815  if (!descriptor->sub_descriptors_refs)
816  return AVERROR(ENOMEM);
817  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
818  avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
819  break;
820  case 0x3004:
821  avio_read(pb, descriptor->essence_container_ul, 16);
822  break;
823  case 0x3006:
824  descriptor->linked_track_id = avio_rb32(pb);
825  break;
826  case 0x3201: /* PictureEssenceCoding */
827  avio_read(pb, descriptor->essence_codec_ul, 16);
828  break;
829  case 0x3203:
830  descriptor->width = avio_rb32(pb);
831  break;
832  case 0x3202:
833  descriptor->height = avio_rb32(pb);
834  break;
835  case 0x320C:
836  descriptor->frame_layout = avio_r8(pb);
837  break;
838  case 0x320E:
839  descriptor->aspect_ratio.num = avio_rb32(pb);
840  descriptor->aspect_ratio.den = avio_rb32(pb);
841  break;
842  case 0x3301:
843  descriptor->component_depth = avio_rb32(pb);
844  break;
845  case 0x3302:
846  descriptor->horiz_subsampling = avio_rb32(pb);
847  break;
848  case 0x3308:
849  descriptor->vert_subsampling = avio_rb32(pb);
850  break;
851  case 0x3D03:
852  descriptor->sample_rate.num = avio_rb32(pb);
853  descriptor->sample_rate.den = avio_rb32(pb);
854  break;
855  case 0x3D06: /* SoundEssenceCompression */
856  avio_read(pb, descriptor->essence_codec_ul, 16);
857  break;
858  case 0x3D07:
859  descriptor->channels = avio_rb32(pb);
860  break;
861  case 0x3D01:
862  descriptor->bits_per_sample = avio_rb32(pb);
863  break;
864  case 0x3401:
865  mxf_read_pixel_layout(pb, descriptor);
866  break;
867  default:
868  /* Private uid used by SONY C0023S01.mxf */
870  if (descriptor->extradata)
871  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
872  av_free(descriptor->extradata);
873  descriptor->extradata_size = 0;
874  descriptor->extradata = av_malloc(size);
875  if (!descriptor->extradata)
876  return AVERROR(ENOMEM);
877  descriptor->extradata_size = size;
878  avio_read(pb, descriptor->extradata, size);
879  }
880  break;
881  }
882  return 0;
883 }
884 
885 /*
886  * Match an uid independently of the version byte and up to len common bytes
887  * Returns: boolean
888  */
889 static int mxf_match_uid(const UID key, const UID uid, int len)
890 {
891  int i;
892  for (i = 0; i < len; i++) {
893  if (i != 7 && key[i] != uid[i])
894  return 0;
895  }
896  return 1;
897 }
898 
899 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
900 {
901  while (uls->uid[0]) {
902  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
903  break;
904  uls++;
905  }
906  return uls;
907 }
908 
909 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
910 {
911  int i;
912 
913  if (!strong_ref)
914  return NULL;
915  for (i = 0; i < mxf->metadata_sets_count; i++) {
916  if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
917  (type == AnyType || mxf->metadata_sets[i]->type == type)) {
918  return mxf->metadata_sets[i];
919  }
920  }
921  return NULL;
922 }
923 
925  // video essence container uls
926  { { 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 */
927  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
928  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
929  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
930 };
931 
932 /* EC ULs for intra-only formats */
934  { { 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 */
935  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
936 };
937 
938 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
940  { { 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 */
941  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
942 };
943 
945  // sound essence container uls
946  { { 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 */
947  { { 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 */
948  { { 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 */
949  { { 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 */
950  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
951 };
952 
953 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
954 {
955  int i, j, nb_segments = 0;
956  MXFIndexTableSegment **unsorted_segments;
957  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
958 
959  /* count number of segments, allocate arrays and copy unsorted segments */
960  for (i = 0; i < mxf->metadata_sets_count; i++)
961  if (mxf->metadata_sets[i]->type == IndexTableSegment)
962  nb_segments++;
963 
964  if (!nb_segments)
965  return AVERROR_INVALIDDATA;
966 
967  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
968  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
969  av_freep(sorted_segments);
970  av_free(unsorted_segments);
971  return AVERROR(ENOMEM);
972  }
973 
974  for (i = j = 0; i < mxf->metadata_sets_count; i++)
975  if (mxf->metadata_sets[i]->type == IndexTableSegment)
976  unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
977 
978  *nb_sorted_segments = 0;
979 
980  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
981  for (i = 0; i < nb_segments; i++) {
982  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
983  uint64_t best_index_duration = 0;
984 
985  for (j = 0; j < nb_segments; j++) {
986  MXFIndexTableSegment *s = unsorted_segments[j];
987 
988  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
989  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
990  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
991  */
992  if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
993  (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
994  (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
995  best = j;
996  best_body_sid = s->body_sid;
997  best_index_sid = s->index_sid;
998  best_index_start = s->index_start_position;
999  best_index_duration = s->index_duration;
1000  }
1001  }
1002 
1003  /* no suitable entry found -> we're done */
1004  if (best == -1)
1005  break;
1006 
1007  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1008  last_body_sid = best_body_sid;
1009  last_index_sid = best_index_sid;
1010  last_index_start = best_index_start;
1011  }
1012 
1013  av_free(unsorted_segments);
1014 
1015  return 0;
1016 }
1017 
1021 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1022 {
1023  int x;
1024  int64_t offset_in = offset; /* for logging */
1025 
1026  for (x = 0; x < mxf->partitions_count; x++) {
1027  MXFPartition *p = &mxf->partitions[x];
1028 
1029  if (p->body_sid != body_sid)
1030  continue;
1031 
1032  if (offset < p->essence_length || !p->essence_length) {
1033  *offset_out = p->essence_offset + offset;
1034  return 0;
1035  }
1036 
1037  offset -= p->essence_length;
1038  }
1039 
1040  av_log(mxf->fc, AV_LOG_ERROR,
1041  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1042  offset_in, body_sid);
1043 
1044  return AVERROR_INVALIDDATA;
1045 }
1046 
1050 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1051 {
1052  int x;
1053  int64_t ret = 0;
1054 
1055  for (x = 0; x < mxf->partitions_count; x++) {
1056  MXFPartition *p = &mxf->partitions[x];
1057 
1058  if (p->body_sid != body_sid)
1059  continue;
1060 
1061  if (!p->essence_length)
1062  return 0;
1063 
1064  ret = p->essence_offset + p->essence_length;
1065  }
1066 
1067  return ret;
1068 }
1069 
1070 /* EditUnit -> absolute offset */
1071 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)
1072 {
1073  int i;
1074  int64_t offset_temp = 0;
1075 
1076  for (i = 0; i < index_table->nb_segments; i++) {
1077  MXFIndexTableSegment *s = index_table->segments[i];
1078 
1079  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1080 
1081  if (edit_unit < s->index_start_position + s->index_duration) {
1082  int64_t index = edit_unit - s->index_start_position;
1083 
1084  if (s->edit_unit_byte_count)
1085  offset_temp += s->edit_unit_byte_count * index;
1086  else if (s->nb_index_entries) {
1087  if (s->nb_index_entries == 2 * s->index_duration + 1)
1088  index *= 2; /* Avid index */
1089 
1090  if (index < 0 || index >= s->nb_index_entries) {
1091  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1092  index_table->index_sid, s->index_start_position);
1093  return AVERROR_INVALIDDATA;
1094  }
1095 
1096  offset_temp = s->stream_offset_entries[index];
1097  } else {
1098  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1099  index_table->index_sid, s->index_start_position);
1100  return AVERROR_INVALIDDATA;
1101  }
1102 
1103  if (edit_unit_out)
1104  *edit_unit_out = edit_unit;
1105 
1106  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1107  } else {
1108  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1109  offset_temp += s->edit_unit_byte_count * s->index_duration;
1110  }
1111  }
1112 
1113  if (nag)
1114  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);
1115 
1116  return AVERROR_INVALIDDATA;
1117 }
1118 
1120 {
1121  int i, j, x;
1122  int8_t max_temporal_offset = -128;
1123 
1124  /* first compute how many entries we have */
1125  for (i = 0; i < index_table->nb_segments; i++) {
1126  MXFIndexTableSegment *s = index_table->segments[i];
1127 
1128  if (!s->nb_index_entries) {
1129  index_table->nb_ptses = 0;
1130  return 0; /* no TemporalOffsets */
1131  }
1132 
1133  index_table->nb_ptses += s->index_duration;
1134  }
1135 
1136  /* paranoid check */
1137  if (index_table->nb_ptses <= 0)
1138  return 0;
1139 
1140  if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1141  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1142  av_freep(&index_table->ptses);
1143  return AVERROR(ENOMEM);
1144  }
1145 
1146  /* we may have a few bad TemporalOffsets
1147  * make sure the corresponding PTSes don't have the bogus value 0 */
1148  for (x = 0; x < index_table->nb_ptses; x++)
1149  index_table->ptses[x] = AV_NOPTS_VALUE;
1150 
1178  for (i = x = 0; i < index_table->nb_segments; i++) {
1179  MXFIndexTableSegment *s = index_table->segments[i];
1180  int index_delta = 1;
1181  int n = s->nb_index_entries;
1182 
1183  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1184  index_delta = 2; /* Avid index */
1185  /* ignore the last entry - it's the size of the essence container */
1186  n--;
1187  }
1188 
1189  for (j = 0; j < n; j += index_delta, x++) {
1190  int offset = s->temporal_offset_entries[j] / index_delta;
1191  int index = x + offset;
1192 
1193  if (x >= index_table->nb_ptses) {
1194  av_log(mxf->fc, AV_LOG_ERROR,
1195  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1197  break;
1198  }
1199 
1200  index_table->fake_index[x].timestamp = x;
1201  index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1202 
1203  if (index < 0 || index >= index_table->nb_ptses) {
1204  av_log(mxf->fc, AV_LOG_ERROR,
1205  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1206  x, offset, index);
1207  continue;
1208  }
1209 
1210  index_table->ptses[index] = x;
1211  max_temporal_offset = FFMAX(max_temporal_offset, offset);
1212  }
1213  }
1214 
1215  index_table->first_dts = -max_temporal_offset;
1216 
1217  return 0;
1218 }
1219 
1225 {
1226  int i, j, k, ret, nb_sorted_segments;
1227  MXFIndexTableSegment **sorted_segments = NULL;
1228 
1229  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1230  nb_sorted_segments <= 0) {
1231  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1232  return 0;
1233  }
1234 
1235  /* sanity check and count unique BodySIDs/IndexSIDs */
1236  for (i = 0; i < nb_sorted_segments; i++) {
1237  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1238  mxf->nb_index_tables++;
1239  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1240  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1241  ret = AVERROR_INVALIDDATA;
1242  goto finish_decoding_index;
1243  }
1244  }
1245 
1246  if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
1247  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1248  ret = AVERROR(ENOMEM);
1249  goto finish_decoding_index;
1250  }
1251 
1252  /* distribute sorted segments to index tables */
1253  for (i = j = 0; i < nb_sorted_segments; i++) {
1254  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1255  /* next IndexSID */
1256  j++;
1257  }
1258 
1259  mxf->index_tables[j].nb_segments++;
1260  }
1261 
1262  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1263  MXFIndexTable *t = &mxf->index_tables[j];
1264 
1265  if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
1266  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
1267  ret = AVERROR(ENOMEM);
1268  goto finish_decoding_index;
1269  }
1270 
1271  if (sorted_segments[i]->index_start_position)
1272  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1273  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1274 
1275  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1276  t->index_sid = sorted_segments[i]->index_sid;
1277  t->body_sid = sorted_segments[i]->body_sid;
1278 
1279  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1280  goto finish_decoding_index;
1281 
1282  /* fix zero IndexDurations */
1283  for (k = 0; k < t->nb_segments; k++) {
1284  if (t->segments[k]->index_duration)
1285  continue;
1286 
1287  if (t->nb_segments > 1)
1288  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1289  t->index_sid, k);
1290 
1291  if (mxf->fc->nb_streams <= 0) {
1292  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1293  break;
1294  }
1295 
1296  /* assume the first stream's duration is reasonable
1297  * leave index_duration = 0 on further segments in case we have any (unlikely)
1298  */
1299  t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1300  break;
1301  }
1302  }
1303 
1304  ret = 0;
1305 finish_decoding_index:
1306  av_free(sorted_segments);
1307  return ret;
1308 }
1309 
1310 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1311 {
1312  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1313  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1314  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1315  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1316 }
1317 
1318 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1319 {
1320  char buf[AV_TIMECODE_STR_SIZE];
1321  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1322 
1323  return 0;
1324 }
1325 
1327 {
1328  MXFPackage *material_package = NULL;
1329  MXFPackage *temp_package = NULL;
1330  int i, j, k, ret;
1331 
1332  av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1333  /* TODO: handle multiple material packages (OP3x) */
1334  for (i = 0; i < mxf->packages_count; i++) {
1335  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1336  if (material_package) break;
1337  }
1338  if (!material_package) {
1339  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1340  return AVERROR_INVALIDDATA;
1341  }
1342 
1343  for (i = 0; i < material_package->tracks_count; i++) {
1344  MXFPackage *source_package = NULL;
1345  MXFTrack *material_track = NULL;
1346  MXFTrack *source_track = NULL;
1347  MXFTrack *temp_track = NULL;
1348  MXFDescriptor *descriptor = NULL;
1349  MXFStructuralComponent *component = NULL;
1350  MXFTimecodeComponent *mxf_tc = NULL;
1351  UID *essence_container_ul = NULL;
1352  const MXFCodecUL *codec_ul = NULL;
1353  const MXFCodecUL *container_ul = NULL;
1354  const MXFCodecUL *pix_fmt_ul = NULL;
1355  AVStream *st;
1356  AVTimecode tc;
1357  int flags;
1358 
1359  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1360  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1361  continue;
1362  }
1363 
1364  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1365  mxf_tc = (MXFTimecodeComponent*)component;
1366  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1367  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1368  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1369  }
1370  }
1371 
1372  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1373  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1374  continue;
1375  }
1376 
1377  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1378  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1379  if (!component)
1380  continue;
1381 
1382  mxf_tc = (MXFTimecodeComponent*)component;
1383  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1384  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1385  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1386  break;
1387  }
1388  }
1389 
1390  /* TODO: handle multiple source clips */
1391  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1392  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1393  if (!component)
1394  continue;
1395 
1396  for (k = 0; k < mxf->packages_count; k++) {
1397  temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1398  if (!temp_package)
1399  continue;
1400  if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1401  source_package = temp_package;
1402  break;
1403  }
1404  }
1405  if (!source_package) {
1406  av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1407  break;
1408  }
1409  for (k = 0; k < source_package->tracks_count; k++) {
1410  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1411  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1412  ret = AVERROR_INVALIDDATA;
1413  goto fail_and_free;
1414  }
1415  if (temp_track->track_id == component->source_track_id) {
1416  source_track = temp_track;
1417  break;
1418  }
1419  }
1420  if (!source_track) {
1421  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1422  break;
1423  }
1424  }
1425  if (!source_track || !component)
1426  continue;
1427 
1428  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1429  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1430  ret = AVERROR_INVALIDDATA;
1431  goto fail_and_free;
1432  }
1433 
1434  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1435  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1436  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1437  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1438  continue;
1439  }
1440 
1441  st = avformat_new_stream(mxf->fc, NULL);
1442  if (!st) {
1443  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1444  ret = AVERROR(ENOMEM);
1445  goto fail_and_free;
1446  }
1447  st->id = source_track->track_id;
1448  st->priv_data = source_track;
1449  source_track->original_duration = st->duration = component->duration;
1450  if (st->duration == -1)
1451  st->duration = AV_NOPTS_VALUE;
1452  st->start_time = component->start_position;
1453  if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
1454  av_log(mxf->fc, AV_LOG_WARNING,
1455  "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1456  material_track->edit_rate.num, material_track->edit_rate.den, st->index);
1457  material_track->edit_rate = (AVRational){25, 1};
1458  }
1459  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1460 
1461  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
1462  source_track->edit_rate = material_track->edit_rate;
1463 
1464  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1466  st->codec->codec_type = codec_ul->id;
1467 
1468  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1469  if (source_package->descriptor) {
1470  if (source_package->descriptor->type == MultipleDescriptor) {
1471  for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1472  MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1473 
1474  if (!sub_descriptor) {
1475  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1476  continue;
1477  }
1478  if (sub_descriptor->linked_track_id == source_track->track_id) {
1479  descriptor = sub_descriptor;
1480  break;
1481  }
1482  }
1483  } else if (source_package->descriptor->type == Descriptor)
1484  descriptor = source_package->descriptor;
1485  }
1486  if (!descriptor) {
1487  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1488  continue;
1489  }
1490  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1491  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1492  essence_container_ul = &descriptor->essence_container_ul;
1493  /* HACK: replacing the original key with mxf_encrypted_essence_container
1494  * is not allowed according to s429-6, try to find correct information anyway */
1495  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1496  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1497  for (k = 0; k < mxf->metadata_sets_count; k++) {
1498  MXFMetadataSet *metadata = mxf->metadata_sets[k];
1499  if (metadata->type == CryptoContext) {
1500  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1501  break;
1502  }
1503  }
1504  }
1505 
1506  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1507  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1508  st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1509  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1511  for (k = 0; k < 16; k++) {
1512  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1513  descriptor->essence_codec_ul[k]);
1514  if (!(k+1 & 19) || k == 5)
1515  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1516  }
1517  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1518  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1519  source_track->intra_only = mxf_is_intra_only(descriptor);
1520  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1521  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1522  st->codec->codec_id = container_ul->id;
1523  st->codec->width = descriptor->width;
1524  st->codec->height = descriptor->height; /* Field height, not frame height */
1525  switch (descriptor->frame_layout) {
1526  case SegmentedFrame:
1527  /* This one is a weird layout I don't fully understand. */
1528  av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1529  break;
1530  case FullFrame:
1532  break;
1533  case OneField:
1534  /* Every other line is stored and needs to be duplicated. */
1535  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1536  break; /* The correct thing to do here is fall through, but by breaking we might be
1537  able to decode some streams at half the vertical resolution, rather than not al all.
1538  It's also for compatibility with the old behavior. */
1539  case MixedFields:
1540  break;
1541  case SeparateFields:
1542  st->codec->height *= 2; /* Turn field height into frame height. */
1543  break;
1544  default:
1545  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1546  }
1547  if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1548  st->codec->pix_fmt = descriptor->pix_fmt;
1549  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1551  &descriptor->essence_codec_ul);
1552  st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1553  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1554  /* support files created before RP224v10 by defaulting to UYVY422
1555  if subsampling is 4:2:2 and component depth is 8-bit */
1556  if (descriptor->horiz_subsampling == 2 &&
1557  descriptor->vert_subsampling == 1 &&
1558  descriptor->component_depth == 8) {
1560  }
1561  }
1562  }
1563  }
1565  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1566  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1567  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1568  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))
1569  st->codec->codec_id = (enum AVCodecID)container_ul->id;
1570  st->codec->channels = descriptor->channels;
1571  st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1572 
1573  if (descriptor->sample_rate.den > 0) {
1574  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1575  st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1576  } else {
1577  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) found for stream #%d, time base forced to 1/48000\n",
1578  descriptor->sample_rate.num, descriptor->sample_rate.den, st->index);
1579  avpriv_set_pts_info(st, 64, 1, 48000);
1580  }
1581 
1582  /* if duration is set, rescale it from EditRate to SampleRate */
1583  if (st->duration != AV_NOPTS_VALUE)
1584  st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1585 
1586  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1587  if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1588  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1590  else if (descriptor->bits_per_sample == 32)
1592  } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1593  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1595  else if (descriptor->bits_per_sample == 32)
1597  } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1599  }
1600  }
1601  if (descriptor->extradata) {
1603  if (st->codec->extradata) {
1604  memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1605  st->codec->extradata_size = descriptor->extradata_size;
1606  }
1607  } else if(st->codec->codec_id == CODEC_ID_H264) {
1609  }
1610  if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1611  /* TODO: decode timestamps */
1613  }
1614  }
1615 
1616  ret = 0;
1617 fail_and_free:
1618  return ret;
1619 }
1620 
1622  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1623  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1624  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1625  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1626  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1627  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1628  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1629  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1630  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1631  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1632  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1633  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1634  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1635  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1636  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1637  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1638  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1639  { { 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 */
1640  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1641  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1642  { { 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 */
1643  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1644  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1645  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1646  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1647  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1648  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1649  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1650  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1651 };
1652 
1653 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1654 {
1655  AVIOContext *pb = mxf->fc->pb;
1656  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1657  uint64_t klv_end = avio_tell(pb) + klv->length;
1658 
1659  if (!ctx)
1660  return AVERROR(ENOMEM);
1661  while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1662  int ret;
1663  int tag = avio_rb16(pb);
1664  int size = avio_rb16(pb); /* KLV specified by 0x53 */
1665  uint64_t next = avio_tell(pb) + size;
1666  UID uid = {0};
1667 
1668  av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1669  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1670  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1671  continue;
1672  }
1673  if (tag > 0x7FFF) { /* dynamic tag */
1674  int i;
1675  for (i = 0; i < mxf->local_tags_count; i++) {
1676  int local_tag = AV_RB16(mxf->local_tags+i*18);
1677  if (local_tag == tag) {
1678  memcpy(uid, mxf->local_tags+i*18+2, 16);
1679  av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1680  PRINT_KEY(mxf->fc, "uid", uid);
1681  }
1682  }
1683  }
1684  if (ctx_size && tag == 0x3C0A)
1685  avio_read(pb, ctx->uid, 16);
1686  else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1687  return ret;
1688 
1689  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1690  * it extending past the end of the KLV though (zzuf5.mxf). */
1691  if (avio_tell(pb) > klv_end) {
1692  if (ctx_size)
1693  av_free(ctx);
1694 
1695  av_log(mxf->fc, AV_LOG_ERROR,
1696  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1697  tag, klv->offset);
1698  return AVERROR_INVALIDDATA;
1699  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1700  avio_seek(pb, next, SEEK_SET);
1701  }
1702  if (ctx_size) ctx->type = type;
1703  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1704 }
1705 
1711 {
1712  AVIOContext *pb = mxf->fc->pb;
1713 
1714  if (!mxf->current_partition ||
1716  return 0; /* we've parsed all partitions */
1717 
1718  /* seek to previous partition */
1719  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1720  mxf->current_partition = NULL;
1721 
1722  av_dlog(mxf->fc, "seeking to previous partition\n");
1723 
1724  return 1;
1725 }
1726 
1732 {
1733  AVIOContext *pb = mxf->fc->pb;
1734  int64_t ret;
1735 
1736  if (mxf->parsing_backward) {
1737  return mxf_seek_to_previous_partition(mxf);
1738  } else {
1739  if (!mxf->footer_partition) {
1740  av_dlog(mxf->fc, "no footer\n");
1741  return 0;
1742  }
1743 
1744  av_dlog(mxf->fc, "seeking to footer\n");
1745 
1746  /* remember where we were so we don't end up seeking further back than this */
1747  mxf->last_forward_tell = avio_tell(pb);
1748 
1749  if (!pb->seekable) {
1750  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1751  return -1;
1752  }
1753 
1754  /* seek to footer partition and parse backward */
1755  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1756  av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1757  mxf->run_in + mxf->footer_partition, ret);
1758  return ret;
1759  }
1760 
1761  mxf->current_partition = NULL;
1762  mxf->parsing_backward = 1;
1763  }
1764 
1765  return 1;
1766 }
1767 
1773 {
1774  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1775 }
1776 
1781 {
1782  int x;
1783 
1784  /* everything is already correct */
1785  if (mxf->op == OPAtom)
1786  return;
1787 
1788  for (x = 0; x < mxf->partitions_count; x++) {
1789  MXFPartition *p = &mxf->partitions[x];
1790 
1791  if (!p->body_sid)
1792  continue; /* BodySID == 0 -> no essence */
1793 
1794  if (x >= mxf->partitions_count - 1)
1795  break; /* last partition - can't compute length (and we don't need to) */
1796 
1797  /* essence container spans to the next partition */
1799 
1800  if (p->essence_length < 0) {
1801  /* next ThisPartition < essence_offset */
1802  p->essence_length = 0;
1803  av_log(mxf->fc, AV_LOG_ERROR,
1804  "partition %i: bad ThisPartition = %"PRIX64"\n",
1805  x+1, mxf->partitions[x+1].this_partition);
1806  }
1807  }
1808 }
1809 
1810 static int64_t round_to_kag(int64_t position, int kag_size)
1811 {
1812  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1813  /* NOTE: kag_size may be any integer between 1 - 2^10 */
1814  int64_t ret = (position / kag_size) * kag_size;
1815  return ret == position ? ret : ret + kag_size;
1816 }
1817 
1818 static int is_pcm(enum AVCodecID codec_id)
1819 {
1820  /* we only care about "normal" PCM codecs until we get samples */
1821  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1822 }
1823 
1830 {
1831  MXFContext *mxf = s->priv_data;
1832 
1833  /* assuming non-OPAtom == frame wrapped
1834  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1835  if (mxf->op != OPAtom)
1836  return;
1837 
1838  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1839  if (s->nb_streams != 1 ||
1841  !is_pcm(s->streams[0]->codec->codec_id) ||
1842  mxf->nb_index_tables != 1 ||
1843  mxf->index_tables[0].nb_segments != 1 ||
1844  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1845  return;
1846 
1847  /* arbitrarily default to 48 kHz PAL audio frame size */
1848  /* TODO: We could compute this from the ratio between the audio
1849  * and video edit rates for 48 kHz NTSC we could use the
1850  * 1802-1802-1802-1802-1801 pattern. */
1851  mxf->edit_units_per_packet = 1920;
1852 }
1853 
1855 {
1856  MXFContext *mxf = s->priv_data;
1857  KLVPacket klv;
1858  int64_t essence_offset = 0;
1859  int64_t last_pos = -1;
1860  uint64_t last_pos_index = 1;
1861  int ret;
1862 
1863  mxf->last_forward_tell = INT64_MAX;
1864  mxf->edit_units_per_packet = 1;
1865 
1867  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1868  return AVERROR_INVALIDDATA;
1869  }
1870  avio_seek(s->pb, -14, SEEK_CUR);
1871  mxf->fc = s;
1872  mxf->run_in = avio_tell(s->pb);
1873 
1874  while (!url_feof(s->pb)) {
1875  const MXFMetadataReadTableEntry *metadata;
1876  if (avio_tell(s->pb) == last_pos) {
1877  av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
1878  return AVERROR_INVALIDDATA;
1879  }
1880  if ((1ULL<<61) % last_pos_index++ == 0)
1881  last_pos = avio_tell(s->pb);
1882  if (klv_read_packet(&klv, s->pb) < 0) {
1883  /* EOF - seek to previous partition or stop */
1884  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1885  break;
1886  else
1887  continue;
1888  }
1889 
1890  PRINT_KEY(s, "read header", klv.key);
1891  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
1896 
1897  if (!mxf->current_partition) {
1898  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
1899  return AVERROR_INVALIDDATA;
1900  }
1901 
1902  if (!mxf->current_partition->essence_offset) {
1903  /* for OP1a we compute essence_offset
1904  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
1905  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
1906  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
1907  */
1908  int64_t op1a_essence_offset =
1913 
1914  if (mxf->op == OPAtom) {
1915  /* point essence_offset to the actual data
1916  * OPAtom has all the essence in one big KLV
1917  */
1920  } else {
1921  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
1922  mxf->current_partition->essence_offset = op1a_essence_offset;
1923  }
1924  }
1925 
1926  if (!essence_offset)
1927  essence_offset = klv.offset;
1928 
1929  /* seek to footer, previous partition or stop */
1930  if (mxf_parse_handle_essence(mxf) <= 0)
1931  break;
1932  continue;
1933  } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
1934  klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
1935  /* next partition pack - keep going, seek to previous partition or stop */
1936  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1937  break;
1938  else if (mxf->parsing_backward)
1939  continue;
1940  /* we're still parsing forward. proceed to parsing this partition pack */
1941  }
1942 
1943  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
1944  if (IS_KLV_KEY(klv.key, metadata->key)) {
1945  int res;
1946  if (klv.key[5] == 0x53) {
1947  res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
1948  } else {
1949  uint64_t next = avio_tell(s->pb) + klv.length;
1950  res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
1951 
1952  /* only seek forward, else this can loop for a long time */
1953  if (avio_tell(s->pb) > next) {
1954  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
1955  klv.offset);
1956  return AVERROR_INVALIDDATA;
1957  }
1958 
1959  avio_seek(s->pb, next, SEEK_SET);
1960  }
1961  if (res < 0) {
1962  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
1963  return res;
1964  }
1965  break;
1966  }
1967  }
1968  if (!metadata->read)
1969  avio_skip(s->pb, klv.length);
1970  }
1971  /* FIXME avoid seek */
1972  if (!essence_offset) {
1973  av_log(s, AV_LOG_ERROR, "no essence\n");
1974  return AVERROR_INVALIDDATA;
1975  }
1976  avio_seek(s->pb, essence_offset, SEEK_SET);
1977 
1979 
1980  /* we need to do this before computing the index tables
1981  * to be able to fill in zero IndexDurations with st->duration */
1982  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
1983  goto fail;
1984 
1985  if ((ret = mxf_compute_index_tables(mxf)) < 0)
1986  goto fail;
1987 
1988  if (mxf->nb_index_tables > 1) {
1989  /* TODO: look up which IndexSID to use via EssenceContainerData */
1990  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
1991  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
1992  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
1993  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
1994  ret = AVERROR_INVALIDDATA;
1995  goto fail;
1996  }
1997 
1999 
2000  return 0;
2001 fail:
2002  mxf_read_close(s);
2003 
2004  return ret;
2005 }
2006 
2011 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2012 {
2013  int64_t last_ofs = -1, next_ofs = -1;
2014  MXFIndexTable *t = &mxf->index_tables[0];
2015 
2016  /* this is called from the OP1a demuxing logic, which means there
2017  * may be no index tables */
2018  if (mxf->nb_index_tables <= 0)
2019  return -1;
2020 
2021  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2022  while (mxf->current_edit_unit >= 0) {
2023  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2024  return -1;
2025 
2026  if (next_ofs <= last_ofs) {
2027  /* large next_ofs didn't change or current_edit_unit wrapped
2028  * around this fixes the infinite loop on zzuf3.mxf */
2029  av_log(mxf->fc, AV_LOG_ERROR,
2030  "next_ofs didn't change. not deriving packet timestamps\n");
2031  return -1;
2032  }
2033 
2034  if (next_ofs > current_offset)
2035  break;
2036 
2037  last_ofs = next_ofs;
2038  mxf->current_edit_unit++;
2039  }
2040 
2041  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2042  if (mxf->current_edit_unit < 0)
2043  return -1;
2044 
2045  return next_ofs;
2046 }
2047 
2048 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2049 {
2050  int i, total = 0, size = 0;
2051  AVStream *st = mxf->fc->streams[stream_index];
2052  MXFTrack *track = st->priv_data;
2053  AVRational time_base = av_inv_q(track->edit_rate);
2055  const MXFSamplesPerFrame *spf = NULL;
2056 
2057  if ((sample_rate.num / sample_rate.den) == 48000)
2058  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2059  if (!spf) {
2060  int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2061  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2062  av_mul_q(sample_rate, time_base)));
2063  if (remainder)
2064  av_log(mxf->fc, AV_LOG_WARNING,
2065  "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2066  stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2067  return 0;
2068  }
2069 
2070  while (spf->samples_per_frame[size]) {
2071  total += spf->samples_per_frame[size];
2072  size++;
2073  }
2074 
2075  av_assert2(size);
2076 
2077  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2078  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2079  *sample_count += spf->samples_per_frame[i];
2080  }
2081 
2082  return 0;
2083 }
2084 
2086 {
2087  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2088  pkt->pts = track->sample_count;
2089  if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
2090  return AVERROR(EINVAL);
2091  track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2092  return 0;
2093 }
2094 
2096 {
2097  KLVPacket klv;
2098  MXFContext *mxf = s->priv_data;
2099 
2100  while (!url_feof(s->pb)) {
2101  int ret;
2102  if (klv_read_packet(&klv, s->pb) < 0)
2103  return -1;
2104  PRINT_KEY(s, "read packet", klv.key);
2105  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2107  ret = mxf_decrypt_triplet(s, pkt, &klv);
2108  if (ret < 0) {
2109  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2110  return AVERROR_INVALIDDATA;
2111  }
2112  return 0;
2113  }
2116  int index = mxf_get_stream_index(s, &klv);
2117  int64_t next_ofs, next_klv;
2118  AVStream *st;
2119  MXFTrack *track;
2120  AVCodecContext *codec;
2121 
2122  if (index < 0) {
2123  av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2124  goto skip;
2125  }
2126 
2127  st = s->streams[index];
2128  track = st->priv_data;
2129 
2130  if (s->streams[index]->discard == AVDISCARD_ALL)
2131  goto skip;
2132 
2133  next_klv = avio_tell(s->pb) + klv.length;
2134  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2135 
2136  if (next_ofs >= 0 && next_klv > next_ofs) {
2137  /* if this check is hit then it's possible OPAtom was treated as OP1a
2138  * truncate the packet since it's probably very large (>2 GiB is common) */
2140  "KLV for edit unit %i extends into next edit unit - OPAtom misinterpreted as OP1a?\n",
2141  mxf->current_edit_unit);
2142  klv.length = next_ofs - avio_tell(s->pb);
2143  }
2144 
2145  /* check for 8 channels AES3 element */
2146  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2147  if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2148  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2149  return AVERROR_INVALIDDATA;
2150  }
2151  } else {
2152  ret = av_get_packet(s->pb, pkt, klv.length);
2153  if (ret < 0)
2154  return ret;
2155  }
2156  pkt->stream_index = index;
2157  pkt->pos = klv.offset;
2158 
2159  codec = s->streams[index]->codec;
2160  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2161  /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2162  MXFIndexTable *t = &mxf->index_tables[0];
2163 
2164  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2165  pkt->dts = mxf->current_edit_unit + t->first_dts;
2166  pkt->pts = t->ptses[mxf->current_edit_unit];
2167  } else if (track->intra_only) {
2168  /* intra-only -> PTS = EditUnit.
2169  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2170  pkt->pts = mxf->current_edit_unit;
2171  }
2172  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2173  int ret = mxf_set_audio_pts(mxf, codec, pkt);
2174  if (ret < 0)
2175  return ret;
2176  }
2177 
2178  /* seek for truncated packets */
2179  avio_seek(s->pb, next_klv, SEEK_SET);
2180 
2181  return 0;
2182  } else
2183  skip:
2184  avio_skip(s->pb, klv.length);
2185  }
2186  return AVERROR_EOF;
2187 }
2188 
2190 {
2191  MXFContext *mxf = s->priv_data;
2192  int ret, size;
2193  int64_t ret64, pos, next_pos;
2194  AVStream *st;
2195  MXFIndexTable *t;
2196  int edit_units;
2197 
2198  if (mxf->op != OPAtom)
2199  return mxf_read_packet_old(s, pkt);
2200 
2201  /* OPAtom - clip wrapped demuxing */
2202  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2203  st = s->streams[0];
2204  t = &mxf->index_tables[0];
2205 
2206  if (mxf->current_edit_unit >= st->duration)
2207  return AVERROR_EOF;
2208 
2209  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2210 
2211  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2212  return ret;
2213 
2214  /* compute size by finding the next edit unit or the end of the essence container
2215  * not pretty, but it works */
2216  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2217  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2218  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2219  return AVERROR_INVALIDDATA;
2220  }
2221 
2222  if ((size = next_pos - pos) <= 0) {
2223  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2224  return AVERROR_INVALIDDATA;
2225  }
2226 
2227  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2228  return ret64;
2229 
2230  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2231  return size;
2232 
2233  pkt->stream_index = 0;
2234 
2235  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2236  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2237  pkt->dts = mxf->current_edit_unit + t->first_dts;
2238  pkt->pts = t->ptses[mxf->current_edit_unit];
2239  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2240  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2241  if (ret < 0)
2242  return ret;
2243  }
2244 
2245  mxf->current_edit_unit += edit_units;
2246 
2247  return 0;
2248 }
2249 
2251 {
2252  MXFContext *mxf = s->priv_data;
2253  MXFIndexTableSegment *seg;
2254  int i;
2255 
2256  av_freep(&mxf->packages_refs);
2257 
2258  for (i = 0; i < s->nb_streams; i++)
2259  s->streams[i]->priv_data = NULL;
2260 
2261  for (i = 0; i < mxf->metadata_sets_count; i++) {
2262  switch (mxf->metadata_sets[i]->type) {
2263  case Descriptor:
2264  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2265  break;
2266  case MultipleDescriptor:
2267  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2268  break;
2269  case Sequence:
2270  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2271  break;
2272  case SourcePackage:
2273  case MaterialPackage:
2274  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2275  break;
2276  case IndexTableSegment:
2277  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2279  av_freep(&seg->flag_entries);
2281  break;
2282  default:
2283  break;
2284  }
2285  av_freep(&mxf->metadata_sets[i]);
2286  }
2287  av_freep(&mxf->partitions);
2288  av_freep(&mxf->metadata_sets);
2289  av_freep(&mxf->aesc);
2290  av_freep(&mxf->local_tags);
2291 
2292  if (mxf->index_tables) {
2293  for (i = 0; i < mxf->nb_index_tables; i++) {
2294  av_freep(&mxf->index_tables[i].segments);
2295  av_freep(&mxf->index_tables[i].ptses);
2296  av_freep(&mxf->index_tables[i].fake_index);
2297  }
2298  }
2299  av_freep(&mxf->index_tables);
2300 
2301  return 0;
2302 }
2303 
2304 static int mxf_probe(AVProbeData *p) {
2305  const uint8_t *bufp = p->buf;
2306  const uint8_t *end = p->buf + p->buf_size;
2307 
2308  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2309  return 0;
2310 
2311  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2312  end -= sizeof(mxf_header_partition_pack_key);
2313  for (; bufp < end; bufp++) {
2315  return AVPROBE_SCORE_MAX;
2316  }
2317  return 0;
2318 }
2319 
2320 /* rudimentary byte seek */
2321 /* XXX: use MXF Index */
2322 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2323 {
2324  AVStream *st = s->streams[stream_index];
2325  int64_t seconds;
2326  MXFContext* mxf = s->priv_data;
2327  int64_t seekpos;
2328  int i, ret;
2329  MXFIndexTable *t;
2330  MXFTrack *source_track = st->priv_data;
2331 
2332  /* if audio then truncate sample_time to EditRate */
2333  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2334  sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2335 
2336  if (mxf->nb_index_tables <= 0) {
2337  if (!s->bit_rate)
2338  return AVERROR_INVALIDDATA;
2339  if (sample_time < 0)
2340  sample_time = 0;
2341  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2342 
2343  if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2344  return ret;
2345  ff_update_cur_dts(s, st, sample_time);
2346  } else {
2347  t = &mxf->index_tables[0];
2348 
2349  /* clamp above zero, else ff_index_search_timestamp() returns negative
2350  * this also means we allow seeking before the start */
2351  sample_time = FFMAX(sample_time, 0);
2352 
2353  if (t->fake_index) {
2354  /* behave as if we have a proper index */
2355  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2356  return sample_time;
2357  } else {
2358  /* no IndexEntryArray (one or more CBR segments)
2359  * make sure we don't seek past the end */
2360  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2361  }
2362 
2363  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2364  return ret;
2365 
2366  ff_update_cur_dts(s, st, sample_time);
2367  mxf->current_edit_unit = sample_time;
2368  avio_seek(s->pb, seekpos, SEEK_SET);
2369  }
2370 
2371  // Update all tracks sample count
2372  for (i = 0; i < s->nb_streams; i++) {
2373  AVStream *cur_st = s->streams[i];
2374  MXFTrack *cur_track = cur_st->priv_data;
2375  uint64_t current_sample_count = 0;
2376  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2377  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2378  if (ret < 0)
2379  return ret;
2380 
2381  cur_track->sample_count = current_sample_count;
2382  }
2383  }
2384  return 0;
2385 }
2386 
2388  .name = "mxf",
2389  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2390  .priv_data_size = sizeof(MXFContext),
2391  .read_probe = mxf_probe,
2396 };