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