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