FFmpeg  1.2.4
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  int ret;
1860 
1861  mxf->last_forward_tell = INT64_MAX;
1862  mxf->edit_units_per_packet = 1;
1863 
1865  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1866  return AVERROR_INVALIDDATA;
1867  }
1868  avio_seek(s->pb, -14, SEEK_CUR);
1869  mxf->fc = s;
1870  mxf->run_in = avio_tell(s->pb);
1871 
1872  while (!url_feof(s->pb)) {
1873  const MXFMetadataReadTableEntry *metadata;
1874 
1875  if (klv_read_packet(&klv, s->pb) < 0) {
1876  /* EOF - seek to previous partition or stop */
1877  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1878  break;
1879  else
1880  continue;
1881  }
1882 
1883  PRINT_KEY(s, "read header", klv.key);
1884  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
1889 
1890  if (!mxf->current_partition) {
1891  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
1892  return AVERROR_INVALIDDATA;
1893  }
1894 
1895  if (!mxf->current_partition->essence_offset) {
1896  /* for OP1a we compute essence_offset
1897  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
1898  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
1899  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
1900  */
1901  int64_t op1a_essence_offset =
1906 
1907  if (mxf->op == OPAtom) {
1908  /* point essence_offset to the actual data
1909  * OPAtom has all the essence in one big KLV
1910  */
1913  } else {
1914  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
1915  mxf->current_partition->essence_offset = op1a_essence_offset;
1916  }
1917  }
1918 
1919  if (!essence_offset)
1920  essence_offset = klv.offset;
1921 
1922  /* seek to footer, previous partition or stop */
1923  if (mxf_parse_handle_essence(mxf) <= 0)
1924  break;
1925  continue;
1926  } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
1927  klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
1928  /* next partition pack - keep going, seek to previous partition or stop */
1929  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1930  break;
1931  else if (mxf->parsing_backward)
1932  continue;
1933  /* we're still parsing forward. proceed to parsing this partition pack */
1934  }
1935 
1936  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
1937  if (IS_KLV_KEY(klv.key, metadata->key)) {
1938  int res;
1939  if (klv.key[5] == 0x53) {
1940  res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
1941  } else {
1942  uint64_t next = avio_tell(s->pb) + klv.length;
1943  res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
1944 
1945  /* only seek forward, else this can loop for a long time */
1946  if (avio_tell(s->pb) > next) {
1947  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
1948  klv.offset);
1949  return AVERROR_INVALIDDATA;
1950  }
1951 
1952  avio_seek(s->pb, next, SEEK_SET);
1953  }
1954  if (res < 0) {
1955  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
1956  return res;
1957  }
1958  break;
1959  }
1960  }
1961  if (!metadata->read)
1962  avio_skip(s->pb, klv.length);
1963  }
1964  /* FIXME avoid seek */
1965  if (!essence_offset) {
1966  av_log(s, AV_LOG_ERROR, "no essence\n");
1967  return AVERROR_INVALIDDATA;
1968  }
1969  avio_seek(s->pb, essence_offset, SEEK_SET);
1970 
1972 
1973  /* we need to do this before computing the index tables
1974  * to be able to fill in zero IndexDurations with st->duration */
1975  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
1976  goto fail;
1977 
1978  if ((ret = mxf_compute_index_tables(mxf)) < 0)
1979  goto fail;
1980 
1981  if (mxf->nb_index_tables > 1) {
1982  /* TODO: look up which IndexSID to use via EssenceContainerData */
1983  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
1984  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
1985  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
1986  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
1987  ret = AVERROR_INVALIDDATA;
1988  goto fail;
1989  }
1990 
1992 
1993  return 0;
1994 fail:
1995  mxf_read_close(s);
1996 
1997  return ret;
1998 }
1999 
2004 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2005 {
2006  int64_t last_ofs = -1, next_ofs = -1;
2007  MXFIndexTable *t = &mxf->index_tables[0];
2008 
2009  /* this is called from the OP1a demuxing logic, which means there
2010  * may be no index tables */
2011  if (mxf->nb_index_tables <= 0)
2012  return -1;
2013 
2014  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2015  while (mxf->current_edit_unit >= 0) {
2016  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2017  return -1;
2018 
2019  if (next_ofs <= last_ofs) {
2020  /* large next_ofs didn't change or current_edit_unit wrapped
2021  * around this fixes the infinite loop on zzuf3.mxf */
2022  av_log(mxf->fc, AV_LOG_ERROR,
2023  "next_ofs didn't change. not deriving packet timestamps\n");
2024  return -1;
2025  }
2026 
2027  if (next_ofs > current_offset)
2028  break;
2029 
2030  last_ofs = next_ofs;
2031  mxf->current_edit_unit++;
2032  }
2033 
2034  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2035  if (mxf->current_edit_unit < 0)
2036  return -1;
2037 
2038  return next_ofs;
2039 }
2040 
2041 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2042 {
2043  int i, total = 0, size = 0;
2044  AVStream *st = mxf->fc->streams[stream_index];
2045  MXFTrack *track = st->priv_data;
2046  AVRational time_base = av_inv_q(track->edit_rate);
2048  const MXFSamplesPerFrame *spf = NULL;
2049 
2050  if ((sample_rate.num / sample_rate.den) == 48000)
2051  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2052  if (!spf) {
2053  int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2054  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2055  av_mul_q(sample_rate, time_base)));
2056  if (remainder)
2057  av_log(mxf->fc, AV_LOG_WARNING,
2058  "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2059  stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2060  return 0;
2061  }
2062 
2063  while (spf->samples_per_frame[size]) {
2064  total += spf->samples_per_frame[size];
2065  size++;
2066  }
2067 
2068  av_assert2(size);
2069 
2070  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2071  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2072  *sample_count += spf->samples_per_frame[i];
2073  }
2074 
2075  return 0;
2076 }
2077 
2079 {
2080  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2081  pkt->pts = track->sample_count;
2082  if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
2083  return AVERROR(EINVAL);
2084  track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2085  return 0;
2086 }
2087 
2089 {
2090  KLVPacket klv;
2091  MXFContext *mxf = s->priv_data;
2092 
2093  while (!url_feof(s->pb)) {
2094  int ret;
2095  if (klv_read_packet(&klv, s->pb) < 0)
2096  return -1;
2097  PRINT_KEY(s, "read packet", klv.key);
2098  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2100  ret = mxf_decrypt_triplet(s, pkt, &klv);
2101  if (ret < 0) {
2102  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2103  return AVERROR_INVALIDDATA;
2104  }
2105  return 0;
2106  }
2109  int index = mxf_get_stream_index(s, &klv);
2110  int64_t next_ofs, next_klv;
2111  AVStream *st;
2112  MXFTrack *track;
2113  AVCodecContext *codec;
2114 
2115  if (index < 0) {
2116  av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2117  goto skip;
2118  }
2119 
2120  st = s->streams[index];
2121  track = st->priv_data;
2122 
2123  if (s->streams[index]->discard == AVDISCARD_ALL)
2124  goto skip;
2125 
2126  next_klv = avio_tell(s->pb) + klv.length;
2127  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2128 
2129  if (next_ofs >= 0 && next_klv > next_ofs) {
2130  /* if this check is hit then it's possible OPAtom was treated as OP1a
2131  * truncate the packet since it's probably very large (>2 GiB is common) */
2133  "KLV for edit unit %i extends into next edit unit - OPAtom misinterpreted as OP1a?\n",
2134  mxf->current_edit_unit);
2135  klv.length = next_ofs - avio_tell(s->pb);
2136  }
2137 
2138  /* check for 8 channels AES3 element */
2139  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2140  if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2141  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2142  return AVERROR_INVALIDDATA;
2143  }
2144  } else {
2145  ret = av_get_packet(s->pb, pkt, klv.length);
2146  if (ret < 0)
2147  return ret;
2148  }
2149  pkt->stream_index = index;
2150  pkt->pos = klv.offset;
2151 
2152  codec = s->streams[index]->codec;
2153  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2154  /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2155  MXFIndexTable *t = &mxf->index_tables[0];
2156 
2157  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2158  pkt->dts = mxf->current_edit_unit + t->first_dts;
2159  pkt->pts = t->ptses[mxf->current_edit_unit];
2160  } else if (track->intra_only) {
2161  /* intra-only -> PTS = EditUnit.
2162  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2163  pkt->pts = mxf->current_edit_unit;
2164  }
2165  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2166  int ret = mxf_set_audio_pts(mxf, codec, pkt);
2167  if (ret < 0)
2168  return ret;
2169  }
2170 
2171  /* seek for truncated packets */
2172  avio_seek(s->pb, next_klv, SEEK_SET);
2173 
2174  return 0;
2175  } else
2176  skip:
2177  avio_skip(s->pb, klv.length);
2178  }
2179  return AVERROR_EOF;
2180 }
2181 
2183 {
2184  MXFContext *mxf = s->priv_data;
2185  int ret, size;
2186  int64_t ret64, pos, next_pos;
2187  AVStream *st;
2188  MXFIndexTable *t;
2189  int edit_units;
2190 
2191  if (mxf->op != OPAtom)
2192  return mxf_read_packet_old(s, pkt);
2193 
2194  /* OPAtom - clip wrapped demuxing */
2195  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2196  st = s->streams[0];
2197  t = &mxf->index_tables[0];
2198 
2199  if (mxf->current_edit_unit >= st->duration)
2200  return AVERROR_EOF;
2201 
2202  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2203 
2204  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2205  return ret;
2206 
2207  /* compute size by finding the next edit unit or the end of the essence container
2208  * not pretty, but it works */
2209  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2210  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2211  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2212  return AVERROR_INVALIDDATA;
2213  }
2214 
2215  if ((size = next_pos - pos) <= 0) {
2216  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2217  return AVERROR_INVALIDDATA;
2218  }
2219 
2220  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2221  return ret64;
2222 
2223  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2224  return size;
2225 
2226  pkt->stream_index = 0;
2227 
2228  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2229  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2230  pkt->dts = mxf->current_edit_unit + t->first_dts;
2231  pkt->pts = t->ptses[mxf->current_edit_unit];
2232  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2233  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2234  if (ret < 0)
2235  return ret;
2236  }
2237 
2238  mxf->current_edit_unit += edit_units;
2239 
2240  return 0;
2241 }
2242 
2244 {
2245  MXFContext *mxf = s->priv_data;
2246  MXFIndexTableSegment *seg;
2247  int i;
2248 
2249  av_freep(&mxf->packages_refs);
2250 
2251  for (i = 0; i < s->nb_streams; i++)
2252  s->streams[i]->priv_data = NULL;
2253 
2254  for (i = 0; i < mxf->metadata_sets_count; i++) {
2255  switch (mxf->metadata_sets[i]->type) {
2256  case Descriptor:
2257  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2258  break;
2259  case MultipleDescriptor:
2260  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2261  break;
2262  case Sequence:
2263  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2264  break;
2265  case SourcePackage:
2266  case MaterialPackage:
2267  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2268  break;
2269  case IndexTableSegment:
2270  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2272  av_freep(&seg->flag_entries);
2274  break;
2275  default:
2276  break;
2277  }
2278  av_freep(&mxf->metadata_sets[i]);
2279  }
2280  av_freep(&mxf->partitions);
2281  av_freep(&mxf->metadata_sets);
2282  av_freep(&mxf->aesc);
2283  av_freep(&mxf->local_tags);
2284 
2285  if (mxf->index_tables) {
2286  for (i = 0; i < mxf->nb_index_tables; i++) {
2287  av_freep(&mxf->index_tables[i].segments);
2288  av_freep(&mxf->index_tables[i].ptses);
2289  av_freep(&mxf->index_tables[i].fake_index);
2290  }
2291  }
2292  av_freep(&mxf->index_tables);
2293 
2294  return 0;
2295 }
2296 
2297 static int mxf_probe(AVProbeData *p) {
2298  const uint8_t *bufp = p->buf;
2299  const uint8_t *end = p->buf + p->buf_size;
2300 
2301  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2302  return 0;
2303 
2304  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2305  end -= sizeof(mxf_header_partition_pack_key);
2306  for (; bufp < end; bufp++) {
2308  return AVPROBE_SCORE_MAX;
2309  }
2310  return 0;
2311 }
2312 
2313 /* rudimentary byte seek */
2314 /* XXX: use MXF Index */
2315 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2316 {
2317  AVStream *st = s->streams[stream_index];
2318  int64_t seconds;
2319  MXFContext* mxf = s->priv_data;
2320  int64_t seekpos;
2321  int i, ret;
2322  MXFIndexTable *t;
2323  MXFTrack *source_track = st->priv_data;
2324 
2325  /* if audio then truncate sample_time to EditRate */
2326  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2327  sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2328 
2329  if (mxf->nb_index_tables <= 0) {
2330  if (!s->bit_rate)
2331  return AVERROR_INVALIDDATA;
2332  if (sample_time < 0)
2333  sample_time = 0;
2334  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2335 
2336  if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2337  return ret;
2338  ff_update_cur_dts(s, st, sample_time);
2339  } else {
2340  t = &mxf->index_tables[0];
2341 
2342  /* clamp above zero, else ff_index_search_timestamp() returns negative
2343  * this also means we allow seeking before the start */
2344  sample_time = FFMAX(sample_time, 0);
2345 
2346  if (t->fake_index) {
2347  /* behave as if we have a proper index */
2348  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2349  return sample_time;
2350  } else {
2351  /* no IndexEntryArray (one or more CBR segments)
2352  * make sure we don't seek past the end */
2353  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2354  }
2355 
2356  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2357  return ret;
2358 
2359  ff_update_cur_dts(s, st, sample_time);
2360  mxf->current_edit_unit = sample_time;
2361  avio_seek(s->pb, seekpos, SEEK_SET);
2362  }
2363 
2364  // Update all tracks sample count
2365  for (i = 0; i < s->nb_streams; i++) {
2366  AVStream *cur_st = s->streams[i];
2367  MXFTrack *cur_track = cur_st->priv_data;
2368  uint64_t current_sample_count = 0;
2369  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2370  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2371  if (ret < 0)
2372  return ret;
2373 
2374  cur_track->sample_count = current_sample_count;
2375  }
2376  }
2377  return 0;
2378 }
2379 
2381  .name = "mxf",
2382  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2383  .priv_data_size = sizeof(MXFContext),
2384  .read_probe = mxf_probe,
2389 };