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) {
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 
903  if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
904  !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
905  !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
907  av_freep(&segment->flag_entries);
908  return AVERROR(ENOMEM);
909  }
910 
911  for (i = 0; i < segment->nb_index_entries; i++) {
912  segment->temporal_offset_entries[i] = avio_r8(pb);
913  avio_r8(pb); /* KeyFrameOffset */
914  segment->flag_entries[i] = avio_r8(pb);
915  segment->stream_offset_entries[i] = avio_rb64(pb);
916  avio_skip(pb, length - 11);
917  }
918  return 0;
919 }
920 
921 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
922 {
924  switch(tag) {
925  case 0x3F05:
926  segment->edit_unit_byte_count = avio_rb32(pb);
927  av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
928  break;
929  case 0x3F06:
930  segment->index_sid = avio_rb32(pb);
931  av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
932  break;
933  case 0x3F07:
934  segment->body_sid = avio_rb32(pb);
935  av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
936  break;
937  case 0x3F0A:
938  av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
939  return mxf_read_index_entry_array(pb, segment);
940  case 0x3F0B:
941  segment->index_edit_rate.num = avio_rb32(pb);
942  segment->index_edit_rate.den = avio_rb32(pb);
943  av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
944  segment->index_edit_rate.den);
945  break;
946  case 0x3F0C:
947  segment->index_start_position = avio_rb64(pb);
948  av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
949  break;
950  case 0x3F0D:
951  segment->index_duration = avio_rb64(pb);
952  av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
953  break;
954  }
955  return 0;
956 }
957 
958 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
959 {
960  int code, value, ofs = 0;
961  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
962 
963  do {
964  code = avio_r8(pb);
965  value = avio_r8(pb);
966  av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
967 
968  if (ofs <= 14) {
969  layout[ofs++] = code;
970  layout[ofs++] = value;
971  } else
972  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
973  } while (code != 0); /* SMPTE 377M E.2.46 */
974 
975  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
976 }
977 
978 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
979 {
980  MXFDescriptor *descriptor = arg;
981  int entry_count, entry_size;
982 
983  switch(tag) {
984  case 0x3F01:
985  return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
986  &descriptor->sub_descriptors_count);
987  case 0x3002: /* ContainerDuration */
988  descriptor->duration = avio_rb64(pb);
989  break;
990  case 0x3004:
991  avio_read(pb, descriptor->essence_container_ul, 16);
992  break;
993  case 0x3005:
994  avio_read(pb, descriptor->codec_ul, 16);
995  break;
996  case 0x3006:
997  descriptor->linked_track_id = avio_rb32(pb);
998  break;
999  case 0x3201: /* PictureEssenceCoding */
1000  avio_read(pb, descriptor->essence_codec_ul, 16);
1001  break;
1002  case 0x3203:
1003  descriptor->width = avio_rb32(pb);
1004  break;
1005  case 0x3202:
1006  descriptor->height = avio_rb32(pb);
1007  break;
1008  case 0x320C:
1009  descriptor->frame_layout = avio_r8(pb);
1010  break;
1011  case 0x320D:
1012  entry_count = avio_rb32(pb);
1013  entry_size = avio_rb32(pb);
1014  if (entry_size == 4) {
1015  if (entry_count > 0)
1016  descriptor->video_line_map[0] = avio_rb32(pb);
1017  else
1018  descriptor->video_line_map[0] = 0;
1019  if (entry_count > 1)
1020  descriptor->video_line_map[1] = avio_rb32(pb);
1021  else
1022  descriptor->video_line_map[1] = 0;
1023  } else
1024  av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1025  break;
1026  case 0x320E:
1027  descriptor->aspect_ratio.num = avio_rb32(pb);
1028  descriptor->aspect_ratio.den = avio_rb32(pb);
1029  break;
1030  case 0x3212:
1031  descriptor->field_dominance = avio_r8(pb);
1032  break;
1033  case 0x3301:
1034  descriptor->component_depth = avio_rb32(pb);
1035  break;
1036  case 0x3302:
1037  descriptor->horiz_subsampling = avio_rb32(pb);
1038  break;
1039  case 0x3308:
1040  descriptor->vert_subsampling = avio_rb32(pb);
1041  break;
1042  case 0x3D03:
1043  descriptor->sample_rate.num = avio_rb32(pb);
1044  descriptor->sample_rate.den = avio_rb32(pb);
1045  break;
1046  case 0x3D06: /* SoundEssenceCompression */
1047  avio_read(pb, descriptor->essence_codec_ul, 16);
1048  break;
1049  case 0x3D07:
1050  descriptor->channels = avio_rb32(pb);
1051  break;
1052  case 0x3D01:
1053  descriptor->bits_per_sample = avio_rb32(pb);
1054  break;
1055  case 0x3401:
1056  mxf_read_pixel_layout(pb, descriptor);
1057  break;
1058  default:
1059  /* Private uid used by SONY C0023S01.mxf */
1061  if (descriptor->extradata)
1062  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1063  av_free(descriptor->extradata);
1064  descriptor->extradata_size = 0;
1065  descriptor->extradata = av_malloc(size);
1066  if (!descriptor->extradata)
1067  return AVERROR(ENOMEM);
1068  descriptor->extradata_size = size;
1069  avio_read(pb, descriptor->extradata, size);
1070  }
1071  if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1072  uint32_t rsiz = avio_rb16(pb);
1073  if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1075  descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1076  }
1077  break;
1078  }
1079  return 0;
1080 }
1081 
1082 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1083 {
1084  MXFTaggedValue *tagged_value = arg;
1085  uint8_t key[17];
1086 
1087  if (size <= 17)
1088  return 0;
1089 
1090  avio_read(pb, key, 17);
1091  /* TODO: handle other types of of indirect values */
1092  if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1093  return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1094  } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1095  return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1096  }
1097  return 0;
1098 }
1099 
1100 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1101 {
1102  MXFTaggedValue *tagged_value = arg;
1103  switch (tag){
1104  case 0x5001:
1105  return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1106  case 0x5003:
1107  return mxf_read_indirect_value(tagged_value, pb, size);
1108  }
1109  return 0;
1110 }
1111 
1112 /*
1113  * Match an uid independently of the version byte and up to len common bytes
1114  * Returns: boolean
1115  */
1116 static int mxf_match_uid(const UID key, const UID uid, int len)
1117 {
1118  int i;
1119  for (i = 0; i < len; i++) {
1120  if (i != 7 && key[i] != uid[i])
1121  return 0;
1122  }
1123  return 1;
1124 }
1125 
1126 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1127 {
1128  while (uls->uid[0]) {
1129  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1130  break;
1131  uls++;
1132  }
1133  return uls;
1134 }
1135 
1136 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1137 {
1138  int i;
1139 
1140  if (!strong_ref)
1141  return NULL;
1142  for (i = 0; i < mxf->metadata_sets_count; i++) {
1143  if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1144  (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1145  return mxf->metadata_sets[i];
1146  }
1147  }
1148  return NULL;
1149 }
1150 
1152  // video essence container uls
1153  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 },
1154  { { 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 */
1155  { { 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 */
1156  { { 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 */
1157  { { 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 */
1158  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1159  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* uncompressed picture */
1160  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1161  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1162  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1163  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1164 };
1165 
1166 /* EC ULs for intra-only formats */
1168  { { 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 */
1169  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1170 };
1171 
1172 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1174  { { 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 */
1175  { { 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 */
1176  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1177 };
1178 
1179 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1181  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1182  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1183  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1184  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1185  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1186 };
1187 
1189  // sound essence container uls
1190  { { 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 */
1191  { { 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 */
1192  { { 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 */
1193  { { 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 */
1194  { { 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) */
1195  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1196 };
1197 
1199  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1200  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1201 };
1202 
1203 static const char* const mxf_data_essence_descriptor[] = {
1204  "vbi_vanc_smpte_436M",
1205 };
1206 
1207 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1208 {
1209  int i, j, nb_segments = 0;
1210  MXFIndexTableSegment **unsorted_segments;
1211  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1212 
1213  /* count number of segments, allocate arrays and copy unsorted segments */
1214  for (i = 0; i < mxf->metadata_sets_count; i++)
1215  if (mxf->metadata_sets[i]->type == IndexTableSegment)
1216  nb_segments++;
1217 
1218  if (!nb_segments)
1219  return AVERROR_INVALIDDATA;
1220 
1221  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1222  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1223  av_freep(sorted_segments);
1224  av_free(unsorted_segments);
1225  return AVERROR(ENOMEM);
1226  }
1227 
1228  for (i = j = 0; i < mxf->metadata_sets_count; i++)
1229  if (mxf->metadata_sets[i]->type == IndexTableSegment)
1230  unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1231 
1232  *nb_sorted_segments = 0;
1233 
1234  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1235  for (i = 0; i < nb_segments; i++) {
1236  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1237  uint64_t best_index_duration = 0;
1238 
1239  for (j = 0; j < nb_segments; j++) {
1240  MXFIndexTableSegment *s = unsorted_segments[j];
1241 
1242  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1243  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1244  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1245  */
1246  if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1247  (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1248  (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1249  best = j;
1250  best_body_sid = s->body_sid;
1251  best_index_sid = s->index_sid;
1252  best_index_start = s->index_start_position;
1253  best_index_duration = s->index_duration;
1254  }
1255  }
1256 
1257  /* no suitable entry found -> we're done */
1258  if (best == -1)
1259  break;
1260 
1261  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1262  last_body_sid = best_body_sid;
1263  last_index_sid = best_index_sid;
1264  last_index_start = best_index_start;
1265  }
1266 
1267  av_free(unsorted_segments);
1268 
1269  return 0;
1270 }
1271 
1272 /**
1273  * Computes the absolute file offset of the given essence container offset
1274  */
1275 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1276 {
1277  int x;
1278  int64_t offset_in = offset; /* for logging */
1279 
1280  for (x = 0; x < mxf->partitions_count; x++) {
1281  MXFPartition *p = &mxf->partitions[x];
1282 
1283  if (p->body_sid != body_sid)
1284  continue;
1285 
1286  if (offset < p->essence_length || !p->essence_length) {
1287  *offset_out = p->essence_offset + offset;
1288  return 0;
1289  }
1290 
1291  offset -= p->essence_length;
1292  }
1293 
1294  av_log(mxf->fc, AV_LOG_ERROR,
1295  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1296  offset_in, body_sid);
1297 
1298  return AVERROR_INVALIDDATA;
1299 }
1300 
1301 /**
1302  * Returns the end position of the essence container with given BodySID, or zero if unknown
1303  */
1304 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1305 {
1306  int x;
1307  int64_t ret = 0;
1308 
1309  for (x = 0; x < mxf->partitions_count; x++) {
1310  MXFPartition *p = &mxf->partitions[x];
1311 
1312  if (p->body_sid != body_sid)
1313  continue;
1314 
1315  if (!p->essence_length)
1316  return 0;
1317 
1318  ret = p->essence_offset + p->essence_length;
1319  }
1320 
1321  return ret;
1322 }
1323 
1324 /* EditUnit -> absolute offset */
1325 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)
1326 {
1327  int i;
1328  int64_t offset_temp = 0;
1329 
1330  for (i = 0; i < index_table->nb_segments; i++) {
1331  MXFIndexTableSegment *s = index_table->segments[i];
1332 
1333  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1334 
1335  if (edit_unit < s->index_start_position + s->index_duration) {
1336  int64_t index = edit_unit - s->index_start_position;
1337 
1338  if (s->edit_unit_byte_count)
1339  offset_temp += s->edit_unit_byte_count * index;
1340  else if (s->nb_index_entries) {
1341  if (s->nb_index_entries == 2 * s->index_duration + 1)
1342  index *= 2; /* Avid index */
1343 
1344  if (index < 0 || index >= s->nb_index_entries) {
1345  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1346  index_table->index_sid, s->index_start_position);
1347  return AVERROR_INVALIDDATA;
1348  }
1349 
1350  offset_temp = s->stream_offset_entries[index];
1351  } else {
1352  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1353  index_table->index_sid, s->index_start_position);
1354  return AVERROR_INVALIDDATA;
1355  }
1356 
1357  if (edit_unit_out)
1358  *edit_unit_out = edit_unit;
1359 
1360  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1361  } else {
1362  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1363  offset_temp += s->edit_unit_byte_count * s->index_duration;
1364  }
1365  }
1366 
1367  if (nag)
1368  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);
1369 
1370  return AVERROR_INVALIDDATA;
1371 }
1372 
1374 {
1375  int i, j, x;
1376  int8_t max_temporal_offset = -128;
1377  uint8_t *flags;
1378 
1379  /* first compute how many entries we have */
1380  for (i = 0; i < index_table->nb_segments; i++) {
1381  MXFIndexTableSegment *s = index_table->segments[i];
1382 
1383  if (!s->nb_index_entries) {
1384  index_table->nb_ptses = 0;
1385  return 0; /* no TemporalOffsets */
1386  }
1387 
1388  index_table->nb_ptses += s->index_duration;
1389  }
1390 
1391  /* paranoid check */
1392  if (index_table->nb_ptses <= 0)
1393  return 0;
1394 
1395  if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1396  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1397  !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1398  !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1399  av_freep(&index_table->ptses);
1400  av_freep(&index_table->fake_index);
1401  av_freep(&index_table->offsets);
1402  return AVERROR(ENOMEM);
1403  }
1404 
1405  /* we may have a few bad TemporalOffsets
1406  * make sure the corresponding PTSes don't have the bogus value 0 */
1407  for (x = 0; x < index_table->nb_ptses; x++)
1408  index_table->ptses[x] = AV_NOPTS_VALUE;
1409 
1410  /**
1411  * We have this:
1412  *
1413  * x TemporalOffset
1414  * 0: 0
1415  * 1: 1
1416  * 2: 1
1417  * 3: -2
1418  * 4: 1
1419  * 5: 1
1420  * 6: -2
1421  *
1422  * We want to transform it into this:
1423  *
1424  * x DTS PTS
1425  * 0: -1 0
1426  * 1: 0 3
1427  * 2: 1 1
1428  * 3: 2 2
1429  * 4: 3 6
1430  * 5: 4 4
1431  * 6: 5 5
1432  *
1433  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1434  * then settings mxf->first_dts = -max(TemporalOffset[x]).
1435  * The latter makes DTS <= PTS.
1436  */
1437  for (i = x = 0; i < index_table->nb_segments; i++) {
1438  MXFIndexTableSegment *s = index_table->segments[i];
1439  int index_delta = 1;
1440  int n = s->nb_index_entries;
1441 
1442  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1443  index_delta = 2; /* Avid index */
1444  /* ignore the last entry - it's the size of the essence container */
1445  n--;
1446  }
1447 
1448  for (j = 0; j < n; j += index_delta, x++) {
1449  int offset = s->temporal_offset_entries[j] / index_delta;
1450  int index = x + offset;
1451 
1452  if (x >= index_table->nb_ptses) {
1453  av_log(mxf->fc, AV_LOG_ERROR,
1454  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1456  break;
1457  }
1458 
1459  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1460 
1461  if (index < 0 || index >= index_table->nb_ptses) {
1462  av_log(mxf->fc, AV_LOG_ERROR,
1463  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1464  x, offset, index);
1465  continue;
1466  }
1467 
1468  index_table->offsets[x] = offset;
1469  index_table->ptses[index] = x;
1470  max_temporal_offset = FFMAX(max_temporal_offset, offset);
1471  }
1472  }
1473 
1474  /* calculate the fake index table in display order */
1475  for (x = 0; x < index_table->nb_ptses; x++) {
1476  index_table->fake_index[x].timestamp = x;
1477  if (index_table->ptses[x] != AV_NOPTS_VALUE)
1478  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1479  }
1480  av_freep(&flags);
1481 
1482  index_table->first_dts = -max_temporal_offset;
1483 
1484  return 0;
1485 }
1486 
1487 /**
1488  * Sorts and collects index table segments into index tables.
1489  * Also computes PTSes if possible.
1490  */
1492 {
1493  int i, j, k, ret, nb_sorted_segments;
1494  MXFIndexTableSegment **sorted_segments = NULL;
1495  AVStream *st = NULL;
1496 
1497  for (i = 0; i < mxf->fc->nb_streams; i++) {
1498  if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
1499  continue;
1500  st = mxf->fc->streams[i];
1501  break;
1502  }
1503 
1504  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1505  nb_sorted_segments <= 0) {
1506  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1507  return 0;
1508  }
1509 
1510  /* sanity check and count unique BodySIDs/IndexSIDs */
1511  for (i = 0; i < nb_sorted_segments; i++) {
1512  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1513  mxf->nb_index_tables++;
1514  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1515  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1516  ret = AVERROR_INVALIDDATA;
1517  goto finish_decoding_index;
1518  }
1519  }
1520 
1522  sizeof(*mxf->index_tables));
1523  if (!mxf->index_tables) {
1524  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1525  ret = AVERROR(ENOMEM);
1526  goto finish_decoding_index;
1527  }
1528 
1529  /* distribute sorted segments to index tables */
1530  for (i = j = 0; i < nb_sorted_segments; i++) {
1531  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1532  /* next IndexSID */
1533  j++;
1534  }
1535 
1536  mxf->index_tables[j].nb_segments++;
1537  }
1538 
1539  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1540  MXFIndexTable *t = &mxf->index_tables[j];
1541 
1543  sizeof(*t->segments));
1544 
1545  if (!t->segments) {
1546  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1547  " pointer array\n");
1548  ret = AVERROR(ENOMEM);
1549  goto finish_decoding_index;
1550  }
1551 
1552  if (sorted_segments[i]->index_start_position)
1553  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1554  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1555 
1556  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1557  t->index_sid = sorted_segments[i]->index_sid;
1558  t->body_sid = sorted_segments[i]->body_sid;
1559 
1560  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1561  goto finish_decoding_index;
1562 
1563  /* fix zero IndexDurations */
1564  for (k = 0; k < t->nb_segments; k++) {
1565  if (t->segments[k]->index_duration)
1566  continue;
1567 
1568  if (t->nb_segments > 1)
1569  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1570  t->index_sid, k);
1571 
1572  if (!st) {
1573  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1574  break;
1575  }
1576 
1577  /* assume the first stream's duration is reasonable
1578  * leave index_duration = 0 on further segments in case we have any (unlikely)
1579  */
1580  t->segments[k]->index_duration = st->duration;
1581  break;
1582  }
1583  }
1584 
1585  ret = 0;
1586 finish_decoding_index:
1587  av_free(sorted_segments);
1588  return ret;
1589 }
1590 
1591 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1592 {
1593  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1594  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1595  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1596  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1597 }
1598 
1599 static int mxf_uid_to_str(UID uid, char **str)
1600 {
1601  int i;
1602  char *p;
1603  p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1604  if (!p)
1605  return AVERROR(ENOMEM);
1606  for (i = 0; i < sizeof(UID); i++) {
1607  snprintf(p, 2 + 1, "%.2x", uid[i]);
1608  p += 2;
1609  if (i == 3 || i == 5 || i == 7 || i == 9) {
1610  snprintf(p, 1 + 1, "-");
1611  p++;
1612  }
1613  }
1614  return 0;
1615 }
1616 
1617 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1618 {
1619  int i;
1620  char *p;
1621  p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1622  if (!p)
1623  return AVERROR(ENOMEM);
1624  snprintf(p, 2 + 1, "0x");
1625  p += 2;
1626  for (i = 0; i < sizeof(UID); i++) {
1627  snprintf(p, 2 + 1, "%.2X", ul[i]);
1628  p += 2;
1629 
1630  }
1631  for (i = 0; i < sizeof(UID); i++) {
1632  snprintf(p, 2 + 1, "%.2X", uid[i]);
1633  p += 2;
1634  }
1635  return 0;
1636 }
1637 
1638 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1639 {
1640  char *str;
1641  int ret;
1642  if (!package)
1643  return 0;
1644  if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1645  return ret;
1646  av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1647  return 0;
1648 }
1649 
1650 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1651 {
1652  char buf[AV_TIMECODE_STR_SIZE];
1653  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1654 
1655  return 0;
1656 }
1657 
1659 {
1660  MXFStructuralComponent *component = NULL;
1661  MXFPulldownComponent *pulldown = NULL;
1662 
1663  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1664  if (!component)
1665  return NULL;
1666 
1667  switch (component->type) {
1668  case TimecodeComponent:
1669  return (MXFTimecodeComponent*)component;
1670  case PulldownComponent: /* timcode component may be located on a pulldown component */
1671  pulldown = (MXFPulldownComponent*)component;
1673  default:
1674  break;
1675  }
1676  return NULL;
1677 }
1678 
1680 {
1681  MXFPackage *package = NULL;
1682  int i;
1683 
1684  for (i = 0; i < mxf->packages_count; i++) {
1685  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1686  if (!package)
1687  continue;
1688 
1689  if (!memcmp(package->package_uid, package_uid, 16))
1690  return package;
1691  }
1692  return NULL;
1693 }
1694 
1695 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1696 {
1697  MXFDescriptor *sub_descriptor = NULL;
1698  int i;
1699 
1700  if (!descriptor)
1701  return NULL;
1702 
1703  if (descriptor->type == MultipleDescriptor) {
1704  for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1705  sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1706 
1707  if (!sub_descriptor) {
1708  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1709  continue;
1710  }
1711  if (sub_descriptor->linked_track_id == track_id) {
1712  return sub_descriptor;
1713  }
1714  }
1715  } else if (descriptor->type == Descriptor)
1716  return descriptor;
1717 
1718  return NULL;
1719 }
1720 
1722 {
1723  MXFStructuralComponent *component = NULL;
1724  MXFPackage *package = NULL;
1725  MXFDescriptor *descriptor = NULL;
1726  int i;
1727 
1728  if (!essence_group || !essence_group->structural_components_count)
1729  return NULL;
1730 
1731  /* essence groups contains multiple representations of the same media,
1732  this return the first components with a valid Descriptor typically index 0 */
1733  for (i =0; i < essence_group->structural_components_count; i++){
1734  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1735  if (!component)
1736  continue;
1737 
1738  if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1739  continue;
1740 
1741  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1742  if (descriptor)
1743  return component;
1744  }
1745  return NULL;
1746 }
1747 
1749 {
1750  MXFStructuralComponent *component = NULL;
1751 
1752  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1753  if (!component)
1754  return NULL;
1755  switch (component->type) {
1756  case SourceClip:
1757  return component;
1758  case EssenceGroup:
1759  return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1760  default:
1761  break;
1762  }
1763  return NULL;
1764 }
1765 
1767 {
1769  int size, i;
1770  char *key = NULL;
1771 
1772  for (i = 0; i < package->comment_count; i++) {
1773  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1774  if (!tag || !tag->name || !tag->value)
1775  continue;
1776 
1777  size = strlen(tag->name) + 8 + 1;
1778  key = av_mallocz(size);
1779  if (!key)
1780  return AVERROR(ENOMEM);
1781 
1782  snprintf(key, size, "comment_%s", tag->name);
1783  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1784  }
1785  return 0;
1786 }
1787 
1789 {
1790  MXFPackage *physical_package = NULL;
1791  MXFTrack *physical_track = NULL;
1792  MXFStructuralComponent *sourceclip = NULL;
1793  MXFTimecodeComponent *mxf_tc = NULL;
1794  int i, j, k;
1795  AVTimecode tc;
1796  int flags;
1797  int64_t start_position;
1798 
1799  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1800  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1801  if (!sourceclip)
1802  continue;
1803 
1804  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1805  break;
1806 
1807  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1808 
1809  /* the name of physical source package is name of the reel or tape */
1810  if (physical_package->name && physical_package->name[0])
1811  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1812 
1813  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1814  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1815  */
1816  for (j = 0; j < physical_package->tracks_count; j++) {
1817  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1818  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1819  continue;
1820  }
1821 
1822  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1823  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1824  continue;
1825  }
1826 
1827  if (physical_track->edit_rate.num <= 0 ||
1828  physical_track->edit_rate.den <= 0) {
1829  av_log(mxf->fc, AV_LOG_WARNING,
1830  "Invalid edit rate (%d/%d) found on structural"
1831  " component #%d, defaulting to 25/1\n",
1832  physical_track->edit_rate.num,
1833  physical_track->edit_rate.den, i);
1834  physical_track->edit_rate = (AVRational){25, 1};
1835  }
1836 
1837  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1838  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1839  continue;
1840 
1841  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1842  /* scale sourceclip start_position to match physical track edit rate */
1843  start_position = av_rescale_q(sourceclip->start_position,
1844  physical_track->edit_rate,
1845  source_track->edit_rate);
1846 
1847  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1848  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1849  return 0;
1850  }
1851  }
1852  }
1853  }
1854 
1855  return 0;
1856 }
1857 
1859 {
1860  MXFStructuralComponent *component = NULL;
1861  const MXFCodecUL *codec_ul = NULL;
1862  MXFPackage tmp_package;
1863  AVStream *st;
1864  int j;
1865 
1866  for (j = 0; j < track->sequence->structural_components_count; j++) {
1867  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
1868  if (!component)
1869  continue;
1870  break;
1871  }
1872  if (!component)
1873  return 0;
1874 
1875  st = avformat_new_stream(mxf->fc, NULL);
1876  if (!st) {
1877  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
1878  return AVERROR(ENOMEM);
1879  }
1880 
1883  st->id = track->track_id;
1884 
1885  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
1886  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
1887  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
1888  if (track->name && track->name[0])
1889  av_dict_set(&st->metadata, "track_name", track->name, 0);
1890 
1892  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
1893  return 0;
1894 }
1895 
1897 {
1898  MXFPackage *material_package = NULL;
1899  int i, j, k, ret;
1900 
1901  av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
1902  /* TODO: handle multiple material packages (OP3x) */
1903  for (i = 0; i < mxf->packages_count; i++) {
1904  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1905  if (material_package) break;
1906  }
1907  if (!material_package) {
1908  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1909  return AVERROR_INVALIDDATA;
1910  }
1911 
1912  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1913  if (material_package->name && material_package->name[0])
1914  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1915  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
1916 
1917  for (i = 0; i < material_package->tracks_count; i++) {
1918  MXFPackage *source_package = NULL;
1919  MXFTrack *material_track = NULL;
1920  MXFTrack *source_track = NULL;
1921  MXFTrack *temp_track = NULL;
1922  MXFDescriptor *descriptor = NULL;
1923  MXFStructuralComponent *component = NULL;
1924  MXFTimecodeComponent *mxf_tc = NULL;
1925  UID *essence_container_ul = NULL;
1926  const MXFCodecUL *codec_ul = NULL;
1927  const MXFCodecUL *container_ul = NULL;
1928  const MXFCodecUL *pix_fmt_ul = NULL;
1929  AVStream *st;
1930  AVTimecode tc;
1931  int flags;
1932 
1933  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1934  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1935  continue;
1936  }
1937 
1938  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1939  mxf_tc = (MXFTimecodeComponent*)component;
1940  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1941  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1942  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1943  }
1944  }
1945 
1946  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1947  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1948  continue;
1949  }
1950 
1951  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1952  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1953  if (!component)
1954  continue;
1955 
1956  mxf_tc = (MXFTimecodeComponent*)component;
1957  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1958  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1959  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1960  break;
1961  }
1962  }
1963 
1964  /* TODO: handle multiple source clips, only finds first valid source clip */
1965  if(material_track->sequence->structural_components_count > 1)
1966  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
1967  material_track->track_id, material_track->sequence->structural_components_count);
1968 
1969  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1970  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1971  if (!component)
1972  continue;
1973 
1974  source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1975  if (!source_package) {
1976  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
1977  break;
1978  }
1979  for (k = 0; k < source_package->tracks_count; k++) {
1980  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1981  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1982  ret = AVERROR_INVALIDDATA;
1983  goto fail_and_free;
1984  }
1985  if (temp_track->track_id == component->source_track_id) {
1986  source_track = temp_track;
1987  break;
1988  }
1989  }
1990  if (!source_track) {
1991  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1992  break;
1993  }
1994  if(source_track && component)
1995  break;
1996  }
1997  if (!source_track || !component || !source_package) {
1998  if((ret = mxf_add_metadata_stream(mxf, material_track)))
1999  goto fail_and_free;
2000  continue;
2001  }
2002 
2003  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2004  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2005  ret = AVERROR_INVALIDDATA;
2006  goto fail_and_free;
2007  }
2008 
2009  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2010  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2011  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2012  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2013  continue;
2014  }
2015 
2016  st = avformat_new_stream(mxf->fc, NULL);
2017  if (!st) {
2018  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2019  ret = AVERROR(ENOMEM);
2020  goto fail_and_free;
2021  }
2022  st->id = material_track->track_id;
2023  st->priv_data = source_track;
2024 
2025  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2026  descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2027 
2028  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2029  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2030  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2031  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2032  else
2033  source_track->original_duration = st->duration = component->duration;
2034 
2035  if (st->duration == -1)
2036  st->duration = AV_NOPTS_VALUE;
2037  st->start_time = component->start_position;
2038  if (material_track->edit_rate.num <= 0 ||
2039  material_track->edit_rate.den <= 0) {
2040  av_log(mxf->fc, AV_LOG_WARNING,
2041  "Invalid edit rate (%d/%d) found on stream #%d, "
2042  "defaulting to 25/1\n",
2043  material_track->edit_rate.num,
2044  material_track->edit_rate.den, st->index);
2045  material_track->edit_rate = (AVRational){25, 1};
2046  }
2047  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2048 
2049  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2050  * the former is accessible via st->priv_data */
2051  source_track->edit_rate = material_track->edit_rate;
2052 
2053  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2055  st->codecpar->codec_type = codec_ul->id;
2056 
2057  if (!descriptor) {
2058  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2059  continue;
2060  }
2061  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2062  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2063  essence_container_ul = &descriptor->essence_container_ul;
2064  /* HACK: replacing the original key with mxf_encrypted_essence_container
2065  * is not allowed according to s429-6, try to find correct information anyway */
2066  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2067  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2068  for (k = 0; k < mxf->metadata_sets_count; k++) {
2069  MXFMetadataSet *metadata = mxf->metadata_sets[k];
2070  if (metadata->type == CryptoContext) {
2071  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2072  break;
2073  }
2074  }
2075  }
2076 
2077  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2078  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2079  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2080  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2081  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2082  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2083  }
2084 
2085  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2087  for (k = 0; k < 16; k++) {
2088  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2089  descriptor->essence_codec_ul[k]);
2090  if (!(k+1 & 19) || k == 5)
2091  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2092  }
2093  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2094 
2095  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2096  if (source_package->name && source_package->name[0])
2097  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2098  if (material_track->name && material_track->name[0])
2099  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2100 
2101  mxf_parse_physical_source_package(mxf, source_track, st);
2102 
2103  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2104  source_track->intra_only = mxf_is_intra_only(descriptor);
2105  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2106  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2107  st->codecpar->codec_id = container_ul->id;
2108  st->codecpar->width = descriptor->width;
2109  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2110  switch (descriptor->frame_layout) {
2111  case FullFrame:
2113  break;
2114  case OneField:
2115  /* Every other line is stored and needs to be duplicated. */
2116  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2117  break; /* The correct thing to do here is fall through, but by breaking we might be
2118  able to decode some streams at half the vertical resolution, rather than not al all.
2119  It's also for compatibility with the old behavior. */
2120  case MixedFields:
2121  break;
2122  case SegmentedFrame:
2124  case SeparateFields:
2125  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2126  descriptor->video_line_map[0], descriptor->video_line_map[1],
2127  descriptor->field_dominance);
2128  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2129  /* Detect coded field order from VideoLineMap:
2130  * (even, even) => bottom field coded first
2131  * (even, odd) => top field coded first
2132  * (odd, even) => top field coded first
2133  * (odd, odd) => bottom field coded first
2134  */
2135  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2136  switch (descriptor->field_dominance) {
2140  break;
2143  break;
2144  default:
2146  "Field dominance %d support",
2147  descriptor->field_dominance);
2148  }
2149  } else {
2150  switch (descriptor->field_dominance) {
2154  break;
2157  break;
2158  default:
2160  "Field dominance %d support",
2161  descriptor->field_dominance);
2162  }
2163  }
2164  }
2165  /* Turn field height into frame height. */
2166  st->codecpar->height *= 2;
2167  break;
2168  default:
2169  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2170  }
2171  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2172  st->codecpar->format = descriptor->pix_fmt;
2173  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2175  &descriptor->essence_codec_ul);
2176  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2177  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2179  &descriptor->essence_codec_ul)->id;
2180  if (!st->codecpar->codec_tag) {
2181  /* support files created before RP224v10 by defaulting to UYVY422
2182  if subsampling is 4:2:2 and component depth is 8-bit */
2183  if (descriptor->horiz_subsampling == 2 &&
2184  descriptor->vert_subsampling == 1 &&
2185  descriptor->component_depth == 8) {
2187  }
2188  }
2189  }
2190  }
2191  }
2193  if (material_track->sequence->origin) {
2194  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2195  }
2196  if (source_track->sequence->origin) {
2197  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2198  }
2199  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2200  st->display_aspect_ratio = descriptor->aspect_ratio;
2201  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2202  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2203  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2204  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))
2205  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2206  st->codecpar->channels = descriptor->channels;
2207  st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2208 
2209  if (descriptor->sample_rate.den > 0) {
2210  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2211  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2212  } else {
2213  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2214  "found for stream #%d, time base forced to 1/48000\n",
2215  descriptor->sample_rate.num, descriptor->sample_rate.den,
2216  st->index);
2217  avpriv_set_pts_info(st, 64, 1, 48000);
2218  }
2219 
2220  /* if duration is set, rescale it from EditRate to SampleRate */
2221  if (st->duration != AV_NOPTS_VALUE)
2222  st->duration = av_rescale_q(st->duration,
2223  av_inv_q(material_track->edit_rate),
2224  st->time_base);
2225 
2226  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2227  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2228  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2230  else if (descriptor->bits_per_sample == 32)
2232  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2233  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2235  else if (descriptor->bits_per_sample == 32)
2237  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2239  }
2240  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2241  int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2242  essence_container_ul)->id;
2243  if (codec_id >= 0 &&
2244  codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2245  av_dict_set(&st->metadata, "data_type",
2246  mxf_data_essence_descriptor[codec_id], 0);
2247  }
2248  }
2249  if (descriptor->extradata) {
2250  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2251  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2252  }
2253  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2254  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2255  &descriptor->essence_codec_ul)->id;
2256  if (coded_width)
2257  st->codecpar->width = coded_width;
2258  ret = ff_generate_avci_extradata(st);
2259  if (ret < 0)
2260  return ret;
2261  }
2262  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2263  /* TODO: decode timestamps */
2265  }
2266  }
2267 
2268  ret = 0;
2269 fail_and_free:
2270  return ret;
2271 }
2272 
2273 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2274 {
2275  struct tm time = { 0 };
2276  time.tm_year = (timestamp >> 48) - 1900;
2277  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2278  time.tm_mday = (timestamp >> 32 & 0xFF);
2279  time.tm_hour = (timestamp >> 24 & 0xFF);
2280  time.tm_min = (timestamp >> 16 & 0xFF);
2281  time.tm_sec = (timestamp >> 8 & 0xFF);
2282 
2283  /* msvcrt versions of strftime calls the invalid parameter handler
2284  * (aborting the process if one isn't set) if the parameters are out
2285  * of range. */
2286  time.tm_mon = av_clip(time.tm_mon, 0, 11);
2287  time.tm_mday = av_clip(time.tm_mday, 1, 31);
2288  time.tm_hour = av_clip(time.tm_hour, 0, 23);
2289  time.tm_min = av_clip(time.tm_min, 0, 59);
2290  time.tm_sec = av_clip(time.tm_sec, 0, 59);
2291 
2292  return (int64_t)av_timegm(&time) * 1000000;
2293 }
2294 
2295 #define SET_STR_METADATA(pb, name, str) do { \
2296  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2297  return ret; \
2298  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2299 } while (0)
2300 
2301 #define SET_UID_METADATA(pb, name, var, str) do { \
2302  avio_read(pb, var, 16); \
2303  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2304  return ret; \
2305  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2306 } while (0)
2307 
2308 #define SET_TS_METADATA(pb, name, var, str) do { \
2309  var = avio_rb64(pb); \
2310  if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2311  return ret; \
2312 } while (0)
2313 
2314 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2315 {
2316  MXFContext *mxf = arg;
2317  AVFormatContext *s = mxf->fc;
2318  int ret;
2319  UID uid = { 0 };
2320  char *str = NULL;
2321  uint64_t ts;
2322  switch (tag) {
2323  case 0x3C01:
2324  SET_STR_METADATA(pb, "company_name", str);
2325  break;
2326  case 0x3C02:
2327  SET_STR_METADATA(pb, "product_name", str);
2328  break;
2329  case 0x3C04:
2330  SET_STR_METADATA(pb, "product_version", str);
2331  break;
2332  case 0x3C05:
2333  SET_UID_METADATA(pb, "product_uid", uid, str);
2334  break;
2335  case 0x3C06:
2336  SET_TS_METADATA(pb, "modification_date", ts, str);
2337  break;
2338  case 0x3C08:
2339  SET_STR_METADATA(pb, "application_platform", str);
2340  break;
2341  case 0x3C09:
2342  SET_UID_METADATA(pb, "generation_uid", uid, str);
2343  break;
2344  case 0x3C0A:
2345  SET_UID_METADATA(pb, "uid", uid, str);
2346  break;
2347  }
2348  return 0;
2349 }
2350 
2351 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2352 {
2353  MXFContext *mxf = arg;
2354  AVFormatContext *s = mxf->fc;
2355  int ret;
2356  char *str = NULL;
2357 
2358  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2359  SET_STR_METADATA(pb, "project_name", str);
2360  }
2361  return 0;
2362 }
2363 
2365  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2366  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2367  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2368  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2369  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2370  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2371  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2372  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2373  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2374  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2375  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2376  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2377  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2378  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2379  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2380  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2381  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2382  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2383  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2384  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2385  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2386  { { 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 */
2387  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2388  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2389  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2390  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2391  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2392  { { 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 */
2393  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2394  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2395  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2396  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2397  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2398  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2399  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2400  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2401 };
2402 
2404 {
2405  switch (type){
2406  case MultipleDescriptor:
2407  case Descriptor:
2408  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2409  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2410  break;
2411  default:
2412  break;
2413  }
2414  return 0;
2415 }
2416 
2417 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2418 {
2419  AVIOContext *pb = mxf->fc->pb;
2420  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2421  uint64_t klv_end = avio_tell(pb) + klv->length;
2422 
2423  if (!ctx)
2424  return AVERROR(ENOMEM);
2425  mxf_metadataset_init(ctx, type);
2426  while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2427  int ret;
2428  int tag = avio_rb16(pb);
2429  int size = avio_rb16(pb); /* KLV specified by 0x53 */
2430  uint64_t next = avio_tell(pb) + size;
2431  UID uid = {0};
2432 
2433  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2434  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2435  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2436  continue;
2437  }
2438  if (tag > 0x7FFF) { /* dynamic tag */
2439  int i;
2440  for (i = 0; i < mxf->local_tags_count; i++) {
2441  int local_tag = AV_RB16(mxf->local_tags+i*18);
2442  if (local_tag == tag) {
2443  memcpy(uid, mxf->local_tags+i*18+2, 16);
2444  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2445  PRINT_KEY(mxf->fc, "uid", uid);
2446  }
2447  }
2448  }
2449  if (ctx_size && tag == 0x3C0A) {
2450  avio_read(pb, ctx->uid, 16);
2451  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2452  mxf_free_metadataset(&ctx, !!ctx_size);
2453  return ret;
2454  }
2455 
2456  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2457  * it extending past the end of the KLV though (zzuf5.mxf). */
2458  if (avio_tell(pb) > klv_end) {
2459  if (ctx_size) {
2460  ctx->type = type;
2461  mxf_free_metadataset(&ctx, !!ctx_size);
2462  }
2463 
2464  av_log(mxf->fc, AV_LOG_ERROR,
2465  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2466  tag, klv->offset);
2467  return AVERROR_INVALIDDATA;
2468  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2469  avio_seek(pb, next, SEEK_SET);
2470  }
2471  if (ctx_size) ctx->type = type;
2472  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2473 }
2474 
2475 /**
2476  * Matches any partition pack key, in other words:
2477  * - HeaderPartition
2478  * - BodyPartition
2479  * - FooterPartition
2480  * @return non-zero if the key is a partition pack key, zero otherwise
2481  */
2483 {
2484  //NOTE: this is a little lax since it doesn't constraint key[14]
2485  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2486  key[13] >= 2 && key[13] <= 4;
2487 }
2488 
2489 /**
2490  * Parses a metadata KLV
2491  * @return <0 on error, 0 otherwise
2492  */
2494  int ctx_size, enum MXFMetadataSetType type)
2495 {
2496  AVFormatContext *s = mxf->fc;
2497  int res;
2498  if (klv.key[5] == 0x53) {
2499  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2500  } else {
2501  uint64_t next = avio_tell(s->pb) + klv.length;
2502  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2503 
2504  /* only seek forward, else this can loop for a long time */
2505  if (avio_tell(s->pb) > next) {
2506  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2507  klv.offset);
2508  return AVERROR_INVALIDDATA;
2509  }
2510 
2511  avio_seek(s->pb, next, SEEK_SET);
2512  }
2513  if (res < 0) {
2514  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2515  return res;
2516  }
2517  return 0;
2518 }
2519 
2520 /**
2521  * Seeks to the previous partition and parses it, if possible
2522  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2523  */
2525 {
2526  AVIOContext *pb = mxf->fc->pb;
2527  KLVPacket klv;
2528  int64_t current_partition_ofs;
2529  int ret;
2530 
2531  if (!mxf->current_partition ||
2533  return 0; /* we've parsed all partitions */
2534 
2535  /* seek to previous partition */
2536  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2537  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2538  mxf->current_partition = NULL;
2539 
2540  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2541 
2542  /* Make sure this is actually a PartitionPack, and if so parse it.
2543  * See deadlock2.mxf
2544  */
2545  if ((ret = klv_read_packet(&klv, pb)) < 0) {
2546  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2547  return ret;
2548  }
2549 
2550  if (!mxf_is_partition_pack_key(klv.key)) {
2551  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2552  return AVERROR_INVALIDDATA;
2553  }
2554 
2555  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2556  * can point to just before the current partition, causing klv_read_packet()
2557  * to sync back up to it. See deadlock3.mxf
2558  */
2559  if (klv.offset >= current_partition_ofs) {
2560  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2561  PRIx64 " indirectly points to itself\n", current_partition_ofs);
2562  return AVERROR_INVALIDDATA;
2563  }
2564 
2565  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2566  return ret;
2567 
2568  return 1;
2569 }
2570 
2571 /**
2572  * Called when essence is encountered
2573  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2574  */
2576 {
2577  AVIOContext *pb = mxf->fc->pb;
2578  int64_t ret;
2579 
2580  if (mxf->parsing_backward) {
2581  return mxf_seek_to_previous_partition(mxf);
2582  } else {
2583  if (!mxf->footer_partition) {
2584  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2585  return 0;
2586  }
2587 
2588  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2589 
2590  /* remember where we were so we don't end up seeking further back than this */
2591  mxf->last_forward_tell = avio_tell(pb);
2592 
2593  if (!pb->seekable) {
2594  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2595  return -1;
2596  }
2597 
2598  /* seek to FooterPartition and parse backward */
2599  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2600  av_log(mxf->fc, AV_LOG_ERROR,
2601  "failed to seek to FooterPartition @ 0x%" PRIx64
2602  " (%"PRId64") - partial file?\n",
2603  mxf->run_in + mxf->footer_partition, ret);
2604  return ret;
2605  }
2606 
2607  mxf->current_partition = NULL;
2608  mxf->parsing_backward = 1;
2609  }
2610 
2611  return 1;
2612 }
2613 
2614 /**
2615  * Called when the next partition or EOF is encountered
2616  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2617  */
2619 {
2620  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2621 }
2622 
2623 /**
2624  * Figures out the proper offset and length of the essence container in each partition
2625  */
2627 {
2628  int x;
2629 
2630  /* everything is already correct */
2631  if (mxf->op == OPAtom)
2632  return;
2633 
2634  for (x = 0; x < mxf->partitions_count; x++) {
2635  MXFPartition *p = &mxf->partitions[x];
2636 
2637  if (!p->body_sid)
2638  continue; /* BodySID == 0 -> no essence */
2639 
2640  if (x >= mxf->partitions_count - 1)
2641  break; /* FooterPartition - can't compute length (and we don't need to) */
2642 
2643  /* essence container spans to the next partition */
2645 
2646  if (p->essence_length < 0) {
2647  /* next ThisPartition < essence_offset */
2648  p->essence_length = 0;
2649  av_log(mxf->fc, AV_LOG_ERROR,
2650  "partition %i: bad ThisPartition = %"PRIX64"\n",
2651  x+1, mxf->partitions[x+1].this_partition);
2652  }
2653  }
2654 }
2655 
2656 static int64_t round_to_kag(int64_t position, int kag_size)
2657 {
2658  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2659  /* NOTE: kag_size may be any integer between 1 - 2^10 */
2660  int64_t ret = (position / kag_size) * kag_size;
2661  return ret == position ? ret : ret + kag_size;
2662 }
2663 
2664 static int is_pcm(enum AVCodecID codec_id)
2665 {
2666  /* we only care about "normal" PCM codecs until we get samples */
2667  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2668 }
2669 
2671 {
2672  int i;
2673 
2674  if (mxf->op != OPAtom)
2675  return NULL;
2676 
2677  for (i = 0; i < mxf->fc->nb_streams; i++) {
2678  if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2679  continue;
2680  return mxf->fc->streams[i];
2681  }
2682  return NULL;
2683 }
2684 
2685 /**
2686  * Deal with the case where for some audio atoms EditUnitByteCount is
2687  * very small (2, 4..). In those cases we should read more than one
2688  * sample per call to mxf_read_packet().
2689  */
2691 {
2692  MXFContext *mxf = s->priv_data;
2693 
2694  /* assuming non-OPAtom == frame wrapped
2695  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2696  AVStream *st = mxf_get_opatom_stream(mxf);
2697  if (!st)
2698  return;
2699 
2700  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2701  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
2702  !is_pcm(st->codecpar->codec_id) ||
2703  mxf->nb_index_tables != 1 ||
2704  mxf->index_tables[0].nb_segments != 1 ||
2705  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2706  return;
2707 
2708  /* arbitrarily default to 48 kHz PAL audio frame size */
2709  /* TODO: We could compute this from the ratio between the audio
2710  * and video edit rates for 48 kHz NTSC we could use the
2711  * 1802-1802-1802-1802-1801 pattern. */
2712  mxf->edit_units_per_packet = 1920;
2713 }
2714 
2715 /**
2716  * Deal with the case where OPAtom files does not have any IndexTableSegments.
2717  */
2719 {
2720  AVFormatContext *s = mxf->fc;
2721  AVStream *st = NULL;
2723  MXFPartition *p = NULL;
2724  int essence_partition_count = 0;
2725  int i, ret;
2726 
2727  st = mxf_get_opatom_stream(mxf);
2728  if (!st)
2729  return 0;
2730 
2731  /* TODO: support raw video without an index if they exist */
2733  return 0;
2734 
2735  /* check if file already has a IndexTableSegment */
2736  for (i = 0; i < mxf->metadata_sets_count; i++) {
2737  if (mxf->metadata_sets[i]->type == IndexTableSegment)
2738  return 0;
2739  }
2740 
2741  /* find the essence partition */
2742  for (i = 0; i < mxf->partitions_count; i++) {
2743  /* BodySID == 0 -> no essence */
2744  if (!mxf->partitions[i].body_sid)
2745  continue;
2746 
2747  p = &mxf->partitions[i];
2748  essence_partition_count++;
2749  }
2750 
2751  /* only handle files with a single essence partition */
2752  if (essence_partition_count != 1)
2753  return 0;
2754 
2755  if (!(segment = av_mallocz(sizeof(*segment))))
2756  return AVERROR(ENOMEM);
2757 
2758  if ((ret = mxf_add_metadata_set(mxf, segment))) {
2759  mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2760  return ret;
2761  }
2762 
2763  segment->type = IndexTableSegment;
2764  /* stream will be treated as small EditUnitByteCount */
2766  segment->index_start_position = 0;
2767  segment->index_duration = s->streams[0]->duration;
2768  segment->index_sid = p->index_sid;
2769  segment->body_sid = p->body_sid;
2770  return 0;
2771 }
2772 
2774 {
2775  MXFContext *mxf = s->priv_data;
2776  uint32_t length;
2777  int64_t file_size, max_rip_length, min_rip_length;
2778  KLVPacket klv;
2779 
2780  if (!s->pb->seekable)
2781  return;
2782 
2783  file_size = avio_size(s->pb);
2784 
2785  /* S377m says to check the RIP length for "silly" values, without defining "silly".
2786  * The limit below assumes a file with nothing but partition packs and a RIP.
2787  * Before changing this, consider that a muxer may place each sample in its own partition.
2788  *
2789  * 105 is the size of the smallest possible PartitionPack
2790  * 12 is the size of each RIP entry
2791  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2792  */
2793  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2794  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2795 
2796  /* We're only interested in RIPs with at least two entries.. */
2797  min_rip_length = 16+1+24+4;
2798 
2799  /* See S377m section 11 */
2800  avio_seek(s->pb, file_size - 4, SEEK_SET);
2801  length = avio_rb32(s->pb);
2802 
2803  if (length < min_rip_length || length > max_rip_length)
2804  goto end;
2805  avio_seek(s->pb, file_size - length, SEEK_SET);
2806  if (klv_read_packet(&klv, s->pb) < 0 ||
2808  klv.length != length - 20)
2809  goto end;
2810 
2811  avio_skip(s->pb, klv.length - 12);
2812  mxf->footer_partition = avio_rb64(s->pb);
2813 
2814  /* sanity check */
2815  if (mxf->run_in + mxf->footer_partition >= file_size) {
2816  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2817  mxf->footer_partition = 0;
2818  }
2819 
2820 end:
2821  avio_seek(s->pb, mxf->run_in, SEEK_SET);
2822 }
2823 
2825 {
2826  MXFContext *mxf = s->priv_data;
2827  KLVPacket klv;
2828  int64_t essence_offset = 0;
2829  int ret;
2830 
2831  mxf->last_forward_tell = INT64_MAX;
2832  mxf->edit_units_per_packet = 1;
2833 
2835  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2836  return AVERROR_INVALIDDATA;
2837  }
2838  avio_seek(s->pb, -14, SEEK_CUR);
2839  mxf->fc = s;
2840  mxf->run_in = avio_tell(s->pb);
2841 
2843 
2844  while (!avio_feof(s->pb)) {
2845  const MXFMetadataReadTableEntry *metadata;
2846 
2847  if (klv_read_packet(&klv, s->pb) < 0) {
2848  /* EOF - seek to previous partition or stop */
2849  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2850  break;
2851  else
2852  continue;
2853  }
2854 
2855  PRINT_KEY(s, "read header", klv.key);
2856  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2861 
2862  if (!mxf->current_partition) {
2863  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2864  return AVERROR_INVALIDDATA;
2865  }
2866 
2867  if (!mxf->current_partition->essence_offset) {
2868  /* for OP1a we compute essence_offset
2869  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2870  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2871  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2872  */
2873  int64_t op1a_essence_offset =
2878 
2879  if (mxf->op == OPAtom) {
2880  /* point essence_offset to the actual data
2881  * OPAtom has all the essence in one big KLV
2882  */
2885  } else {
2886  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2887  mxf->current_partition->essence_offset = op1a_essence_offset;
2888  }
2889  }
2890 
2891  if (!essence_offset)
2892  essence_offset = klv.offset;
2893 
2894  /* seek to footer, previous partition or stop */
2895  if (mxf_parse_handle_essence(mxf) <= 0)
2896  break;
2897  continue;
2898  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2899  /* next partition pack - keep going, seek to previous partition or stop */
2900  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2901  break;
2902  else if (mxf->parsing_backward)
2903  continue;
2904  /* we're still parsing forward. proceed to parsing this partition pack */
2905  }
2906 
2907  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2908  if (IS_KLV_KEY(klv.key, metadata->key)) {
2909  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2910  goto fail;
2911  break;
2912  }
2913  }
2914  if (!metadata->read) {
2915  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2916  UID_ARG(klv.key));
2917  avio_skip(s->pb, klv.length);
2918  }
2919  }
2920  /* FIXME avoid seek */
2921  if (!essence_offset) {
2922  av_log(s, AV_LOG_ERROR, "no essence\n");
2923  ret = AVERROR_INVALIDDATA;
2924  goto fail;
2925  }
2926  avio_seek(s->pb, essence_offset, SEEK_SET);
2927 
2929 
2930  /* we need to do this before computing the index tables
2931  * to be able to fill in zero IndexDurations with st->duration */
2932  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2933  goto fail;
2934 
2936  if ((ret = mxf_compute_index_tables(mxf)) < 0)
2937  goto fail;
2938 
2939  if (mxf->nb_index_tables > 1) {
2940  /* TODO: look up which IndexSID to use via EssenceContainerData */
2941  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2942  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2943  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2944  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2945  ret = AVERROR_INVALIDDATA;
2946  goto fail;
2947  }
2948 
2950 
2951  return 0;
2952 fail:
2953  mxf_read_close(s);
2954 
2955  return ret;
2956 }
2957 
2958 /**
2959  * Sets mxf->current_edit_unit based on what offset we're currently at.
2960  * @return next_ofs if OK, <0 on error
2961  */
2962 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2963 {
2964  int64_t last_ofs = -1, next_ofs = -1;
2965  MXFIndexTable *t = &mxf->index_tables[0];
2966 
2967  /* this is called from the OP1a demuxing logic, which means there
2968  * may be no index tables */
2969  if (mxf->nb_index_tables <= 0)
2970  return -1;
2971 
2972  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2973  while (mxf->current_edit_unit >= 0) {
2974  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2975  return -1;
2976 
2977  if (next_ofs <= last_ofs) {
2978  /* large next_ofs didn't change or current_edit_unit wrapped
2979  * around this fixes the infinite loop on zzuf3.mxf */
2980  av_log(mxf->fc, AV_LOG_ERROR,
2981  "next_ofs didn't change. not deriving packet timestamps\n");
2982  return -1;
2983  }
2984 
2985  if (next_ofs > current_offset)
2986  break;
2987 
2988  last_ofs = next_ofs;
2989  mxf->current_edit_unit++;
2990  }
2991 
2992  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2993  if (mxf->current_edit_unit < 0)
2994  return -1;
2995 
2996  return next_ofs;
2997 }
2998 
2999 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3000  uint64_t *sample_count)
3001 {
3002  int i, total = 0, size = 0;
3003  AVStream *st = mxf->fc->streams[stream_index];
3004  MXFTrack *track = st->priv_data;
3005  AVRational time_base = av_inv_q(track->edit_rate);
3007  const MXFSamplesPerFrame *spf = NULL;
3008 
3009  if ((sample_rate.num / sample_rate.den) == 48000)
3010  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3011  if (!spf) {
3012  int remainder = (sample_rate.num * time_base.num) %
3013  (time_base.den * sample_rate.den);
3014  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
3015  av_mul_q(sample_rate, time_base)));
3016  if (remainder)
3017  av_log(mxf->fc, AV_LOG_WARNING,
3018  "seeking detected on stream #%d with time base (%d/%d) and "
3019  "sample rate (%d/%d), audio pts won't be accurate.\n",
3020  stream_index, time_base.num, time_base.den,
3021  sample_rate.num, sample_rate.den);
3022  return 0;
3023  }
3024 
3025  while (spf->samples_per_frame[size]) {
3026  total += spf->samples_per_frame[size];
3027  size++;
3028  }
3029 
3030  av_assert2(size);
3031 
3032  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3033  for (i = 0; i < mxf->current_edit_unit % size; i++) {
3034  *sample_count += spf->samples_per_frame[i];
3035  }
3036 
3037  return 0;
3038 }
3039 
3041  AVPacket *pkt)
3042 {
3043  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3044  int64_t bits_per_sample = par->bits_per_coded_sample;
3045 
3046  if (!bits_per_sample)
3047  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3048 
3049  pkt->pts = track->sample_count;
3050 
3051  if ( par->channels <= 0
3052  || bits_per_sample <= 0
3053  || par->channels * (int64_t)bits_per_sample < 8)
3054  return AVERROR(EINVAL);
3055  track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3056  return 0;
3057 }
3058 
3060 {
3061  KLVPacket klv;
3062  MXFContext *mxf = s->priv_data;
3063  int ret;
3064 
3065  while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3066  PRINT_KEY(s, "read packet", klv.key);
3067  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3069  ret = mxf_decrypt_triplet(s, pkt, &klv);
3070  if (ret < 0) {
3071  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3072  return ret;
3073  }
3074  return 0;
3075  }
3079  int index = mxf_get_stream_index(s, &klv);
3080  int64_t next_ofs, next_klv;
3081  AVStream *st;
3082  MXFTrack *track;
3083  AVCodecParameters *par;
3084 
3085  if (index < 0) {
3086  av_log(s, AV_LOG_ERROR,
3087  "error getting stream index %"PRIu32"\n",
3088  AV_RB32(klv.key + 12));
3089  goto skip;
3090  }
3091 
3092  st = s->streams[index];
3093  track = st->priv_data;
3094 
3095  if (s->streams[index]->discard == AVDISCARD_ALL)
3096  goto skip;
3097 
3098  next_klv = avio_tell(s->pb) + klv.length;
3099  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3100 
3101  if (next_ofs >= 0 && next_klv > next_ofs) {
3102  /* if this check is hit then it's possible OPAtom was treated as OP1a
3103  * truncate the packet since it's probably very large (>2 GiB is common) */
3105  "OPAtom misinterpreted as OP1a? "
3106  "KLV for edit unit %i extending into "
3107  "next edit unit",
3108  mxf->current_edit_unit);
3109  klv.length = next_ofs - avio_tell(s->pb);
3110  }
3111 
3112  /* check for 8 channels AES3 element */
3113  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3114  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3115  pkt, klv.length);
3116  if (ret < 0) {
3117  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3118  return ret;
3119  }
3120  } else {
3121  ret = av_get_packet(s->pb, pkt, klv.length);
3122  if (ret < 0)
3123  return ret;
3124  }
3125  pkt->stream_index = index;
3126  pkt->pos = klv.offset;
3127 
3128  par = st->codecpar;
3129 
3130  if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
3131  /* mxf->current_edit_unit good - see if we have an
3132  * index table to derive timestamps from */
3133  MXFIndexTable *t = &mxf->index_tables[0];
3134 
3135  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3136  pkt->dts = mxf->current_edit_unit + t->first_dts;
3137  pkt->pts = t->ptses[mxf->current_edit_unit];
3138  } else if (track && track->intra_only) {
3139  /* intra-only -> PTS = EditUnit.
3140  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3141  pkt->pts = mxf->current_edit_unit;
3142  }
3143  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3144  ret = mxf_set_audio_pts(mxf, par, pkt);
3145  if (ret < 0)
3146  return ret;
3147  }
3148 
3149  /* seek for truncated packets */
3150  avio_seek(s->pb, next_klv, SEEK_SET);
3151 
3152  return 0;
3153  } else
3154  skip:
3155  avio_skip(s->pb, klv.length);
3156  }
3157  return avio_feof(s->pb) ? AVERROR_EOF : ret;
3158 }
3159 
3161 {
3162  MXFContext *mxf = s->priv_data;
3163  int ret, size;
3164  int64_t ret64, pos, next_pos;
3165  AVStream *st;
3166  MXFIndexTable *t;
3167  int edit_units;
3168 
3169  if (mxf->op != OPAtom)
3170  return mxf_read_packet_old(s, pkt);
3171 
3172  // If we have no streams then we basically are at EOF
3173  st = mxf_get_opatom_stream(mxf);
3174  if (!st)
3175  return AVERROR_EOF;
3176 
3177  /* OPAtom - clip wrapped demuxing */
3178  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3179  t = &mxf->index_tables[0];
3180 
3181  if (mxf->current_edit_unit >= st->duration)
3182  return AVERROR_EOF;
3183 
3184  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
3185 
3186  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3187  return ret;
3188 
3189  /* compute size by finding the next edit unit or the end of the essence container
3190  * not pretty, but it works */
3191  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3192  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3193  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3194  return AVERROR_INVALIDDATA;
3195  }
3196 
3197  if ((size = next_pos - pos) <= 0) {
3198  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3199  return AVERROR_INVALIDDATA;
3200  }
3201 
3202  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3203  return ret64;
3204 
3205  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3206  return size;
3207 
3208  pkt->stream_index = st->index;
3209 
3210  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
3211  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
3212  pkt->dts = mxf->current_edit_unit + t->first_dts;
3213  pkt->pts = t->ptses[mxf->current_edit_unit];
3214  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3215  int ret = mxf_set_audio_pts(mxf, st->codecpar, pkt);
3216  if (ret < 0)
3217  return ret;
3218  }
3219 
3220  mxf->current_edit_unit += edit_units;
3221 
3222  return 0;
3223 }
3224 
3226 {
3227  MXFContext *mxf = s->priv_data;
3228  int i;
3229 
3230  av_freep(&mxf->packages_refs);
3231 
3232  for (i = 0; i < s->nb_streams; i++)
3233  s->streams[i]->priv_data = NULL;
3234 
3235  for (i = 0; i < mxf->metadata_sets_count; i++) {
3236  mxf_free_metadataset(mxf->metadata_sets + i, 1);
3237  }
3238  av_freep(&mxf->partitions);
3239  av_freep(&mxf->metadata_sets);
3240  av_freep(&mxf->aesc);
3241  av_freep(&mxf->local_tags);
3242 
3243  if (mxf->index_tables) {
3244  for (i = 0; i < mxf->nb_index_tables; i++) {
3245  av_freep(&mxf->index_tables[i].segments);
3246  av_freep(&mxf->index_tables[i].ptses);
3247  av_freep(&mxf->index_tables[i].fake_index);
3248  av_freep(&mxf->index_tables[i].offsets);
3249  }
3250  }
3251  av_freep(&mxf->index_tables);
3252 
3253  return 0;
3254 }
3255 
3256 static int mxf_probe(AVProbeData *p) {
3257  const uint8_t *bufp = p->buf;
3258  const uint8_t *end = p->buf + p->buf_size;
3259 
3260  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3261  return 0;
3262 
3263  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3264  end -= sizeof(mxf_header_partition_pack_key);
3265 
3266  for (; bufp < end;) {
3267  if (!((bufp[13] - 1) & 0xF2)){
3268  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3269  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3270  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3272  return AVPROBE_SCORE_MAX;
3273  bufp ++;
3274  } else
3275  bufp += 10;
3276  }
3277 
3278  return 0;
3279 }
3280 
3281 /* rudimentary byte seek */
3282 /* XXX: use MXF Index */
3283 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3284 {
3285  AVStream *st = s->streams[stream_index];
3286  int64_t seconds;
3287  MXFContext* mxf = s->priv_data;
3288  int64_t seekpos;
3289  int i, ret;
3290  MXFIndexTable *t;
3291  MXFTrack *source_track = st->priv_data;
3292 
3294  return 0;
3295 
3296  /* if audio then truncate sample_time to EditRate */
3298  sample_time = av_rescale_q(sample_time, st->time_base,
3299  av_inv_q(source_track->edit_rate));
3300 
3301  if (mxf->nb_index_tables <= 0) {
3302  if (!s->bit_rate)
3303  return AVERROR_INVALIDDATA;
3304  if (sample_time < 0)
3305  sample_time = 0;
3306  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3307 
3308  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3309  if (seekpos < 0)
3310  return seekpos;
3311 
3312  ff_update_cur_dts(s, st, sample_time);
3313  mxf->current_edit_unit = sample_time;
3314  } else {
3315  t = &mxf->index_tables[0];
3316 
3317  /* clamp above zero, else ff_index_search_timestamp() returns negative
3318  * this also means we allow seeking before the start */
3319  sample_time = FFMAX(sample_time, 0);
3320 
3321  if (t->fake_index) {
3322  /* The first frames may not be keyframes in presentation order, so
3323  * we have to advance the target to be able to find the first
3324  * keyframe backwards... */
3325  if (!(flags & AVSEEK_FLAG_ANY) &&
3326  (flags & AVSEEK_FLAG_BACKWARD) &&
3327  t->ptses[0] != AV_NOPTS_VALUE &&
3328  sample_time < t->ptses[0] &&
3329  (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3330  sample_time = t->ptses[0];
3331 
3332  /* behave as if we have a proper index */
3333  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3334  return sample_time;
3335  /* get the stored order index from the display order index */
3336  sample_time += t->offsets[sample_time];
3337  } else {
3338  /* no IndexEntryArray (one or more CBR segments)
3339  * make sure we don't seek past the end */
3340  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3341  }
3342 
3343  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3344  return ret;
3345 
3346  ff_update_cur_dts(s, st, sample_time);
3347  mxf->current_edit_unit = sample_time;
3348  avio_seek(s->pb, seekpos, SEEK_SET);
3349  }
3350 
3351  // Update all tracks sample count
3352  for (i = 0; i < s->nb_streams; i++) {
3353  AVStream *cur_st = s->streams[i];
3354  MXFTrack *cur_track = cur_st->priv_data;
3355  uint64_t current_sample_count = 0;
3356  if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3357  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
3358  if (ret < 0)
3359  return ret;
3360 
3361  cur_track->sample_count = current_sample_count;
3362  }
3363  }
3364  return 0;
3365 }
3366 
3368  .name = "mxf",
3369  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3370  .flags = AVFMT_SEEK_TO_PTS,
3371  .priv_data_size = sizeof(MXFContext),
3372  .read_probe = mxf_probe,
3377 };
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:2626
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:540
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:82
enum MXFMetadataSetType type
Definition: mxfdec.c:155
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2401
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:812
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:1896
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4062
MXFMetadataSetType
Definition: mxf.h:30
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
enum AVCodecID codec_id
Definition: ffmpeg_vaapi.c:149
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:309
uint8_t origin
Definition: mxfdec.c: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:921
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:2364
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:2524
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:1621
static int mxf_probe(AVProbeData *p)
Definition: mxfdec.c:3256
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:4581
int64_t * ptses
Definition: mxfdec.c:237
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2403
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:2773
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:3981
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:890
#define SET_TS_METADATA(pb, name, var, str)
Definition: mxfdec.c:2308
int size
Definition: avcodec.h:1602
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:230
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:3283
static int mxf_uid_to_str(UID uid, char **str)
Definition: mxfdec.c:1599
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1440
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:1617
int64_t offset
Definition: mxf.h:63
void * priv_data
Definition: avformat.h:904
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:304
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:252
char * name
Definition: mxfdec.c:149
discard all
Definition: avcodec.h:787
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:1966
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:742
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition: mxfdec.c:1591
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:2824
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:3973
static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read, int ctx_size, enum MXFMetadataSetType type)
Parses a metadata KLV.
Definition: mxfdec.c:2493
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:260
enum MXFMetadataSetType type
Definition: mxfdec.c: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:2618
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition: mxfdec.c:2417
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:3160
Format I/O context.
Definition: avformat.h:1338
Definition: mxfdec.c:69
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:2664
uint8_t UID[16]
Definition: mxf.h:28
int frame_layout
Definition: mxfdec.c:177
UID uid
Definition: mxfenc.c:1819
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:1871
static int mxf_handle_missing_index_segment(MXFContext *mxf)
Deal with the case where OPAtom files does not have any IndexTableSegments.
Definition: mxfdec.c:2718
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:151
Opaque data information usually continuous.
Definition: avutil.h:197
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:4047
#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:757
timecode is drop frame
Definition: timecode.h:36
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVRational index_edit_rate
Definition: mxfdec.c:203
enum AVStreamParseType need_parsing
Definition: avformat.h:1076
int id
Format-specific stream ID.
Definition: avformat.h:896
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:3225
Definition: mxf.h:61
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4214
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
Definition: mxfdec.c:1638
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:1406
#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:1275
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:1491
MXFIndexTableSegment ** segments
Definition: mxfdec.c:239
const MXFCodecUL ff_mxf_codec_uls[]
Definition: mxf.c:36
uint8_t * data
Definition: avcodec.h:1601
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:1412
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:289
Definition: mxfdec.c:67
Definition: ismindex.c:71
ptrdiff_t size
Definition: opengl_enc.c:101
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str, int be)
Definition: mxfdec.c:715
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:824
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:511
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition: mxfdec.c:1167
unsigned int vert_subsampling
Definition: mxfdec.c:188
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:208
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:604
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:1207
static MXFDescriptor * mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
Definition: mxfdec.c:1695
static AVStream * mxf_get_opatom_stream(MXFContext *mxf)
Definition: mxfdec.c:2670
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:183
#define SET_UID_METADATA(pb, name, var, str)
Definition: mxfdec.c:2301
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:363
#define AVINDEX_KEYFRAME
Definition: avformat.h:827
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:191
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:3535
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1554
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:958
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:1658
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:1650
#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:1325
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:821
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:176
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:1173
Definition: mxf.h:56
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3977
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:1188
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:2575
#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:2656
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
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:226
int64_t essence_length
Definition: mxfdec.c:88
#define fail()
Definition: checkasm.h:84
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:1116
int packages_count
Definition: mxfdec.c:249
Only parse headers, do not repack.
Definition: avformat.h:811
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:595
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:1748
int64_t index_byte_count
Definition: mxfdec.c:91
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:464
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition: mxf.c:118
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition: mxf.c:76
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:463
Definition: hls.c:67
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1394
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:4958
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition: mxfdec.c:1126
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:1136
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:243
int local_tags_count
Definition: mxfdec.c: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:3190
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:1721
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:1766
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:1180
Definition: mxfdec.c:70
int n
Definition: avisynth_c.h:684
AVDictionary * metadata
Definition: avformat.h:958
#define FF_PROFILE_JPEG2000_DCINEMA_4K
Definition: avcodec.h:3263
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:2314
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:2690
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:196
#define FF_ARRAY_ELEMS(a)
uint8_t le
Definition: crc.c:295
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:3146
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:514
uint64_t index_duration
Definition: mxfdec.c:205
Stream structure.
Definition: avformat.h:889
#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:1203
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
static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1100
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:1380
static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:978
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:2403
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:1198
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:391
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:1222
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:1679
AVFormatContext * fc
Definition: mxfdec.c:252
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:517
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:461
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:79
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:943
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:4091
Definition: mxfdec.c:73
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
Definition: mxfdec.c:1788
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:473
const uint8_t * key
Definition: avformat.h:1490
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:810
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:282
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition: mxfdec.c:1151
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:936
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:1858
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:3367
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:2273
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:1373
#define av_free(p)
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par, AVPacket *pkt)
Definition: mxfdec.c:3040
int current_klv_index
Definition: mxfdec.c:258
const MXFCodecUL ff_mxf_codec_tag_uls[]
Definition: mxf.c:82
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:2482
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:2351
static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
Definition: mxfdec.c:679
static uint8_t tmp[8]
Definition: des.c:38
MXFOP op
Definition: mxfdec.c:247
void * priv_data
Format private data.
Definition: avformat.h:1366
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:1304
#define FF_PROFILE_JPEG2000_DCINEMA_2K
Definition: avcodec.h:3262
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:1082
uint64_t layout
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4023
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3995
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:2295
int channels
Audio only.
Definition: avcodec.h:4087
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1600
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:2962
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:3059
static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
Definition: mxfdec.c:2999
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:664
AVCodecParameters * codecpar
Definition: avformat.h:1241
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:328
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3985
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:1603
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:926
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:949
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1578
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:1594
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:242
char * value
Definition: mxfdec.c:150
uint64_t previous_partition
Definition: mxfdec.c:83
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
const char * name
Definition: opengl_enc.c:103
int64_t header_byte_count
Definition: mxfdec.c:90
UID descriptor_ref
Definition: mxfdec.c:220