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 //#define DEBUG
47 
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/timecode.h"
53 #include "avformat.h"
54 #include "internal.h"
55 #include "mxf.h"
56 
57 typedef enum {
58  Header,
59  BodyPartition,
60  Footer
61 } MXFPartitionType;
62 
63 typedef enum {
64  OP1a = 1,
65  OP1b,
66  OP1c,
67  OP2a,
68  OP2b,
69  OP2c,
70  OP3a,
71  OP3b,
72  OP3c,
73  OPAtom,
74  OPSONYOpt, /* FATE sample, violates the spec in places */
75 } MXFOP;
76 
77 typedef struct {
78  int closed;
79  int complete;
80  MXFPartitionType type;
81  uint64_t previous_partition;
82  int index_sid;
83  int body_sid;
84  int64_t this_partition;
85  int64_t essence_offset; ///< absolute offset of essence
86  int64_t essence_length;
87  int32_t kag_size;
88  int64_t header_byte_count;
89  int64_t index_byte_count;
90  int pack_length;
91 } MXFPartition;
92 
93 typedef struct {
94  UID uid;
95  enum MXFMetadataSetType type;
96  UID source_container_ul;
97 } MXFCryptoContext;
98 
99 typedef struct {
100  UID uid;
101  enum MXFMetadataSetType type;
102  UID source_package_uid;
103  UID data_definition_ul;
104  int64_t duration;
105  int64_t start_position;
106  int source_track_id;
107 } MXFStructuralComponent;
108 
109 typedef struct {
110  UID uid;
111  enum MXFMetadataSetType type;
112  UID data_definition_ul;
113  UID *structural_components_refs;
114  int structural_components_count;
115  int64_t duration;
116 } MXFSequence;
117 
118 typedef struct {
119  UID uid;
120  enum MXFMetadataSetType type;
121  int drop_frame;
122  int start_frame;
123  struct AVRational rate;
124  AVTimecode tc;
125 } MXFTimecodeComponent;
126 
127 typedef struct {
128  UID uid;
129  enum MXFMetadataSetType type;
130  MXFSequence *sequence; /* mandatory, and only one */
131  UID sequence_ref;
132  int track_id;
133  uint8_t track_number[4];
134  AVRational edit_rate;
135  int intra_only;
136  uint64_t sample_count;
137  int64_t original_duration; ///< duration before multiplying st->duration by SampleRate/EditRate
138 } MXFTrack;
139 
140 typedef struct {
141  UID uid;
142  enum MXFMetadataSetType type;
143  UID essence_container_ul;
144  UID essence_codec_ul;
145  AVRational sample_rate;
146  AVRational aspect_ratio;
147  int width;
148  int height; /* Field height, not frame height */
149  int frame_layout; /* See MXFFrameLayout enum */
150  int channels;
151  int bits_per_sample;
152  int field_dominance;
153  unsigned int component_depth;
154  unsigned int horiz_subsampling;
155  unsigned int vert_subsampling;
156  UID *sub_descriptors_refs;
157  int sub_descriptors_count;
158  int linked_track_id;
159  uint8_t *extradata;
160  int extradata_size;
161  enum AVPixelFormat pix_fmt;
162 } MXFDescriptor;
163 
164 typedef struct {
165  UID uid;
166  enum MXFMetadataSetType type;
167  int edit_unit_byte_count;
168  int index_sid;
169  int body_sid;
170  AVRational index_edit_rate;
171  uint64_t index_start_position;
172  uint64_t index_duration;
173  int8_t *temporal_offset_entries;
174  int *flag_entries;
175  uint64_t *stream_offset_entries;
176  int nb_index_entries;
177 } MXFIndexTableSegment;
178 
179 typedef struct {
180  UID uid;
181  enum MXFMetadataSetType type;
182  UID package_uid;
183  UID *tracks_refs;
184  int tracks_count;
185  MXFDescriptor *descriptor; /* only one */
186  UID descriptor_ref;
187 } MXFPackage;
188 
189 typedef struct {
190  UID uid;
191  enum MXFMetadataSetType type;
192 } MXFMetadataSet;
193 
194 /* decoded index table */
195 typedef struct {
196  int index_sid;
197  int body_sid;
198  int nb_ptses; /* number of PTSes or total duration of index */
199  int64_t first_dts; /* DTS = EditUnit + first_dts */
200  int64_t *ptses; /* maps EditUnit -> PTS */
201  int nb_segments;
202  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
203  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
204 } MXFIndexTable;
205 
206 typedef struct {
207  MXFPartition *partitions;
208  unsigned partitions_count;
209  MXFOP op;
210  UID *packages_refs;
211  int packages_count;
212  MXFMetadataSet **metadata_sets;
213  int metadata_sets_count;
214  AVFormatContext *fc;
215  struct AVAES *aesc;
216  uint8_t *local_tags;
217  int local_tags_count;
218  uint64_t footer_partition;
219  KLVPacket current_klv_data;
220  int current_klv_index;
221  int run_in;
222  MXFPartition *current_partition;
223  int parsing_backward;
224  int64_t last_forward_tell;
225  int last_forward_partition;
226  int current_edit_unit;
227  int nb_index_tables;
228  MXFIndexTable *index_tables;
229  int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
230 } MXFContext;
231 
232 enum MXFWrappingScheme {
233  Frame,
234  Clip,
235 };
236 
237 /* NOTE: klv_offset is not set (-1) for local keys */
238 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
239 
240 typedef struct {
241  const UID key;
242  MXFMetadataReadFunc *read;
243  int ctx_size;
244  enum MXFMetadataSetType type;
245 } MXFMetadataReadTableEntry;
246 
247 static int mxf_read_close(AVFormatContext *s);
248 
249 /* partial keys to match */
250 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
251 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
252 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
253 static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
254 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
255 /* complete keys to match */
256 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 };
257 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
258 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
259 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
260 
261 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
262 
263 static int64_t klv_decode_ber_length(AVIOContext *pb)
264 {
265  uint64_t size = avio_r8(pb);
266  if (size & 0x80) { /* long form */
267  int bytes_num = size & 0x7f;
268  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
269  if (bytes_num > 8)
270  return AVERROR_INVALIDDATA;
271  size = 0;
272  while (bytes_num--)
273  size = size << 8 | avio_r8(pb);
274  }
275  return size;
276 }
277 
278 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
279 {
280  int i, b;
281  for (i = 0; i < size && !url_feof(pb); i++) {
282  b = avio_r8(pb);
283  if (b == key[0])
284  i = 0;
285  else if (b != key[i])
286  i = -1;
287  }
288  return i == size;
289 }
290 
291 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
292 {
293  if (!mxf_read_sync(pb, mxf_klv_key, 4))
294  return AVERROR_INVALIDDATA;
295  klv->offset = avio_tell(pb) - 4;
296  memcpy(klv->key, mxf_klv_key, 4);
297  avio_read(pb, klv->key + 4, 12);
298  klv->length = klv_decode_ber_length(pb);
299  return klv->length == -1 ? -1 : 0;
300 }
301 
302 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
303 {
304  int i;
305 
306  for (i = 0; i < s->nb_streams; i++) {
307  MXFTrack *track = s->streams[i]->priv_data;
308  /* SMPTE 379M 7.3 */
309  if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
310  return i;
311  }
312  /* return 0 if only one stream, for OP Atom files with 0 as track number */
313  return s->nb_streams == 1 ? 0 : -1;
314 }
315 
316 /* XXX: use AVBitStreamFilter */
317 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
318 {
319  const uint8_t *buf_ptr, *end_ptr;
320  uint8_t *data_ptr;
321  int i;
322 
323  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
324  return AVERROR_INVALIDDATA;
325  length = av_get_packet(pb, pkt, length);
326  if (length < 0)
327  return length;
328  data_ptr = pkt->data;
329  end_ptr = pkt->data + length;
330  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
331  for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
332  for (i = 0; i < st->codec->channels; i++) {
333  uint32_t sample = bytestream_get_le32(&buf_ptr);
334  if (st->codec->bits_per_coded_sample == 24)
335  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
336  else
337  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
338  }
339  buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
340  }
341  av_shrink_packet(pkt, data_ptr - pkt->data);
342  return 0;
343 }
344 
345 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
346 {
347  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
348  MXFContext *mxf = s->priv_data;
349  AVIOContext *pb = s->pb;
350  int64_t end = avio_tell(pb) + klv->length;
351  int64_t size;
352  uint64_t orig_size;
353  uint64_t plaintext_size;
354  uint8_t ivec[16];
355  uint8_t tmpbuf[16];
356  int index;
357 
358  if (!mxf->aesc && s->key && s->keylen == 16) {
359  mxf->aesc = av_aes_alloc();
360  if (!mxf->aesc)
361  return AVERROR(ENOMEM);
362  av_aes_init(mxf->aesc, s->key, 128, 1);
363  }
364  // crypto context
365  avio_skip(pb, klv_decode_ber_length(pb));
366  // plaintext offset
367  klv_decode_ber_length(pb);
368  plaintext_size = avio_rb64(pb);
369  // source klv key
370  klv_decode_ber_length(pb);
371  avio_read(pb, klv->key, 16);
372  if (!IS_KLV_KEY(klv, mxf_essence_element_key))
373  return AVERROR_INVALIDDATA;
374  index = mxf_get_stream_index(s, klv);
375  if (index < 0)
376  return AVERROR_INVALIDDATA;
377  // source size
378  klv_decode_ber_length(pb);
379  orig_size = avio_rb64(pb);
380  if (orig_size < plaintext_size)
381  return AVERROR_INVALIDDATA;
382  // enc. code
383  size = klv_decode_ber_length(pb);
384  if (size < 32 || size - 32 < orig_size)
385  return AVERROR_INVALIDDATA;
386  avio_read(pb, ivec, 16);
387  avio_read(pb, tmpbuf, 16);
388  if (mxf->aesc)
389  av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
390  if (memcmp(tmpbuf, checkv, 16))
391  av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
392  size -= 32;
393  size = av_get_packet(pb, pkt, size);
394  if (size < 0)
395  return size;
396  else if (size < plaintext_size)
397  return AVERROR_INVALIDDATA;
398  size -= plaintext_size;
399  if (mxf->aesc)
400  av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
401  &pkt->data[plaintext_size], size >> 4, ivec, 1);
402  av_shrink_packet(pkt, orig_size);
403  pkt->stream_index = index;
404  avio_skip(pb, end - avio_tell(pb));
405  return 0;
406 }
407 
408 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
409 {
410  MXFContext *mxf = arg;
411  int item_num = avio_rb32(pb);
412  int item_len = avio_rb32(pb);
413 
414  if (item_len != 18) {
415  avpriv_request_sample(pb, "Primer pack item length %d", item_len);
416  return AVERROR_PATCHWELCOME;
417  }
418  if (item_num > 65536) {
419  av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
420  return AVERROR_INVALIDDATA;
421  }
422  mxf->local_tags = av_calloc(item_num, item_len);
423  if (!mxf->local_tags)
424  return AVERROR(ENOMEM);
425  mxf->local_tags_count = item_num;
426  avio_read(pb, mxf->local_tags, item_num*item_len);
427  return 0;
428 }
429 
430 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
431 {
432  MXFContext *mxf = arg;
433  MXFPartition *partition, *tmp_part;
434  UID op;
435  uint64_t footer_partition;
436  uint32_t nb_essence_containers;
437 
438  if (mxf->partitions_count+1 >= UINT_MAX / sizeof(*mxf->partitions))
439  return AVERROR(ENOMEM);
440 
441  tmp_part = av_realloc(mxf->partitions, (mxf->partitions_count + 1) * sizeof(*mxf->partitions));
442  if (!tmp_part)
443  return AVERROR(ENOMEM);
444  mxf->partitions = tmp_part;
445 
446  if (mxf->parsing_backward) {
447  /* insert the new partition pack in the middle
448  * this makes the entries in mxf->partitions sorted by offset */
449  memmove(&mxf->partitions[mxf->last_forward_partition+1],
450  &mxf->partitions[mxf->last_forward_partition],
451  (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
452  partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
453  } else {
454  mxf->last_forward_partition++;
455  partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
456  }
457 
458  memset(partition, 0, sizeof(*partition));
459  mxf->partitions_count++;
460  partition->pack_length = avio_tell(pb) - klv_offset + size;
461 
462  switch(uid[13]) {
463  case 2:
464  partition->type = Header;
465  break;
466  case 3:
467  partition->type = BodyPartition;
468  break;
469  case 4:
470  partition->type = Footer;
471  break;
472  default:
473  av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
474  return AVERROR_INVALIDDATA;
475  }
476 
477  /* consider both footers to be closed (there is only Footer and CompleteFooter) */
478  partition->closed = partition->type == Footer || !(uid[14] & 1);
479  partition->complete = uid[14] > 2;
480  avio_skip(pb, 4);
481  partition->kag_size = avio_rb32(pb);
482  partition->this_partition = avio_rb64(pb);
483  partition->previous_partition = avio_rb64(pb);
484  footer_partition = avio_rb64(pb);
485  partition->header_byte_count = avio_rb64(pb);
486  partition->index_byte_count = avio_rb64(pb);
487  partition->index_sid = avio_rb32(pb);
488  avio_skip(pb, 8);
489  partition->body_sid = avio_rb32(pb);
490  avio_read(pb, op, sizeof(UID));
491  nb_essence_containers = avio_rb32(pb);
492 
493  /* some files don'thave FooterPartition set in every partition */
494  if (footer_partition) {
495  if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
496  av_log(mxf->fc, AV_LOG_ERROR,
497  "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
498  mxf->footer_partition, footer_partition);
499  } else {
500  mxf->footer_partition = footer_partition;
501  }
502  }
503 
504  av_dlog(mxf->fc,
505  "PartitionPack: ThisPartition = 0x%"PRIX64
506  ", PreviousPartition = 0x%"PRIX64", "
507  "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
508  partition->this_partition,
509  partition->previous_partition, footer_partition,
510  partition->index_sid, partition->body_sid);
511 
512  /* sanity check PreviousPartition if set */
513  if (partition->previous_partition &&
514  mxf->run_in + partition->previous_partition >= klv_offset) {
515  av_log(mxf->fc, AV_LOG_ERROR,
516  "PreviousPartition points to this partition or forward\n");
517  return AVERROR_INVALIDDATA;
518  }
519 
520  if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
521  else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
522  else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
523  else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
524  else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
525  else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
526  else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
527  else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
528  else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
529  else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
530  else if (op[12] == 0x10) {
531  /* SMPTE 390m: "There shall be exactly one essence container"
532  * The following block deals with files that violate this, namely:
533  * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
534  * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
535  if (nb_essence_containers != 1) {
536  MXFOP op = nb_essence_containers ? OP1a : OPAtom;
537 
538  /* only nag once */
539  if (!mxf->op)
540  av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
541  nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
542 
543  mxf->op = op;
544  } else
545  mxf->op = OPAtom;
546  } else {
547  av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
548  mxf->op = OP1a;
549  }
550 
551  if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
552  av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
553 
554  if (mxf->op == OPSONYOpt)
555  partition->kag_size = 512;
556  else
557  partition->kag_size = 1;
558 
559  av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
560  }
561 
562  return 0;
563 }
564 
565 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
566 {
567  MXFMetadataSet **tmp;
568  if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets))
569  return AVERROR(ENOMEM);
570  tmp = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets));
571  if (!tmp)
572  return AVERROR(ENOMEM);
573  mxf->metadata_sets = tmp;
574  mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
575  mxf->metadata_sets_count++;
576  return 0;
577 }
578 
579 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
580 {
581  MXFCryptoContext *cryptocontext = arg;
582  if (size != 16)
583  return AVERROR_INVALIDDATA;
584  if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
585  avio_read(pb, cryptocontext->source_container_ul, 16);
586  return 0;
587 }
588 
589 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
590 {
591  MXFContext *mxf = arg;
592  switch (tag) {
593  case 0x1901:
594  mxf->packages_count = avio_rb32(pb);
595  mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
596  if (!mxf->packages_refs)
597  return AVERROR(ENOMEM);
598  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
599  avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
600  break;
601  }
602  return 0;
603 }
604 
605 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
606 {
607  MXFStructuralComponent *source_clip = arg;
608  switch(tag) {
609  case 0x0202:
610  source_clip->duration = avio_rb64(pb);
611  break;
612  case 0x1201:
613  source_clip->start_position = avio_rb64(pb);
614  break;
615  case 0x1101:
616  /* UMID, only get last 16 bytes */
617  avio_skip(pb, 16);
618  avio_read(pb, source_clip->source_package_uid, 16);
619  break;
620  case 0x1102:
621  source_clip->source_track_id = avio_rb32(pb);
622  break;
623  }
624  return 0;
625 }
626 
627 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
628 {
629  MXFPackage *package = arg;
630  switch(tag) {
631  case 0x4403:
632  package->tracks_count = avio_rb32(pb);
633  package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
634  if (!package->tracks_refs)
635  return AVERROR(ENOMEM);
636  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
637  avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
638  break;
639  }
640  return 0;
641 }
642 
643 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
644 {
645  MXFTimecodeComponent *mxf_timecode = arg;
646  switch(tag) {
647  case 0x1501:
648  mxf_timecode->start_frame = avio_rb64(pb);
649  break;
650  case 0x1502:
651  mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
652  break;
653  case 0x1503:
654  mxf_timecode->drop_frame = avio_r8(pb);
655  break;
656  }
657  return 0;
658 }
659 
660 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
661 {
662  MXFTrack *track = arg;
663  switch(tag) {
664  case 0x4801:
665  track->track_id = avio_rb32(pb);
666  break;
667  case 0x4804:
668  avio_read(pb, track->track_number, 4);
669  break;
670  case 0x4B01:
671  track->edit_rate.num = avio_rb32(pb);
672  track->edit_rate.den = avio_rb32(pb);
673  break;
674  case 0x4803:
675  avio_read(pb, track->sequence_ref, 16);
676  break;
677  }
678  return 0;
679 }
680 
681 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
682 {
683  MXFSequence *sequence = arg;
684  switch(tag) {
685  case 0x0202:
686  sequence->duration = avio_rb64(pb);
687  break;
688  case 0x0201:
689  avio_read(pb, sequence->data_definition_ul, 16);
690  break;
691  case 0x1001:
692  sequence->structural_components_count = avio_rb32(pb);
693  sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
694  if (!sequence->structural_components_refs)
695  return AVERROR(ENOMEM);
696  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
697  avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
698  break;
699  }
700  return 0;
701 }
702 
703 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
704 {
705  MXFPackage *package = arg;
706  switch(tag) {
707  case 0x4403:
708  package->tracks_count = avio_rb32(pb);
709  package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
710  if (!package->tracks_refs)
711  return AVERROR(ENOMEM);
712  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
713  avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
714  break;
715  case 0x4401:
716  /* UMID, only get last 16 bytes */
717  avio_skip(pb, 16);
718  avio_read(pb, package->package_uid, 16);
719  break;
720  case 0x4701:
721  avio_read(pb, package->descriptor_ref, 16);
722  break;
723  }
724  return 0;
725 }
726 
727 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
728 {
729  int i, length;
730 
731  segment->nb_index_entries = avio_rb32(pb);
732 
733  length = avio_rb32(pb);
734 
735  if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
736  !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
737  !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
738  return AVERROR(ENOMEM);
739 
740  for (i = 0; i < segment->nb_index_entries; i++) {
741  segment->temporal_offset_entries[i] = avio_r8(pb);
742  avio_r8(pb); /* KeyFrameOffset */
743  segment->flag_entries[i] = avio_r8(pb);
744  segment->stream_offset_entries[i] = avio_rb64(pb);
745  avio_skip(pb, length - 11);
746  }
747  return 0;
748 }
749 
750 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
751 {
752  MXFIndexTableSegment *segment = arg;
753  switch(tag) {
754  case 0x3F05:
755  segment->edit_unit_byte_count = avio_rb32(pb);
756  av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
757  break;
758  case 0x3F06:
759  segment->index_sid = avio_rb32(pb);
760  av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
761  break;
762  case 0x3F07:
763  segment->body_sid = avio_rb32(pb);
764  av_dlog(NULL, "BodySID %d\n", segment->body_sid);
765  break;
766  case 0x3F0A:
767  av_dlog(NULL, "IndexEntryArray found\n");
768  return mxf_read_index_entry_array(pb, segment);
769  case 0x3F0B:
770  segment->index_edit_rate.num = avio_rb32(pb);
771  segment->index_edit_rate.den = avio_rb32(pb);
772  av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
773  segment->index_edit_rate.den);
774  break;
775  case 0x3F0C:
776  segment->index_start_position = avio_rb64(pb);
777  av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
778  break;
779  case 0x3F0D:
780  segment->index_duration = avio_rb64(pb);
781  av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
782  break;
783  }
784  return 0;
785 }
786 
787 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
788 {
789  int code, value, ofs = 0;
790  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
791 
792  do {
793  code = avio_r8(pb);
794  value = avio_r8(pb);
795  av_dlog(NULL, "pixel layout: code %#x\n", code);
796 
797  if (ofs <= 14) {
798  layout[ofs++] = code;
799  layout[ofs++] = value;
800  } else
801  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
802  } while (code != 0); /* SMPTE 377M E.2.46 */
803 
804  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
805 }
806 
807 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
808 {
809  MXFDescriptor *descriptor = arg;
810  descriptor->pix_fmt = AV_PIX_FMT_NONE;
811  switch(tag) {
812  case 0x3F01:
813  descriptor->sub_descriptors_count = avio_rb32(pb);
814  descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
815  if (!descriptor->sub_descriptors_refs)
816  return AVERROR(ENOMEM);
817  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
818  avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
819  break;
820  case 0x3004:
821  avio_read(pb, descriptor->essence_container_ul, 16);
822  break;
823  case 0x3006:
824  descriptor->linked_track_id = avio_rb32(pb);
825  break;
826  case 0x3201: /* PictureEssenceCoding */
827  avio_read(pb, descriptor->essence_codec_ul, 16);
828  break;
829  case 0x3203:
830  descriptor->width = avio_rb32(pb);
831  break;
832  case 0x3202:
833  descriptor->height = avio_rb32(pb);
834  break;
835  case 0x320C:
836  descriptor->frame_layout = avio_r8(pb);
837  break;
838  case 0x320E:
839  descriptor->aspect_ratio.num = avio_rb32(pb);
840  descriptor->aspect_ratio.den = avio_rb32(pb);
841  break;
842  case 0x3212:
843  descriptor->field_dominance = avio_r8(pb);
844  break;
845  case 0x3301:
846  descriptor->component_depth = avio_rb32(pb);
847  break;
848  case 0x3302:
849  descriptor->horiz_subsampling = avio_rb32(pb);
850  break;
851  case 0x3308:
852  descriptor->vert_subsampling = avio_rb32(pb);
853  break;
854  case 0x3D03:
855  descriptor->sample_rate.num = avio_rb32(pb);
856  descriptor->sample_rate.den = avio_rb32(pb);
857  break;
858  case 0x3D06: /* SoundEssenceCompression */
859  avio_read(pb, descriptor->essence_codec_ul, 16);
860  break;
861  case 0x3D07:
862  descriptor->channels = avio_rb32(pb);
863  break;
864  case 0x3D01:
865  descriptor->bits_per_sample = avio_rb32(pb);
866  break;
867  case 0x3401:
868  mxf_read_pixel_layout(pb, descriptor);
869  break;
870  default:
871  /* Private uid used by SONY C0023S01.mxf */
872  if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
873  if (descriptor->extradata)
874  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
875  av_free(descriptor->extradata);
876  descriptor->extradata_size = 0;
877  descriptor->extradata = av_malloc(size);
878  if (!descriptor->extradata)
879  return AVERROR(ENOMEM);
880  descriptor->extradata_size = size;
881  avio_read(pb, descriptor->extradata, size);
882  }
883  break;
884  }
885  return 0;
886 }
887 
888 /*
889  * Match an uid independently of the version byte and up to len common bytes
890  * Returns: boolean
891  */
892 static int mxf_match_uid(const UID key, const UID uid, int len)
893 {
894  int i;
895  for (i = 0; i < len; i++) {
896  if (i != 7 && key[i] != uid[i])
897  return 0;
898  }
899  return 1;
900 }
901 
902 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
903 {
904  while (uls->uid[0]) {
905  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
906  break;
907  uls++;
908  }
909  return uls;
910 }
911 
912 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
913 {
914  int i;
915 
916  if (!strong_ref)
917  return NULL;
918  for (i = 0; i < mxf->metadata_sets_count; i++) {
919  if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
920  (type == AnyType || mxf->metadata_sets[i]->type == type)) {
921  return mxf->metadata_sets[i];
922  }
923  }
924  return NULL;
925 }
926 
927 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
928  // video essence container uls
929  { { 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 */
930  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
931  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
932  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
933 };
934 
935 /* EC ULs for intra-only formats */
936 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
937  { { 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 */
938  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
939 };
940 
941 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
942 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
943  { { 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 */
944  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
945 };
946 
947 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
948  // sound essence container uls
949  { { 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 */
950  { { 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 */
951  { { 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 */
952  { { 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 */
953  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
954 };
955 
956 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
957 {
958  int i, j, nb_segments = 0;
959  MXFIndexTableSegment **unsorted_segments;
960  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
961 
962  /* count number of segments, allocate arrays and copy unsorted segments */
963  for (i = 0; i < mxf->metadata_sets_count; i++)
964  if (mxf->metadata_sets[i]->type == IndexTableSegment)
965  nb_segments++;
966 
967  if (!nb_segments)
968  return AVERROR_INVALIDDATA;
969 
970  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
971  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
972  av_freep(sorted_segments);
973  av_free(unsorted_segments);
974  return AVERROR(ENOMEM);
975  }
976 
977  for (i = j = 0; i < mxf->metadata_sets_count; i++)
978  if (mxf->metadata_sets[i]->type == IndexTableSegment)
979  unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
980 
981  *nb_sorted_segments = 0;
982 
983  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
984  for (i = 0; i < nb_segments; i++) {
985  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
986  uint64_t best_index_duration = 0;
987 
988  for (j = 0; j < nb_segments; j++) {
989  MXFIndexTableSegment *s = unsorted_segments[j];
990 
991  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
992  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
993  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
994  */
995  if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
996  (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
997  (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
998  best = j;
999  best_body_sid = s->body_sid;
1000  best_index_sid = s->index_sid;
1001  best_index_start = s->index_start_position;
1002  best_index_duration = s->index_duration;
1003  }
1004  }
1005 
1006  /* no suitable entry found -> we're done */
1007  if (best == -1)
1008  break;
1009 
1010  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1011  last_body_sid = best_body_sid;
1012  last_index_sid = best_index_sid;
1013  last_index_start = best_index_start;
1014  }
1015 
1016  av_free(unsorted_segments);
1017 
1018  return 0;
1019 }
1020 
1021 /**
1022  * Computes the absolute file offset of the given essence container offset
1023  */
1024 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1025 {
1026  int x;
1027  int64_t offset_in = offset; /* for logging */
1028 
1029  for (x = 0; x < mxf->partitions_count; x++) {
1030  MXFPartition *p = &mxf->partitions[x];
1031 
1032  if (p->body_sid != body_sid)
1033  continue;
1034 
1035  if (offset < p->essence_length || !p->essence_length) {
1036  *offset_out = p->essence_offset + offset;
1037  return 0;
1038  }
1039 
1040  offset -= p->essence_length;
1041  }
1042 
1043  av_log(mxf->fc, AV_LOG_ERROR,
1044  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1045  offset_in, body_sid);
1046 
1047  return AVERROR_INVALIDDATA;
1048 }
1049 
1050 /**
1051  * Returns the end position of the essence container with given BodySID, or zero if unknown
1052  */
1053 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1054 {
1055  int x;
1056  int64_t ret = 0;
1057 
1058  for (x = 0; x < mxf->partitions_count; x++) {
1059  MXFPartition *p = &mxf->partitions[x];
1060 
1061  if (p->body_sid != body_sid)
1062  continue;
1063 
1064  if (!p->essence_length)
1065  return 0;
1066 
1067  ret = p->essence_offset + p->essence_length;
1068  }
1069 
1070  return ret;
1071 }
1072 
1073 /* EditUnit -> absolute offset */
1074 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)
1075 {
1076  int i;
1077  int64_t offset_temp = 0;
1078 
1079  for (i = 0; i < index_table->nb_segments; i++) {
1080  MXFIndexTableSegment *s = index_table->segments[i];
1081 
1082  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1083 
1084  if (edit_unit < s->index_start_position + s->index_duration) {
1085  int64_t index = edit_unit - s->index_start_position;
1086 
1087  if (s->edit_unit_byte_count)
1088  offset_temp += s->edit_unit_byte_count * index;
1089  else if (s->nb_index_entries) {
1090  if (s->nb_index_entries == 2 * s->index_duration + 1)
1091  index *= 2; /* Avid index */
1092 
1093  if (index < 0 || index >= s->nb_index_entries) {
1094  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1095  index_table->index_sid, s->index_start_position);
1096  return AVERROR_INVALIDDATA;
1097  }
1098 
1099  offset_temp = s->stream_offset_entries[index];
1100  } else {
1101  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1102  index_table->index_sid, s->index_start_position);
1103  return AVERROR_INVALIDDATA;
1104  }
1105 
1106  if (edit_unit_out)
1107  *edit_unit_out = edit_unit;
1108 
1109  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1110  } else {
1111  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1112  offset_temp += s->edit_unit_byte_count * s->index_duration;
1113  }
1114  }
1115 
1116  if (nag)
1117  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);
1118 
1119  return AVERROR_INVALIDDATA;
1120 }
1121 
1122 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1123 {
1124  int i, j, x;
1125  int8_t max_temporal_offset = -128;
1126 
1127  /* first compute how many entries we have */
1128  for (i = 0; i < index_table->nb_segments; i++) {
1129  MXFIndexTableSegment *s = index_table->segments[i];
1130 
1131  if (!s->nb_index_entries) {
1132  index_table->nb_ptses = 0;
1133  return 0; /* no TemporalOffsets */
1134  }
1135 
1136  index_table->nb_ptses += s->index_duration;
1137  }
1138 
1139  /* paranoid check */
1140  if (index_table->nb_ptses <= 0)
1141  return 0;
1142 
1143  if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1144  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1145  av_freep(&index_table->ptses);
1146  return AVERROR(ENOMEM);
1147  }
1148 
1149  /* we may have a few bad TemporalOffsets
1150  * make sure the corresponding PTSes don't have the bogus value 0 */
1151  for (x = 0; x < index_table->nb_ptses; x++)
1152  index_table->ptses[x] = AV_NOPTS_VALUE;
1153 
1154  /**
1155  * We have this:
1156  *
1157  * x TemporalOffset
1158  * 0: 0
1159  * 1: 1
1160  * 2: 1
1161  * 3: -2
1162  * 4: 1
1163  * 5: 1
1164  * 6: -2
1165  *
1166  * We want to transform it into this:
1167  *
1168  * x DTS PTS
1169  * 0: -1 0
1170  * 1: 0 3
1171  * 2: 1 1
1172  * 3: 2 2
1173  * 4: 3 6
1174  * 5: 4 4
1175  * 6: 5 5
1176  *
1177  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1178  * then settings mxf->first_dts = -max(TemporalOffset[x]).
1179  * The latter makes DTS <= PTS.
1180  */
1181  for (i = x = 0; i < index_table->nb_segments; i++) {
1182  MXFIndexTableSegment *s = index_table->segments[i];
1183  int index_delta = 1;
1184  int n = s->nb_index_entries;
1185 
1186  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1187  index_delta = 2; /* Avid index */
1188  /* ignore the last entry - it's the size of the essence container */
1189  n--;
1190  }
1191 
1192  for (j = 0; j < n; j += index_delta, x++) {
1193  int offset = s->temporal_offset_entries[j] / index_delta;
1194  int index = x + offset;
1195 
1196  if (x >= index_table->nb_ptses) {
1197  av_log(mxf->fc, AV_LOG_ERROR,
1198  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1199  s->nb_index_entries, s->index_duration);
1200  break;
1201  }
1202 
1203  index_table->fake_index[x].timestamp = x;
1204  index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1205 
1206  if (index < 0 || index >= index_table->nb_ptses) {
1207  av_log(mxf->fc, AV_LOG_ERROR,
1208  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1209  x, offset, index);
1210  continue;
1211  }
1212 
1213  index_table->ptses[index] = x;
1214  max_temporal_offset = FFMAX(max_temporal_offset, offset);
1215  }
1216  }
1217 
1218  index_table->first_dts = -max_temporal_offset;
1219 
1220  return 0;
1221 }
1222 
1223 /**
1224  * Sorts and collects index table segments into index tables.
1225  * Also computes PTSes if possible.
1226  */
1227 static int mxf_compute_index_tables(MXFContext *mxf)
1228 {
1229  int i, j, k, ret, nb_sorted_segments;
1230  MXFIndexTableSegment **sorted_segments = NULL;
1231 
1232  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1233  nb_sorted_segments <= 0) {
1234  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1235  return 0;
1236  }
1237 
1238  /* sanity check and count unique BodySIDs/IndexSIDs */
1239  for (i = 0; i < nb_sorted_segments; i++) {
1240  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1241  mxf->nb_index_tables++;
1242  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1243  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1244  ret = AVERROR_INVALIDDATA;
1245  goto finish_decoding_index;
1246  }
1247  }
1248 
1249  if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
1250  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1251  ret = AVERROR(ENOMEM);
1252  goto finish_decoding_index;
1253  }
1254 
1255  /* distribute sorted segments to index tables */
1256  for (i = j = 0; i < nb_sorted_segments; i++) {
1257  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1258  /* next IndexSID */
1259  j++;
1260  }
1261 
1262  mxf->index_tables[j].nb_segments++;
1263  }
1264 
1265  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1266  MXFIndexTable *t = &mxf->index_tables[j];
1267 
1268  if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
1269  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
1270  ret = AVERROR(ENOMEM);
1271  goto finish_decoding_index;
1272  }
1273 
1274  if (sorted_segments[i]->index_start_position)
1275  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1276  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1277 
1278  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1279  t->index_sid = sorted_segments[i]->index_sid;
1280  t->body_sid = sorted_segments[i]->body_sid;
1281 
1282  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1283  goto finish_decoding_index;
1284 
1285  /* fix zero IndexDurations */
1286  for (k = 0; k < t->nb_segments; k++) {
1287  if (t->segments[k]->index_duration)
1288  continue;
1289 
1290  if (t->nb_segments > 1)
1291  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1292  t->index_sid, k);
1293 
1294  if (mxf->fc->nb_streams <= 0) {
1295  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1296  break;
1297  }
1298 
1299  /* assume the first stream's duration is reasonable
1300  * leave index_duration = 0 on further segments in case we have any (unlikely)
1301  */
1302  t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1303  break;
1304  }
1305  }
1306 
1307  ret = 0;
1308 finish_decoding_index:
1309  av_free(sorted_segments);
1310  return ret;
1311 }
1312 
1313 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1314 {
1315  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1316  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1317  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1318  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1319 }
1320 
1321 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1322 {
1323  char buf[AV_TIMECODE_STR_SIZE];
1324  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1325 
1326  return 0;
1327 }
1328 
1329 static int mxf_parse_structural_metadata(MXFContext *mxf)
1330 {
1331  MXFPackage *material_package = NULL;
1332  MXFPackage *temp_package = NULL;
1333  int i, j, k, ret;
1334 
1335  av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1336  /* TODO: handle multiple material packages (OP3x) */
1337  for (i = 0; i < mxf->packages_count; i++) {
1338  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1339  if (material_package) break;
1340  }
1341  if (!material_package) {
1342  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1343  return AVERROR_INVALIDDATA;
1344  }
1345 
1346  for (i = 0; i < material_package->tracks_count; i++) {
1347  MXFPackage *source_package = NULL;
1348  MXFTrack *material_track = NULL;
1349  MXFTrack *source_track = NULL;
1350  MXFTrack *temp_track = NULL;
1351  MXFDescriptor *descriptor = NULL;
1352  MXFStructuralComponent *component = NULL;
1353  MXFTimecodeComponent *mxf_tc = NULL;
1354  UID *essence_container_ul = NULL;
1355  const MXFCodecUL *codec_ul = NULL;
1356  const MXFCodecUL *container_ul = NULL;
1357  const MXFCodecUL *pix_fmt_ul = NULL;
1358  AVStream *st;
1359  AVTimecode tc;
1360  int flags;
1361 
1362  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1363  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1364  continue;
1365  }
1366 
1367  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1368  mxf_tc = (MXFTimecodeComponent*)component;
1369  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1370  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1371  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1372  }
1373  }
1374 
1375  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1376  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1377  continue;
1378  }
1379 
1380  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1381  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1382  if (!component)
1383  continue;
1384 
1385  mxf_tc = (MXFTimecodeComponent*)component;
1386  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1387  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1388  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1389  break;
1390  }
1391  }
1392 
1393  /* TODO: handle multiple source clips */
1394  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1395  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1396  if (!component)
1397  continue;
1398 
1399  for (k = 0; k < mxf->packages_count; k++) {
1400  temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1401  if (!temp_package)
1402  continue;
1403  if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1404  source_package = temp_package;
1405  break;
1406  }
1407  }
1408  if (!source_package) {
1409  av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1410  break;
1411  }
1412  for (k = 0; k < source_package->tracks_count; k++) {
1413  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1414  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1415  ret = AVERROR_INVALIDDATA;
1416  goto fail_and_free;
1417  }
1418  if (temp_track->track_id == component->source_track_id) {
1419  source_track = temp_track;
1420  break;
1421  }
1422  }
1423  if (!source_track) {
1424  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1425  break;
1426  }
1427  }
1428  if (!source_track || !component)
1429  continue;
1430 
1431  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1432  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1433  ret = AVERROR_INVALIDDATA;
1434  goto fail_and_free;
1435  }
1436 
1437  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1438  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1439  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1440  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1441  continue;
1442  }
1443 
1444  st = avformat_new_stream(mxf->fc, NULL);
1445  if (!st) {
1446  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1447  ret = AVERROR(ENOMEM);
1448  goto fail_and_free;
1449  }
1450  st->id = source_track->track_id;
1451  st->priv_data = source_track;
1452  source_track->original_duration = st->duration = component->duration;
1453  if (st->duration == -1)
1454  st->duration = AV_NOPTS_VALUE;
1455  st->start_time = component->start_position;
1456  if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
1457  av_log(mxf->fc, AV_LOG_WARNING,
1458  "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1459  material_track->edit_rate.num, material_track->edit_rate.den, st->index);
1460  material_track->edit_rate = (AVRational){25, 1};
1461  }
1462  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1463 
1464  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
1465  source_track->edit_rate = material_track->edit_rate;
1466 
1467  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1468  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1469  st->codec->codec_type = codec_ul->id;
1470 
1471  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1472  if (source_package->descriptor) {
1473  if (source_package->descriptor->type == MultipleDescriptor) {
1474  for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1475  MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1476 
1477  if (!sub_descriptor) {
1478  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1479  continue;
1480  }
1481  if (sub_descriptor->linked_track_id == source_track->track_id) {
1482  descriptor = sub_descriptor;
1483  break;
1484  }
1485  }
1486  } else if (source_package->descriptor->type == Descriptor)
1487  descriptor = source_package->descriptor;
1488  }
1489  if (!descriptor) {
1490  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1491  continue;
1492  }
1493  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1494  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1495  essence_container_ul = &descriptor->essence_container_ul;
1496  /* HACK: replacing the original key with mxf_encrypted_essence_container
1497  * is not allowed according to s429-6, try to find correct information anyway */
1498  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1499  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1500  for (k = 0; k < mxf->metadata_sets_count; k++) {
1501  MXFMetadataSet *metadata = mxf->metadata_sets[k];
1502  if (metadata->type == CryptoContext) {
1503  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1504  break;
1505  }
1506  }
1507  }
1508 
1509  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1510  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1511  st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1512  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1513  avcodec_get_name(st->codec->codec_id));
1514  for (k = 0; k < 16; k++) {
1515  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1516  descriptor->essence_codec_ul[k]);
1517  if (!(k+1 & 19) || k == 5)
1518  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1519  }
1520  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1521  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1522  source_track->intra_only = mxf_is_intra_only(descriptor);
1523  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1524  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1525  st->codec->codec_id = container_ul->id;
1526  st->codec->width = descriptor->width;
1527  st->codec->height = descriptor->height; /* Field height, not frame height */
1528  switch (descriptor->frame_layout) {
1529  case SegmentedFrame:
1530  /* This one is a weird layout I don't fully understand. */
1531  av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1532  break;
1533  case FullFrame:
1534  st->codec->field_order = AV_FIELD_PROGRESSIVE;
1535  break;
1536  case OneField:
1537  /* Every other line is stored and needs to be duplicated. */
1538  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1539  break; /* The correct thing to do here is fall through, but by breaking we might be
1540  able to decode some streams at half the vertical resolution, rather than not al all.
1541  It's also for compatibility with the old behavior. */
1542  case MixedFields:
1543  break;
1544  case SeparateFields:
1545  st->codec->height *= 2; /* Turn field height into frame height. */
1546  break;
1547  default:
1548  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1549  }
1550  if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1551  st->codec->pix_fmt = descriptor->pix_fmt;
1552  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1553  pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1554  &descriptor->essence_codec_ul);
1555  st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1556  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1557  /* support files created before RP224v10 by defaulting to UYVY422
1558  if subsampling is 4:2:2 and component depth is 8-bit */
1559  if (descriptor->horiz_subsampling == 2 &&
1560  descriptor->vert_subsampling == 1 &&
1561  descriptor->component_depth == 8) {
1562  st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1563  }
1564  }
1565  }
1566  }
1567  st->need_parsing = AVSTREAM_PARSE_HEADERS;
1568  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1569  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1570  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1571  if (st->codec->codec_id == AV_CODEC_ID_NONE || (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
1572  st->codec->codec_id = (enum AVCodecID)container_ul->id;
1573  st->codec->channels = descriptor->channels;
1574  st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1575 
1576  if (descriptor->sample_rate.den > 0) {
1577  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1578  st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1579  } else {
1580  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) found for stream #%d, time base forced to 1/48000\n",
1581  descriptor->sample_rate.num, descriptor->sample_rate.den, st->index);
1582  avpriv_set_pts_info(st, 64, 1, 48000);
1583  }
1584 
1585  /* if duration is set, rescale it from EditRate to SampleRate */
1586  if (st->duration != AV_NOPTS_VALUE)
1587  st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1588 
1589  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1590  if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1591  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1592  st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1593  else if (descriptor->bits_per_sample == 32)
1594  st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1595  } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1596  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1597  st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1598  else if (descriptor->bits_per_sample == 32)
1599  st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1600  } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1601  st->need_parsing = AVSTREAM_PARSE_FULL;
1602  }
1603  }
1604  if (descriptor->extradata) {
1605  st->codec->extradata = av_mallocz(descriptor->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1606  if (st->codec->extradata)
1607  memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1608  } else if(st->codec->codec_id == AV_CODEC_ID_H264) {
1609  ff_generate_avci_extradata(st);
1610  }
1611  if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1612  /* TODO: decode timestamps */
1613  st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1614  }
1615  }
1616 
1617  ret = 0;
1618 fail_and_free:
1619  return ret;
1620 }
1621 
1622 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1623 {
1624  int ret;
1625  size_t buf_size;
1626 
1627  if (size < 0)
1628  return AVERROR(EINVAL);
1629 
1630  buf_size = size + size/2 + 1;
1631  *str = av_malloc(buf_size);
1632  if (!*str)
1633  return AVERROR(ENOMEM);
1634 
1635  if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1636  av_freep(str);
1637  return ret;
1638  }
1639 
1640  return ret;
1641 }
1642 
1643 static int mxf_uid_to_str(UID uid, char **str)
1644 {
1645  int i;
1646  char *p;
1647  p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1648  if (!p)
1649  return AVERROR(ENOMEM);
1650  for (i = 0; i < sizeof(UID); i++) {
1651  snprintf(p, 2 + 1, "%.2x", uid[i]);
1652  p += 2;
1653  if (i == 3 || i == 5 || i == 7 || i == 9) {
1654  snprintf(p, 1 + 1, "-");
1655  p++;
1656  }
1657  }
1658  return 0;
1659 }
1660 
1661 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1662 {
1663  struct tm time = {0};
1664  time.tm_year = (timestamp >> 48) - 1900;
1665  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1666  time.tm_mday = (timestamp >> 32 & 0xFF);
1667  time.tm_hour = (timestamp >> 24 & 0xFF);
1668  time.tm_min = (timestamp >> 16 & 0xFF);
1669  time.tm_sec = (timestamp >> 8 & 0xFF);
1670 
1671  /* ensure month/day are valid */
1672  time.tm_mon = FFMAX(time.tm_mon, 0);
1673  time.tm_mday = FFMAX(time.tm_mday, 1);
1674 
1675  *str = av_mallocz(32);
1676  if (!*str)
1677  return AVERROR(ENOMEM);
1678  strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1679 
1680  return 0;
1681 }
1682 
1683 #define SET_STR_METADATA(pb, name, str) do { \
1684  if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1685  return ret; \
1686  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1687 } while (0)
1688 
1689 #define SET_UID_METADATA(pb, name, var, str) do { \
1690  avio_read(pb, var, 16); \
1691  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1692  return ret; \
1693  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1694 } while (0)
1695 
1696 #define SET_TS_METADATA(pb, name, var, str) do { \
1697  var = avio_rb64(pb); \
1698  if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1699  return ret; \
1700  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1701 } while (0)
1702 
1703 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1704 {
1705  MXFContext *mxf = arg;
1706  AVFormatContext *s = mxf->fc;
1707  int ret;
1708  UID uid = { 0 };
1709  char *str = NULL;
1710  uint64_t ts;
1711  switch (tag) {
1712  case 0x3C01:
1713  SET_STR_METADATA(pb, "company_name", str);
1714  break;
1715  case 0x3C02:
1716  SET_STR_METADATA(pb, "product_name", str);
1717  break;
1718  case 0x3C04:
1719  SET_STR_METADATA(pb, "product_version", str);
1720  break;
1721  case 0x3C05:
1722  SET_UID_METADATA(pb, "product_uid", uid, str);
1723  break;
1724  case 0x3C06:
1725  SET_TS_METADATA(pb, "modification_date", ts, str);
1726  break;
1727  case 0x3C08:
1728  SET_STR_METADATA(pb, "application_platform", str);
1729  break;
1730  case 0x3C09:
1731  SET_UID_METADATA(pb, "generation_uid", uid, str);
1732  break;
1733  case 0x3C0A:
1734  SET_UID_METADATA(pb, "uid", uid, str);
1735  break;
1736  }
1737  return 0;
1738 }
1739 
1740 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1741  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1742  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1743  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1744  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1745  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1746  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1747  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1748  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1749  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1750  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1751  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1752  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1753  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1754  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1755  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1756  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1757  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1758  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1759  { { 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 */
1760  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1761  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1762  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
1763  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1764  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1765  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1766  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1767  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1768  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1769  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1770  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1771 };
1772 
1773 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1774 {
1775  AVIOContext *pb = mxf->fc->pb;
1776  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1777  uint64_t klv_end = avio_tell(pb) + klv->length;
1778 
1779  if (!ctx)
1780  return AVERROR(ENOMEM);
1781  while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1782  int ret;
1783  int tag = avio_rb16(pb);
1784  int size = avio_rb16(pb); /* KLV specified by 0x53 */
1785  uint64_t next = avio_tell(pb) + size;
1786  UID uid = {0};
1787 
1788  av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1789  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1790  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1791  continue;
1792  }
1793  if (tag > 0x7FFF) { /* dynamic tag */
1794  int i;
1795  for (i = 0; i < mxf->local_tags_count; i++) {
1796  int local_tag = AV_RB16(mxf->local_tags+i*18);
1797  if (local_tag == tag) {
1798  memcpy(uid, mxf->local_tags+i*18+2, 16);
1799  av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1800  PRINT_KEY(mxf->fc, "uid", uid);
1801  }
1802  }
1803  }
1804  if (ctx_size && tag == 0x3C0A)
1805  avio_read(pb, ctx->uid, 16);
1806  else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1807  return ret;
1808 
1809  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1810  * it extending past the end of the KLV though (zzuf5.mxf). */
1811  if (avio_tell(pb) > klv_end) {
1812  if (ctx_size)
1813  av_free(ctx);
1814 
1815  av_log(mxf->fc, AV_LOG_ERROR,
1816  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1817  tag, klv->offset);
1818  return AVERROR_INVALIDDATA;
1819  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1820  avio_seek(pb, next, SEEK_SET);
1821  }
1822  if (ctx_size) ctx->type = type;
1823  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1824 }
1825 
1826 /**
1827  * Seeks to the previous partition, if possible
1828  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1829  */
1830 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1831 {
1832  AVIOContext *pb = mxf->fc->pb;
1833 
1834  if (!mxf->current_partition ||
1835  mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1836  return 0; /* we've parsed all partitions */
1837 
1838  /* seek to previous partition */
1839  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1840  mxf->current_partition = NULL;
1841 
1842  av_dlog(mxf->fc, "seeking to previous partition\n");
1843 
1844  return 1;
1845 }
1846 
1847 /**
1848  * Called when essence is encountered
1849  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1850  */
1851 static int mxf_parse_handle_essence(MXFContext *mxf)
1852 {
1853  AVIOContext *pb = mxf->fc->pb;
1854  int64_t ret;
1855 
1856  if (mxf->parsing_backward) {
1857  return mxf_seek_to_previous_partition(mxf);
1858  } else {
1859  if (!mxf->footer_partition) {
1860  av_dlog(mxf->fc, "no footer\n");
1861  return 0;
1862  }
1863 
1864  av_dlog(mxf->fc, "seeking to footer\n");
1865 
1866  /* remember where we were so we don't end up seeking further back than this */
1867  mxf->last_forward_tell = avio_tell(pb);
1868 
1869  if (!pb->seekable) {
1870  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1871  return -1;
1872  }
1873 
1874  /* seek to footer partition and parse backward */
1875  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1876  av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1877  mxf->run_in + mxf->footer_partition, ret);
1878  return ret;
1879  }
1880 
1881  mxf->current_partition = NULL;
1882  mxf->parsing_backward = 1;
1883  }
1884 
1885  return 1;
1886 }
1887 
1888 /**
1889  * Called when the next partition or EOF is encountered
1890  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1891  */
1892 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1893 {
1894  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1895 }
1896 
1897 /**
1898  * Figures out the proper offset and length of the essence container in each partition
1899  */
1900 static void mxf_compute_essence_containers(MXFContext *mxf)
1901 {
1902  int x;
1903 
1904  /* everything is already correct */
1905  if (mxf->op == OPAtom)
1906  return;
1907 
1908  for (x = 0; x < mxf->partitions_count; x++) {
1909  MXFPartition *p = &mxf->partitions[x];
1910 
1911  if (!p->body_sid)
1912  continue; /* BodySID == 0 -> no essence */
1913 
1914  if (x >= mxf->partitions_count - 1)
1915  break; /* last partition - can't compute length (and we don't need to) */
1916 
1917  /* essence container spans to the next partition */
1918  p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1919 
1920  if (p->essence_length < 0) {
1921  /* next ThisPartition < essence_offset */
1922  p->essence_length = 0;
1923  av_log(mxf->fc, AV_LOG_ERROR,
1924  "partition %i: bad ThisPartition = %"PRIX64"\n",
1925  x+1, mxf->partitions[x+1].this_partition);
1926  }
1927  }
1928 }
1929 
1930 static int64_t round_to_kag(int64_t position, int kag_size)
1931 {
1932  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1933  /* NOTE: kag_size may be any integer between 1 - 2^10 */
1934  int64_t ret = (position / kag_size) * kag_size;
1935  return ret == position ? ret : ret + kag_size;
1936 }
1937 
1938 static int is_pcm(enum AVCodecID codec_id)
1939 {
1940  /* we only care about "normal" PCM codecs until we get samples */
1941  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1942 }
1943 
1944 /**
1945  * Deal with the case where for some audio atoms EditUnitByteCount is
1946  * very small (2, 4..). In those cases we should read more than one
1947  * sample per call to mxf_read_packet().
1948  */
1949 static void mxf_handle_small_eubc(AVFormatContext *s)
1950 {
1951  MXFContext *mxf = s->priv_data;
1952 
1953  /* assuming non-OPAtom == frame wrapped
1954  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1955  if (mxf->op != OPAtom)
1956  return;
1957 
1958  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1959  if (s->nb_streams != 1 ||
1960  s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1961  !is_pcm(s->streams[0]->codec->codec_id) ||
1962  mxf->nb_index_tables != 1 ||
1963  mxf->index_tables[0].nb_segments != 1 ||
1964  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1965  return;
1966 
1967  /* arbitrarily default to 48 kHz PAL audio frame size */
1968  /* TODO: We could compute this from the ratio between the audio
1969  * and video edit rates for 48 kHz NTSC we could use the
1970  * 1802-1802-1802-1802-1801 pattern. */
1971  mxf->edit_units_per_packet = 1920;
1972 }
1973 
1974 static int mxf_read_header(AVFormatContext *s)
1975 {
1976  MXFContext *mxf = s->priv_data;
1977  KLVPacket klv;
1978  int64_t essence_offset = 0;
1979  int ret;
1980 
1981  mxf->last_forward_tell = INT64_MAX;
1982  mxf->edit_units_per_packet = 1;
1983 
1984  if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
1985  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1986  return AVERROR_INVALIDDATA;
1987  }
1988  avio_seek(s->pb, -14, SEEK_CUR);
1989  mxf->fc = s;
1990  mxf->run_in = avio_tell(s->pb);
1991 
1992  while (!url_feof(s->pb)) {
1993  const MXFMetadataReadTableEntry *metadata;
1994 
1995  if (klv_read_packet(&klv, s->pb) < 0) {
1996  /* EOF - seek to previous partition or stop */
1997  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1998  break;
1999  else
2000  continue;
2001  }
2002 
2003  PRINT_KEY(s, "read header", klv.key);
2004  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2005  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2006  IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2007  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2008  IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2009 
2010  if (!mxf->current_partition) {
2011  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2012  return AVERROR_INVALIDDATA;
2013  }
2014 
2015  if (!mxf->current_partition->essence_offset) {
2016  /* for OP1a we compute essence_offset
2017  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2018  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2019  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2020  */
2021  int64_t op1a_essence_offset =
2022  round_to_kag(mxf->current_partition->this_partition +
2023  mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2024  round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2025  round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2026 
2027  if (mxf->op == OPAtom) {
2028  /* point essence_offset to the actual data
2029  * OPAtom has all the essence in one big KLV
2030  */
2031  mxf->current_partition->essence_offset = avio_tell(s->pb);
2032  mxf->current_partition->essence_length = klv.length;
2033  } else {
2034  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2035  mxf->current_partition->essence_offset = op1a_essence_offset;
2036  }
2037  }
2038 
2039  if (!essence_offset)
2040  essence_offset = klv.offset;
2041 
2042  /* seek to footer, previous partition or stop */
2043  if (mxf_parse_handle_essence(mxf) <= 0)
2044  break;
2045  continue;
2046  } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2047  klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2048  /* next partition pack - keep going, seek to previous partition or stop */
2049  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2050  break;
2051  else if (mxf->parsing_backward)
2052  continue;
2053  /* we're still parsing forward. proceed to parsing this partition pack */
2054  }
2055 
2056  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2057  if (IS_KLV_KEY(klv.key, metadata->key)) {
2058  int res;
2059  if (klv.key[5] == 0x53) {
2060  res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2061  } else {
2062  uint64_t next = avio_tell(s->pb) + klv.length;
2063  res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2064 
2065  /* only seek forward, else this can loop for a long time */
2066  if (avio_tell(s->pb) > next) {
2067  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2068  klv.offset);
2069  return AVERROR_INVALIDDATA;
2070  }
2071 
2072  avio_seek(s->pb, next, SEEK_SET);
2073  }
2074  if (res < 0) {
2075  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2076  return res;
2077  }
2078  break;
2079  }
2080  }
2081  if (!metadata->read)
2082  avio_skip(s->pb, klv.length);
2083  }
2084  /* FIXME avoid seek */
2085  if (!essence_offset) {
2086  av_log(s, AV_LOG_ERROR, "no essence\n");
2087  return AVERROR_INVALIDDATA;
2088  }
2089  avio_seek(s->pb, essence_offset, SEEK_SET);
2090 
2091  mxf_compute_essence_containers(mxf);
2092 
2093  /* we need to do this before computing the index tables
2094  * to be able to fill in zero IndexDurations with st->duration */
2095  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2096  goto fail;
2097 
2098  if ((ret = mxf_compute_index_tables(mxf)) < 0)
2099  goto fail;
2100 
2101  if (mxf->nb_index_tables > 1) {
2102  /* TODO: look up which IndexSID to use via EssenceContainerData */
2103  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2104  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2105  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2106  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2107  ret = AVERROR_INVALIDDATA;
2108  goto fail;
2109  }
2110 
2111  mxf_handle_small_eubc(s);
2112 
2113  return 0;
2114 fail:
2115  mxf_read_close(s);
2116 
2117  return ret;
2118 }
2119 
2120 /**
2121  * Sets mxf->current_edit_unit based on what offset we're currently at.
2122  * @return next_ofs if OK, <0 on error
2123  */
2124 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2125 {
2126  int64_t last_ofs = -1, next_ofs = -1;
2127  MXFIndexTable *t = &mxf->index_tables[0];
2128 
2129  /* this is called from the OP1a demuxing logic, which means there
2130  * may be no index tables */
2131  if (mxf->nb_index_tables <= 0)
2132  return -1;
2133 
2134  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2135  while (mxf->current_edit_unit >= 0) {
2136  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2137  return -1;
2138 
2139  if (next_ofs <= last_ofs) {
2140  /* large next_ofs didn't change or current_edit_unit wrapped
2141  * around this fixes the infinite loop on zzuf3.mxf */
2142  av_log(mxf->fc, AV_LOG_ERROR,
2143  "next_ofs didn't change. not deriving packet timestamps\n");
2144  return -1;
2145  }
2146 
2147  if (next_ofs > current_offset)
2148  break;
2149 
2150  last_ofs = next_ofs;
2151  mxf->current_edit_unit++;
2152  }
2153 
2154  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2155  if (mxf->current_edit_unit < 0)
2156  return -1;
2157 
2158  return next_ofs;
2159 }
2160 
2161 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2162 {
2163  int i, total = 0, size = 0;
2164  AVStream *st = mxf->fc->streams[stream_index];
2165  MXFTrack *track = st->priv_data;
2166  AVRational time_base = av_inv_q(track->edit_rate);
2167  AVRational sample_rate = av_inv_q(st->time_base);
2168  const MXFSamplesPerFrame *spf = NULL;
2169 
2170  if ((sample_rate.num / sample_rate.den) == 48000)
2171  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2172  if (!spf) {
2173  int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2174  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2175  av_mul_q(sample_rate, time_base)));
2176  if (remainder)
2177  av_log(mxf->fc, AV_LOG_WARNING,
2178  "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2179  stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2180  return 0;
2181  }
2182 
2183  while (spf->samples_per_frame[size]) {
2184  total += spf->samples_per_frame[size];
2185  size++;
2186  }
2187 
2188  av_assert2(size);
2189 
2190  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2191  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2192  *sample_count += spf->samples_per_frame[i];
2193  }
2194 
2195  return 0;
2196 }
2197 
2198 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2199 {
2200  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2201  pkt->pts = track->sample_count;
2202  if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
2203  return AVERROR(EINVAL);
2204  track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2205  return 0;
2206 }
2207 
2208 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2209 {
2210  KLVPacket klv;
2211  MXFContext *mxf = s->priv_data;
2212 
2213  while (!url_feof(s->pb)) {
2214  int ret;
2215  if (klv_read_packet(&klv, s->pb) < 0)
2216  return -1;
2217  PRINT_KEY(s, "read packet", klv.key);
2218  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2219  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2220  ret = mxf_decrypt_triplet(s, pkt, &klv);
2221  if (ret < 0) {
2222  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2223  return AVERROR_INVALIDDATA;
2224  }
2225  return 0;
2226  }
2227  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2228  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2229  int index = mxf_get_stream_index(s, &klv);
2230  int64_t next_ofs, next_klv;
2231  AVStream *st;
2232  MXFTrack *track;
2233  AVCodecContext *codec;
2234 
2235  if (index < 0) {
2236  av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2237  goto skip;
2238  }
2239 
2240  st = s->streams[index];
2241  track = st->priv_data;
2242 
2243  if (s->streams[index]->discard == AVDISCARD_ALL)
2244  goto skip;
2245 
2246  next_klv = avio_tell(s->pb) + klv.length;
2247  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2248 
2249  if (next_ofs >= 0 && next_klv > next_ofs) {
2250  /* if this check is hit then it's possible OPAtom was treated as OP1a
2251  * truncate the packet since it's probably very large (>2 GiB is common) */
2252  avpriv_request_sample(s,
2253  "OPAtom misinterpreted as OP1a?"
2254  "KLV for edit unit %i extending into "
2255  "next edit unit",
2256  mxf->current_edit_unit);
2257  klv.length = next_ofs - avio_tell(s->pb);
2258  }
2259 
2260  /* check for 8 channels AES3 element */
2261  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2262  if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2263  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2264  return AVERROR_INVALIDDATA;
2265  }
2266  } else {
2267  ret = av_get_packet(s->pb, pkt, klv.length);
2268  if (ret < 0)
2269  return ret;
2270  }
2271  pkt->stream_index = index;
2272  pkt->pos = klv.offset;
2273 
2274  codec = s->streams[index]->codec;
2275  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2276  /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2277  MXFIndexTable *t = &mxf->index_tables[0];
2278 
2279  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2280  pkt->dts = mxf->current_edit_unit + t->first_dts;
2281  pkt->pts = t->ptses[mxf->current_edit_unit];
2282  } else if (track->intra_only) {
2283  /* intra-only -> PTS = EditUnit.
2284  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2285  pkt->pts = mxf->current_edit_unit;
2286  }
2287  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2288  int ret = mxf_set_audio_pts(mxf, codec, pkt);
2289  if (ret < 0)
2290  return ret;
2291  }
2292 
2293  /* seek for truncated packets */
2294  avio_seek(s->pb, next_klv, SEEK_SET);
2295 
2296  return 0;
2297  } else
2298  skip:
2299  avio_skip(s->pb, klv.length);
2300  }
2301  return AVERROR_EOF;
2302 }
2303 
2304 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2305 {
2306  MXFContext *mxf = s->priv_data;
2307  int ret, size;
2308  int64_t ret64, pos, next_pos;
2309  AVStream *st;
2310  MXFIndexTable *t;
2311  int edit_units;
2312 
2313  if (mxf->op != OPAtom)
2314  return mxf_read_packet_old(s, pkt);
2315 
2316  /* OPAtom - clip wrapped demuxing */
2317  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2318  st = s->streams[0];
2319  t = &mxf->index_tables[0];
2320 
2321  if (mxf->current_edit_unit >= st->duration)
2322  return AVERROR_EOF;
2323 
2324  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2325 
2326  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2327  return ret;
2328 
2329  /* compute size by finding the next edit unit or the end of the essence container
2330  * not pretty, but it works */
2331  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2332  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2333  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2334  return AVERROR_INVALIDDATA;
2335  }
2336 
2337  if ((size = next_pos - pos) <= 0) {
2338  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2339  return AVERROR_INVALIDDATA;
2340  }
2341 
2342  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2343  return ret64;
2344 
2345  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2346  return size;
2347 
2348  pkt->stream_index = 0;
2349 
2350  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2351  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2352  pkt->dts = mxf->current_edit_unit + t->first_dts;
2353  pkt->pts = t->ptses[mxf->current_edit_unit];
2354  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2355  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2356  if (ret < 0)
2357  return ret;
2358  }
2359 
2360  mxf->current_edit_unit += edit_units;
2361 
2362  return 0;
2363 }
2364 
2365 static int mxf_read_close(AVFormatContext *s)
2366 {
2367  MXFContext *mxf = s->priv_data;
2368  MXFIndexTableSegment *seg;
2369  int i;
2370 
2371  av_freep(&mxf->packages_refs);
2372 
2373  for (i = 0; i < s->nb_streams; i++)
2374  s->streams[i]->priv_data = NULL;
2375 
2376  for (i = 0; i < mxf->metadata_sets_count; i++) {
2377  switch (mxf->metadata_sets[i]->type) {
2378  case Descriptor:
2379  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2380  break;
2381  case MultipleDescriptor:
2382  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2383  break;
2384  case Sequence:
2385  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2386  break;
2387  case SourcePackage:
2388  case MaterialPackage:
2389  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2390  break;
2391  case IndexTableSegment:
2392  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2393  av_freep(&seg->temporal_offset_entries);
2394  av_freep(&seg->flag_entries);
2395  av_freep(&seg->stream_offset_entries);
2396  break;
2397  default:
2398  break;
2399  }
2400  av_freep(&mxf->metadata_sets[i]);
2401  }
2402  av_freep(&mxf->partitions);
2403  av_freep(&mxf->metadata_sets);
2404  av_freep(&mxf->aesc);
2405  av_freep(&mxf->local_tags);
2406 
2407  if (mxf->index_tables) {
2408  for (i = 0; i < mxf->nb_index_tables; i++) {
2409  av_freep(&mxf->index_tables[i].segments);
2410  av_freep(&mxf->index_tables[i].ptses);
2411  av_freep(&mxf->index_tables[i].fake_index);
2412  }
2413  }
2414  av_freep(&mxf->index_tables);
2415 
2416  return 0;
2417 }
2418 
2419 static int mxf_probe(AVProbeData *p) {
2420  const uint8_t *bufp = p->buf;
2421  const uint8_t *end = p->buf + p->buf_size;
2422 
2423  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2424  return 0;
2425 
2426  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2427  end -= sizeof(mxf_header_partition_pack_key);
2428  for (; bufp < end; bufp++) {
2429  if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
2430  return AVPROBE_SCORE_MAX;
2431  }
2432  return 0;
2433 }
2434 
2435 /* rudimentary byte seek */
2436 /* XXX: use MXF Index */
2437 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2438 {
2439  AVStream *st = s->streams[stream_index];
2440  int64_t seconds;
2441  MXFContext* mxf = s->priv_data;
2442  int64_t seekpos;
2443  int i, ret;
2444  int64_t ret64;
2445  MXFIndexTable *t;
2446  MXFTrack *source_track = st->priv_data;
2447 
2448  /* if audio then truncate sample_time to EditRate */
2449  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2450  sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2451 
2452  if (mxf->nb_index_tables <= 0) {
2453  if (!s->bit_rate)
2454  return AVERROR_INVALIDDATA;
2455  if (sample_time < 0)
2456  sample_time = 0;
2457  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2458 
2459  if ((ret64 = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2460  return ret64;
2461  ff_update_cur_dts(s, st, sample_time);
2462  mxf->current_edit_unit = sample_time;
2463  } else {
2464  t = &mxf->index_tables[0];
2465 
2466  /* clamp above zero, else ff_index_search_timestamp() returns negative
2467  * this also means we allow seeking before the start */
2468  sample_time = FFMAX(sample_time, 0);
2469 
2470  if (t->fake_index) {
2471  /* behave as if we have a proper index */
2472  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2473  return sample_time;
2474  } else {
2475  /* no IndexEntryArray (one or more CBR segments)
2476  * make sure we don't seek past the end */
2477  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2478  }
2479 
2480  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2481  return ret;
2482 
2483  ff_update_cur_dts(s, st, sample_time);
2484  mxf->current_edit_unit = sample_time;
2485  avio_seek(s->pb, seekpos, SEEK_SET);
2486  }
2487 
2488  // Update all tracks sample count
2489  for (i = 0; i < s->nb_streams; i++) {
2490  AVStream *cur_st = s->streams[i];
2491  MXFTrack *cur_track = cur_st->priv_data;
2492  uint64_t current_sample_count = 0;
2493  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2494  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2495  if (ret < 0)
2496  return ret;
2497 
2498  cur_track->sample_count = current_sample_count;
2499  }
2500  }
2501  return 0;
2502 }
2503 
2504 AVInputFormat ff_mxf_demuxer = {
2505  .name = "mxf",
2506  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2507  .priv_data_size = sizeof(MXFContext),
2508  .read_probe = mxf_probe,
2509  .read_header = mxf_read_header,
2510  .read_packet = mxf_read_packet,
2511  .read_close = mxf_read_close,
2512  .read_seek = mxf_read_seek,
2513 };
mxf_crypto_source_container_ul
static const uint8_t mxf_crypto_source_container_ul[]
Definition: mxfdec.c:256
mxf_compute_essence_containers
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:1900
AV_CODEC_ID_PCM_S24BE
Definition: libavcodec/avcodec.h:312
AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:85
av_mallocz
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
MXFContext
struct MXFContext MXFContext
AVSTREAM_PARSE_TIMESTAMPS
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:584
mxf_parse_structural_metadata
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:1329
AV_CODEC_ID_PCM_S24DAUD
Definition: libavcodec/avcodec.h:315
MXFMetadataSetType
MXFMetadataSetType
Definition: mxf.h:30
s
const char * s
Definition: avisynth_c.h:668
AVIOContext
Bytestream IO Context.
Definition: avio.h:68
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_CODEC_ID_NONE
Definition: libavcodec/avcodec.h:100
MXFDescriptor::component_depth
unsigned int component_depth
Definition: mxfdec.c:153
MXFContext::current_klv_data
KLVPacket current_klv_data
Definition: mxfdec.c:219
mxf_read_index_table_segment
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:750
Descriptor
Definition: mxf.h:38
MXFTimecodeComponent::tc
AVTimecode tc
Definition: mxfdec.c:124
mxf_metadata_read_table
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
Definition: mxfdec.c:1740
MXFContext::current_edit_unit
int current_edit_unit
Definition: mxfdec.c:226
PRINT_KEY
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:82
MXFIndexTable::index_sid
int index_sid
Definition: mxfdec.c:196
klv_read_packet
static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
Definition: mxfdec.c:291
MXFSequence::structural_components_refs
UID * structural_components_refs
Definition: mxfdec.c:113
MXFOP
MXFOP
Definition: mxfdec.c:63
mxf_seek_to_previous_partition
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition, if possible.
Definition: mxfdec.c:1830
MXFIndexTableSegment::edit_unit_byte_count
int edit_unit_byte_count
Definition: mxfdec.c:167
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: libavcodec/avcodec.h:1080
mxf_probe
static int mxf_probe(AVProbeData *p)
Definition: mxfdec.c:2419
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:97
avpriv_set_pts_info
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: libavformat/utils.c:3952
MXFIndexTable::ptses
int64_t * ptses
Definition: mxfdec.c:200
MXFTrack::sequence_ref
UID sequence_ref
Definition: mxfdec.c:131
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:154
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
AVRational::num
int num
numerator
Definition: rational.h:44
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:644
SET_TS_METADATA
#define SET_TS_METADATA(pb, name, var, str)
Definition: mxfdec.c:1696
SourceClip
Definition: mxf.h:34
MXFContext::footer_partition
uint64_t footer_partition
Definition: mxfdec.c:218
MXFPartition::closed
int closed
Definition: mxfdec.c:78
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:199
MXFMetadataReadTableEntry::type
enum MXFMetadataSetType type
Definition: mxfdec.c:244
av_aes_crypt
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:142
mxf_read_seek
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mxfdec.c:2437
mxf_uid_to_str
static int mxf_uid_to_str(UID uid, char **str)
Definition: mxfdec.c:1643
mxf_get_d10_aes3_packet
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
Definition: mxfdec.c:317
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: libavcodec/avcodec.h:1330
MXFTrack::sequence
MXFSequence * sequence
Definition: mxfdec.c:130
tc
#define tc
Definition: regdef.h:69
MXFDescriptor::linked_track_id
int linked_track_id
Definition: mxfdec.c:158
KLVPacket::key
UID key
Definition: mxf.h:59
KLVPacket::offset
int64_t offset
Definition: mxf.h:60
AVStream::priv_data
void * priv_data
Definition: avformat.h:663
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:256
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:141
av_dlog
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
AVDISCARD_ALL
discard all
Definition: libavcodec/avcodec.h:599
timecode.h
Timecode helpers header.
OP3a
Definition: mxfdec.c:70
ff_index_search_timestamp
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: libavformat/utils.c:1777
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:595
mxf_is_intra_only
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition: mxfdec.c:1313
sample
#define sample
Definition: flacdsp_template.c:44
AV_CODEC_ID_H264
Definition: libavcodec/avcodec.h:130
mxf_read_header
static int mxf_read_header(AVFormatContext *s)
Definition: mxfdec.c:1974
MXFCryptoContext::source_container_ul
UID source_container_ul
Definition: mxfdec.c:96
MXFCodecUL::id
int id
Definition: mxf.h:67
MXFDescriptor::type
enum MXFMetadataSetType type
Definition: mxfdec.c:142
av_freep
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
OP2c
Definition: mxfdec.c:69
mxf_parse_handle_partition_or_eof
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
Definition: mxfdec.c:1892
mxf_read_local_tags
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition: mxfdec.c:1773
mxf_read_packet
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:2304
if
initialize output if(nPeaks >3)%at least 3 peaks in spectrum for trying to find f0 nf0peaks
AVFormatContext
Format I/O context.
Definition: avformat.h:944
OP2a
Definition: mxfdec.c:67
is_pcm
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:1938
UID
uint8_t UID[16]
Definition: mxf.h:28
MXFDescriptor::frame_layout
int frame_layout
Definition: mxfdec.c:149
ff_update_cur_dts
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: libavformat/utils.c:1690
Footer
Definition: mxfdec.c:60
avpriv_request_sample
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
MXFContext::packages_refs
UID * packages_refs
Definition: mxfdec.c:210
uint8_t
uint8_t
Definition: audio_convert.c:194
MXFPackage::tracks_refs
UID * tracks_refs
Definition: mxfdec.c:183
MXFIndexTable::first_dts
int64_t first_dts
Definition: mxfdec.c:199
ff_mxf_get_samples_per_frame
const MXFSamplesPerFrame * ff_mxf_get_samples_per_frame(AVFormatContext *s, AVRational time_base)
Definition: mxf.c:119
AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:145
mxf_avid_essence_element_key
static const uint8_t mxf_avid_essence_element_key[]
Definition: mxfdec.c:252
MXFDescriptor::bits_per_sample
int bits_per_sample
Definition: mxfdec.c:151
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
Clip
Definition: mxfdec.c:234
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:610
AV_RB32
#define AV_RB32
Definition: avr32/intreadwrite.h:130
pkt
static AVPacket pkt
Definition: demuxing.c:56
MXFIndexTableSegment::index_edit_rate
AVRational index_edit_rate
Definition: mxfdec.c:170
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:811
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:650
b
#define b
Definition: input.c:42
end
end end
Definition: extra/f0detection.m:15
mxf_read_close
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:2365
KLVPacket
Definition: mxf.h:58
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: libavcodec/avcodec.h:1242
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: libavformat/utils.c:3362
AVFormatContext::streams
AVStream ** streams
Definition: avformat.h:992
mxf_absolute_bodysid_offset
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:1024
MXFPartition::complete
int complete
Definition: mxfdec.c:79
mxf_klv_key
static const uint8_t mxf_klv_key[]
Definition: mxfdec.c:254
MXFMetadataReadFunc
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:238
av_q2d
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
mxf_compute_index_tables
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
Definition: mxfdec.c:1227
MXFIndexTable::segments
MXFIndexTableSegment ** segments
Definition: mxfdec.c:202
ff_mxf_codec_uls
const MXFCodecUL ff_mxf_codec_uls[]
Definition: mxf.c:34
AVPacket::data
uint8_t * data
Definition: libavcodec/avcodec.h:1051
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
mxf_sony_mpeg4_extradata
static const uint8_t mxf_sony_mpeg4_extradata[]
Definition: mxfdec.c:259
tag
uint32_t tag
Definition: movenc.c:894
Frame
Definition: mxfdec.c:233
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
pix_fmt
enum AVPixelFormat pix_fmt
Definition: v4l.c:63
av_get_packet
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: libavformat/utils.c:328
OP1b
Definition: mxfdec.c:65
Track
Definition: ismindex.c:61
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:675
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:248
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: libavcodec/avcodec.h:2546
mxf_intra_only_essence_container_uls
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition: mxfdec.c:936
MXFDescriptor::vert_subsampling
unsigned int vert_subsampling
Definition: mxfdec.c:155
MXFTrack::intra_only
int intra_only
Definition: mxfdec.c:135
MXFPartition::kag_size
int32_t kag_size
Definition: mxfdec.c:87
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: libavutil/timecode.h:33
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:478
mxf_get_sorted_table_segments
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
Definition: mxfdec.c:956
AV_CODEC_ID_DVVIDEO
Definition: libavcodec/avcodec.h:127
MXFTrack::track_number
uint8_t track_number[4]
Definition: mxfdec.c:133
mxf_timestamp_to_str
static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
Definition: mxfdec.c:1661
MXFTrack::original_duration
int64_t original_duration
duration before multiplying st->duration by SampleRate/EditRate
Definition: mxfdec.c:137
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:130
SET_UID_METADATA
#define SET_UID_METADATA(pb, name, var, str)
Definition: mxfdec.c:1689
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
mxf_read_sync
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:278
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:599
MXFContext::metadata_sets_count
int metadata_sets_count
Definition: mxfdec.c:213
MXFDescriptor::essence_container_ul
UID essence_container_ul
Definition: mxfdec.c:143
AV_CODEC_ID_PCM_ALAW
Definition: libavcodec/avcodec.h:306
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: libavcodec/avcodec.h:99
MXFStructuralComponent::start_position
int64_t start_position
Definition: mxfdec.c:105
MXFContext::last_forward_partition
int last_forward_partition
Definition: mxfdec.c:225
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: libavcodec/utils.c:2690
AVFormatContext::metadata
AVDictionary * metadata
Definition: avformat.h:1092
av_free
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:183
mxf_read_timecode_component
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:643
MXFPartitionType
MXFPartitionType
Definition: mxfdec.c:57
mxf_read_pixel_layout
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
Definition: mxfdec.c:787
MXFDescriptor::essence_codec_ul
UID essence_codec_ul
Definition: mxfdec.c:144
MXFIndexTableSegment::temporal_offset_entries
int8_t * temporal_offset_entries
Definition: mxfdec.c:173
mxf_add_timecode_metadata
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
Definition: mxfdec.c:1321
AV_RB16
#define AV_RB16
Definition: avr32/intreadwrite.h:53
mxf_read_sequence
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:681
mxf_edit_unit_absolute_offset
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:1074
MXFPackage::descriptor
MXFDescriptor * descriptor
Definition: mxfdec.c:185
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:593
MXFIndexTableSegment::index_start_position
uint64_t index_start_position
Definition: mxfdec.c:171
MXFIndexTable::nb_ptses
int nb_ptses
Definition: mxfdec.c:198
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: libavutil/internal.h:123
mxf_read_index_entry_array
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
Definition: mxfdec.c:727
MXFCodecUL::matching_len
unsigned matching_len
Definition: mxf.h:66
mxf_intra_only_picture_essence_coding_uls
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
Definition: mxfdec.c:942
OneField
Definition: mxf.h:53
arg
const char * arg
Definition: libavcodec/jacosubdec.c:69
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:144
KLVPacket::length
uint64_t length
Definition: mxf.h:61
mxf_sound_essence_container_uls
static const MXFCodecUL mxf_sound_essence_container_uls[]
Definition: mxfdec.c:947
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
av_log
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
mxf_parse_handle_essence
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
Definition: mxfdec.c:1851
IS_KLV_KEY
#define IS_KLV_KEY(x, y)
Definition: mxfdec.c:261
av_aes_alloc
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:44
round_to_kag
static int64_t round_to_kag(int64_t position, int kag_size)
Definition: mxfdec.c:1930
codec_id
enum AVCodecID codec_id
Definition: mov_chan.c:433
MXFTrack::track_id
int track_id
Definition: mxfdec.c:132
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:70
MXFPackage::package_uid
UID package_uid
Definition: mxfdec.c:182
FFMAX
#define FFMAX(a, b)
Definition: common.h:56
MXFPartition::essence_length
int64_t essence_length
Definition: mxfdec.c:86
mxf_read_source_clip
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:605
MXFSequence::duration
int64_t duration
Definition: mxfdec.c:115
size
int size
Definition: twinvq_data.h:11127
mxf_match_uid
static int mxf_match_uid(const UID key, const UID uid, int len)
Definition: mxfdec.c:892
MXFContext::packages_count
int packages_count
Definition: mxfdec.c:211
AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:583
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:469
AVStream::codec
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:662
MXFPartition::index_byte_count
int64_t index_byte_count
Definition: mxfdec.c:89
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:337
ff_mxf_decode_pixel_layout
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition: mxf.c:96
ff_mxf_pixel_format_uls
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition: mxf.c:60
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:336
segment
Definition: hls.c:58
FF_INPUT_BUFFER_PADDING_SIZE
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: libavcodec/avcodec.h:561
AVFormatContext::nb_streams
unsigned int nb_streams
A list of all streams in the file.
Definition: avformat.h:991
MXFIndexTable::nb_segments
int nb_segments
Definition: mxfdec.c:201
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Definition: log.h:157
mxf_get_codec_ul
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition: mxfdec.c:902
AVRational
struct AVRational AVRational
rational number numerator/denominator
MXFContext::partitions
MXFPartition * partitions
Definition: mxfdec.c:207
mxf_essence_element_key
static const uint8_t mxf_essence_element_key[]
Definition: mxfdec.c:251
mxf_resolve_strong_ref
static void * mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
Definition: mxfdec.c:912
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:117
mxf_read_utf16_string
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str)
Definition: mxfdec.c:1622
MXFContext::local_tags_count
int local_tags_count
Definition: mxfdec.c:217
MXFDescriptor::horiz_subsampling
unsigned int horiz_subsampling
Definition: mxfdec.c:154
av_rescale
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:118
mxf_encrypted_triplet_key
static const uint8_t mxf_encrypted_triplet_key[]
Definition: mxfdec.c:257
FFMIN
#define FFMIN(a, b)
Definition: common.h:58
MXFDescriptor::pix_fmt
enum AVPixelFormat pix_fmt
Definition: mxfdec.c:161
read_probe
static int read_probe(AVProbeData *pd)
Definition: libavformat/jvdec.c:54
MXFSequence::uid
UID uid
Definition: mxfdec.c:110
MXFPartition::essence_offset
int64_t essence_offset
absolute offset of essence
Definition: mxfdec.c:85
MXFTimecodeComponent::rate
struct AVRational rate
Definition: mxfdec.c:123
ret
ret
Definition: avfilter.c:821
AVCodecContext::width
int width
picture width / height.
Definition: libavcodec/avcodec.h:1302
mxf_read_material_package
static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:627
MXFContext::edit_units_per_packet
int edit_units_per_packet
how many edit units to read at a time (PCM, OPAtom)
Definition: mxfdec.c:229
MXFContext::last_forward_tell
int64_t last_forward_tell
Definition: mxfdec.c:224
t
t
Definition: genspecsines3.m:6
mxf_header_partition_pack_key
static const uint8_t mxf_header_partition_pack_key[]
Definition: mxfdec.c:250
int32_t
int32_t
Definition: audio_convert.c:194
mxf_read_primer_pack
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:408
OP2b
Definition: mxfdec.c:68
MXFPartition::this_partition
int64_t this_partition
Definition: mxfdec.c:84
mxf_decrypt_triplet
static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
Definition: mxfdec.c:345
mxf_read_identification_metadata
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
Definition: mxfdec.c:1703
mxf_get_stream_index
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
Definition: mxfdec.c:302
mxf_handle_small_eubc
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:1949
ff_mxf_data_definition_uls
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
Definition: mxf.c:28
MXFDescriptor::sub_descriptors_refs
UID * sub_descriptors_refs
Definition: mxfdec.c:156
mxf_read_source_package
static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:703
AV_CODEC_ID_PCM_S16BE
Definition: libavcodec/avcodec.h:300
url_feof
int url_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:280
AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: libavcodec/avcodec.h:104
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: libavcodec/utils.c:2416
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:517
MXFIndexTableSegment::index_duration
uint64_t index_duration
Definition: mxfdec.c:172
AVStream
Stream structure.
Definition: avformat.h:643
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
av_aes_init
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
Definition: aes.c:193
k
for k
Definition: genspecsines_sin.m:6
NULL
NULL
Definition: eval.c:55
code
or the Software in violation of any applicable export control laws in any jurisdiction Except as provided by mandatorily applicable UPF has no obligation to provide you with source code to the Software In the event Software contains any source code
Definition: MELODIA - License.txt:24
sample_rate
sample_rate
Definition: ffmpeg_filter.c:169
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: libavcodec/avcodec.h:1142
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: libavcodec/avcodec.h:1145
MXFDescriptor::sub_descriptors_count
int sub_descriptors_count
Definition: mxfdec.c:157
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: libavcodec/avcodec.h:1861
MXFContext::nb_index_tables
int nb_index_tables
Definition: mxfdec.c:227
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:977
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: libavutil/timecode.c:84
mxf_read_generic_descriptor
static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:807
mxf_encrypted_essence_container
static const uint8_t mxf_encrypted_essence_container[]
Definition: mxfdec.c:258
OP1a
Definition: mxfdec.c:64
MXFSamplesPerFrame::samples_per_frame
int samples_per_frame[6]
Definition: mxf.h:72
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
ff_generate_avci_extradata
void ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: libavformat/utils.c:4368
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
buf
void * buf
Definition: avisynth_c.h:594
MXFContext::run_in
int run_in
Definition: mxfdec.c:221
read_packet
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
Definition: libcdio.c:114
av_dict_set
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:62
value
double value
Definition: eval.c:82
av_malloc
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
MXFDescriptor::aspect_ratio
AVRational aspect_ratio
Definition: mxfdec.c:146
index
int index
Definition: gxfenc.c:89
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
FullFrame
Definition: mxf.h:51
AVRational
rational number numerator/denominator
Definition: rational.h:43
mxf_read_partition_pack
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:430
MXFPartition::type
MXFPartitionType type
Definition: mxfdec.c:80
mxf_system_item_key
static const uint8_t mxf_system_item_key[]
Definition: mxfdec.c:253
MXFContext::aesc
struct AVAES * aesc
Definition: mxfdec.c:215
MXFContext::fc
AVFormatContext * fc
Definition: mxfdec.c:214
AV_CODEC_ID_PCM_S24LE
Definition: libavcodec/avcodec.h:311
MXFDescriptor::extradata
uint8_t * extradata
Definition: mxfdec.c:159
MXFContext::partitions_count
unsigned partitions_count
Definition: mxfdec.c:208
MXFDescriptor::sample_rate
AVRational sample_rate
Definition: mxfdec.c:145
snprintf
#define snprintf
Definition: snprintf.h:34
AV_CODEC_ID_MP2
Definition: libavcodec/avcodec.h:381
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:334
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Buffer references ownership and permissions
MXFCodecUL
Definition: mxf.h:64
type
#define type
MXFContext::local_tags
uint8_t * local_tags
Definition: mxfdec.c:216
AV_FIELD_PROGRESSIVE
Definition: libavcodec/avcodec.h:1118
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
Definition: mem.c:213
MXFDescriptor::channels
int channels
Definition: mxfdec.c:150
brsc.track
track
Definition: brsc.py:18
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:122
flags
static int flags
Definition: cpu.c:23
klv_decode_ber_length
static int64_t klv_decode_ber_length(AVIOContext *pb)
Definition: mxfdec.c:263
n
n
Definition: genspecsines_sin.m:10
MXFWrappingScheme
MXFWrappingScheme
Definition: mxfdec.c:232
av_timecode_init
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: libavutil/timecode.c:182
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:696
OP3b
Definition: mxfdec.c:71
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score, half of that is used for file-extension-based detection
Definition: avformat.h:340
AVFormatContext::key
const uint8_t * key
Definition: avformat.h:1047
MXFContext::parsing_backward
int parsing_backward
Definition: mxfdec.c:223
op
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: libavcodec/anm.c:76
AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:582
avformat.h
Main libavformat public API header.
mxf_read_content_storage
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:589
MXFPackage::tracks_count
int tracks_count
Definition: mxfdec.c:184
Sequence
Definition: mxf.h:36
MXFIndexTable::body_sid
int body_sid
Definition: mxfdec.c:197
mxf_picture_essence_container_uls
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition: mxfdec.c:927
avio_get_str16be
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
mxf_set_audio_pts
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
Definition: mxfdec.c:2198
MXFDescriptor::height
int height
Definition: mxfdec.c:148
OPAtom
Definition: mxfdec.c:73
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:689
MXFMetadataReadTableEntry::read
MXFMetadataReadFunc * read
Definition: mxfdec.c:242
OP1c
Definition: mxfdec.c:66
OP3c
Definition: mxfdec.c:72
AV_CODEC_ID_PCM_S16LE
Definition: libavcodec/avcodec.h:299
MXFDescriptor::field_dominance
int field_dominance
Definition: mxfdec.c:152
ff_mxf_demuxer
AVInputFormat ff_mxf_demuxer
Definition: mxfdec.c:2504
MXFPackage::uid
UID uid
Definition: mxfdec.c:180
AVRational::den
int den
denominator
Definition: rational.h:45
MXFIndexTable::fake_index
AVIndexEntry * fake_index
Definition: mxfdec.c:203
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:12
MXFSequence::structural_components_count
int structural_components_count
Definition: mxfdec.c:114
MXFSequence::data_definition_ul
UID data_definition_ul
Definition: mxfdec.c:112
MXFMetadataSet::type
enum MXFMetadataSetType type
Definition: mxfdec.c:191
mxf_read_cryptographic_context
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:579
MXFPartition::body_sid
int body_sid
Definition: mxfdec.c:83
mxf_compute_ptses_fake_index
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
Definition: mxfdec.c:1122
MXFContext::current_klv_index
int current_klv_index
Definition: mxfdec.c:220
len
int len
Definition: vorbis_enc_data.h:452
MXFIndexTableSegment::stream_offset_entries
uint64_t * stream_offset_entries
Definition: mxfdec.c:175
AVCodecContext::channels
int channels
number of audio channels
Definition: libavcodec/avcodec.h:1862
mxf_add_metadata_set
static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
Definition: mxfdec.c:565
MXFContext::op
MXFOP op
Definition: mxfdec.c:209
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:964
mxf_essence_container_end
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:1053
MXFDescriptor::extradata_size
int extradata_size
Definition: mxfdec.c:160
MXFTrack::uid
UID uid
Definition: mxfdec.c:128
mxf_read_track
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:660
SET_STR_METADATA
#define SET_STR_METADATA(pb, name, str)
Definition: mxfdec.c:1683
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: libavcodec/avcodec.h:1050
mxf_set_current_edit_unit
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
Sets mxf->current_edit_unit based on what offset we&#39;re currently at.
Definition: mxfdec.c:2124
AVFormatContext::bit_rate
int bit_rate
Decoding: total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1016
MXFContext::metadata_sets
MXFMetadataSet ** metadata_sets
Definition: mxfdec.c:212
AV_LOG_INFO
#define AV_LOG_INFO
Definition: log.h:156
mxf_read_packet_old
static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:2208
mxf_compute_sample_count
static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
Definition: mxfdec.c:2161
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: libavcodec/avcodec.h:1858
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:461
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:143
AV_CODEC_ID_PCM_S32LE
Definition: libavcodec/avcodec.h:307
AV_CODEC_ID_RAWVIDEO
Definition: libavcodec/avcodec.h:116
MXFContext::index_tables
MXFIndexTable * index_tables
Definition: mxfdec.c:228
length
const char int length
Definition: avisynth_c.h:668
MXFCodecUL::uid
UID uid
Definition: mxf.h:65
MXFPartition::pack_length
int pack_length
Definition: mxfdec.c:90
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:679
AVAES
Definition: aes.c:34
MXFTrack::edit_rate
AVRational edit_rate
Definition: mxfdec.c:134
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:702
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
AVPacket
This structure stores compressed data.
Definition: libavcodec/avcodec.h:1028
MXFPartition::index_sid
int index_sid
Definition: mxfdec.c:82
AnyType
Definition: mxf.h:31
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: libavcodec/avcodec.h:1044
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:467
Header
Definition: mxfdec.c:58
MXFTrack::sample_count
uint64_t sample_count
Definition: mxfdec.c:136
MXFContext::current_partition
MXFPartition * current_partition
Definition: mxfdec.c:222
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:190
AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
Definition: libavutil/timecode.h:36
MXFPartition::previous_partition
uint64_t previous_partition
Definition: mxfdec.c:81
AV_CODEC_ID_PCM_S32BE
Definition: libavcodec/avcodec.h:308
MXFPartition::header_byte_count
int64_t header_byte_count
Definition: mxfdec.c:88
MXFPackage::descriptor_ref
UID descriptor_ref
Definition: mxfdec.c:186
Generated on Fri Dec 20 2024 06:56:04 for FFmpeg by   doxygen 1.8.11