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