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