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