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