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