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