FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  *
32  * Principle
33  * Search for Track numbers which will identify essence element KLV packets.
34  * Search for SourcePackage which define tracks which contains Track numbers.
35  * Material Package contains tracks with reference to SourcePackage tracks.
36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37  * Assign Descriptors to correct Tracks.
38  *
39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40  * Metadata parsing resolves Strong References to objects.
41  *
42  * Simple demuxer, only OP1A supported and some files might not work at all.
43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
44  */
45 
46 //#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  unsigned int component_depth;
153  unsigned int horiz_subsampling;
154  unsigned int vert_subsampling;
155  UID *sub_descriptors_refs;
156  int sub_descriptors_count;
157  int linked_track_id;
158  uint8_t *extradata;
159  int extradata_size;
160  enum AVPixelFormat pix_fmt;
161 } MXFDescriptor;
162 
163 typedef struct {
164  UID uid;
165  enum MXFMetadataSetType type;
166  int edit_unit_byte_count;
167  int index_sid;
168  int body_sid;
169  AVRational index_edit_rate;
170  uint64_t index_start_position;
171  uint64_t index_duration;
172  int8_t *temporal_offset_entries;
173  int *flag_entries;
174  uint64_t *stream_offset_entries;
175  int nb_index_entries;
176 } MXFIndexTableSegment;
177 
178 typedef struct {
179  UID uid;
180  enum MXFMetadataSetType type;
181  UID package_uid;
182  UID *tracks_refs;
183  int tracks_count;
184  MXFDescriptor *descriptor; /* only one */
185  UID descriptor_ref;
186 } MXFPackage;
187 
188 typedef struct {
189  UID uid;
190  enum MXFMetadataSetType type;
191 } MXFMetadataSet;
192 
193 /* decoded index table */
194 typedef struct {
195  int index_sid;
196  int body_sid;
197  int nb_ptses; /* number of PTSes or total duration of index */
198  int64_t first_dts; /* DTS = EditUnit + first_dts */
199  int64_t *ptses; /* maps EditUnit -> PTS */
200  int nb_segments;
201  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
202  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
203 } MXFIndexTable;
204 
205 typedef struct {
206  MXFPartition *partitions;
207  unsigned partitions_count;
208  MXFOP op;
209  UID *packages_refs;
210  int packages_count;
211  MXFMetadataSet **metadata_sets;
212  int metadata_sets_count;
213  AVFormatContext *fc;
214  struct AVAES *aesc;
215  uint8_t *local_tags;
216  int local_tags_count;
217  uint64_t footer_partition;
218  KLVPacket current_klv_data;
219  int current_klv_index;
220  int run_in;
221  MXFPartition *current_partition;
222  int parsing_backward;
223  int64_t last_forward_tell;
224  int last_forward_partition;
225  int current_edit_unit;
226  int nb_index_tables;
227  MXFIndexTable *index_tables;
228  int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
229 } MXFContext;
230 
231 enum MXFWrappingScheme {
232  Frame,
233  Clip,
234 };
235 
236 /* NOTE: klv_offset is not set (-1) for local keys */
237 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
238 
239 typedef struct {
240  const UID key;
241  MXFMetadataReadFunc *read;
242  int ctx_size;
243  enum MXFMetadataSetType type;
244 } MXFMetadataReadTableEntry;
245 
246 static int mxf_read_close(AVFormatContext *s);
247 
248 /* partial keys to match */
249 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
250 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
251 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
252 static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
253 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
254 /* complete keys to match */
255 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 };
256 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
257 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
258 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
259 
260 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
261 
262 static int64_t klv_decode_ber_length(AVIOContext *pb)
263 {
264  uint64_t size = avio_r8(pb);
265  if (size & 0x80) { /* long form */
266  int bytes_num = size & 0x7f;
267  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
268  if (bytes_num > 8)
269  return AVERROR_INVALIDDATA;
270  size = 0;
271  while (bytes_num--)
272  size = size << 8 | avio_r8(pb);
273  }
274  return size;
275 }
276 
277 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
278 {
279  int i, b;
280  for (i = 0; i < size && !url_feof(pb); i++) {
281  b = avio_r8(pb);
282  if (b == key[0])
283  i = 0;
284  else if (b != key[i])
285  i = -1;
286  }
287  return i == size;
288 }
289 
290 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
291 {
292  if (!mxf_read_sync(pb, mxf_klv_key, 4))
293  return AVERROR_INVALIDDATA;
294  klv->offset = avio_tell(pb) - 4;
295  memcpy(klv->key, mxf_klv_key, 4);
296  avio_read(pb, klv->key + 4, 12);
297  klv->length = klv_decode_ber_length(pb);
298  return klv->length == -1 ? -1 : 0;
299 }
300 
301 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
302 {
303  int i;
304 
305  for (i = 0; i < s->nb_streams; i++) {
306  MXFTrack *track = s->streams[i]->priv_data;
307  /* SMPTE 379M 7.3 */
308  if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
309  return i;
310  }
311  /* return 0 if only one stream, for OP Atom files with 0 as track number */
312  return s->nb_streams == 1 ? 0 : -1;
313 }
314 
315 /* XXX: use AVBitStreamFilter */
316 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
317 {
318  const uint8_t *buf_ptr, *end_ptr;
319  uint8_t *data_ptr;
320  int i;
321 
322  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
323  return AVERROR_INVALIDDATA;
324  length = av_get_packet(pb, pkt, length);
325  if (length < 0)
326  return length;
327  data_ptr = pkt->data;
328  end_ptr = pkt->data + length;
329  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
330  for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
331  for (i = 0; i < st->codec->channels; i++) {
332  uint32_t sample = bytestream_get_le32(&buf_ptr);
333  if (st->codec->bits_per_coded_sample == 24)
334  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
335  else
336  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
337  }
338  buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
339  }
340  av_shrink_packet(pkt, data_ptr - pkt->data);
341  return 0;
342 }
343 
344 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
345 {
346  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
347  MXFContext *mxf = s->priv_data;
348  AVIOContext *pb = s->pb;
349  int64_t end = avio_tell(pb) + klv->length;
350  int64_t size;
351  uint64_t orig_size;
352  uint64_t plaintext_size;
353  uint8_t ivec[16];
354  uint8_t tmpbuf[16];
355  int index;
356 
357  if (!mxf->aesc && s->key && s->keylen == 16) {
358  mxf->aesc = av_aes_alloc();
359  if (!mxf->aesc)
360  return AVERROR(ENOMEM);
361  av_aes_init(mxf->aesc, s->key, 128, 1);
362  }
363  // crypto context
364  avio_skip(pb, klv_decode_ber_length(pb));
365  // plaintext offset
366  klv_decode_ber_length(pb);
367  plaintext_size = avio_rb64(pb);
368  // source klv key
369  klv_decode_ber_length(pb);
370  avio_read(pb, klv->key, 16);
371  if (!IS_KLV_KEY(klv, mxf_essence_element_key))
372  return AVERROR_INVALIDDATA;
373  index = mxf_get_stream_index(s, klv);
374  if (index < 0)
375  return AVERROR_INVALIDDATA;
376  // source size
377  klv_decode_ber_length(pb);
378  orig_size = avio_rb64(pb);
379  if (orig_size < plaintext_size)
380  return AVERROR_INVALIDDATA;
381  // enc. code
382  size = klv_decode_ber_length(pb);
383  if (size < 32 || size - 32 < orig_size)
384  return AVERROR_INVALIDDATA;
385  avio_read(pb, ivec, 16);
386  avio_read(pb, tmpbuf, 16);
387  if (mxf->aesc)
388  av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
389  if (memcmp(tmpbuf, checkv, 16))
390  av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
391  size -= 32;
392  size = av_get_packet(pb, pkt, size);
393  if (size < 0)
394  return size;
395  else if (size < plaintext_size)
396  return AVERROR_INVALIDDATA;
397  size -= plaintext_size;
398  if (mxf->aesc)
399  av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
400  &pkt->data[plaintext_size], size >> 4, ivec, 1);
401  av_shrink_packet(pkt, orig_size);
402  pkt->stream_index = index;
403  avio_skip(pb, end - avio_tell(pb));
404  return 0;
405 }
406 
407 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
408 {
409  MXFContext *mxf = arg;
410  int item_num = avio_rb32(pb);
411  int item_len = avio_rb32(pb);
412 
413  if (item_len != 18) {
414  av_log_ask_for_sample(pb, "unsupported primer pack item length %d\n",
415  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 0x3301:
843  descriptor->component_depth = avio_rb32(pb);
844  break;
845  case 0x3302:
846  descriptor->horiz_subsampling = avio_rb32(pb);
847  break;
848  case 0x3308:
849  descriptor->vert_subsampling = avio_rb32(pb);
850  break;
851  case 0x3D03:
852  descriptor->sample_rate.num = avio_rb32(pb);
853  descriptor->sample_rate.den = avio_rb32(pb);
854  break;
855  case 0x3D06: /* SoundEssenceCompression */
856  avio_read(pb, descriptor->essence_codec_ul, 16);
857  break;
858  case 0x3D07:
859  descriptor->channels = avio_rb32(pb);
860  break;
861  case 0x3D01:
862  descriptor->bits_per_sample = avio_rb32(pb);
863  break;
864  case 0x3401:
865  mxf_read_pixel_layout(pb, descriptor);
866  break;
867  default:
868  /* Private uid used by SONY C0023S01.mxf */
869  if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
870  if (descriptor->extradata)
871  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
872  av_free(descriptor->extradata);
873  descriptor->extradata_size = 0;
874  descriptor->extradata = av_malloc(size);
875  if (!descriptor->extradata)
876  return AVERROR(ENOMEM);
877  descriptor->extradata_size = size;
878  avio_read(pb, descriptor->extradata, size);
879  }
880  break;
881  }
882  return 0;
883 }
884 
885 /*
886  * Match an uid independently of the version byte and up to len common bytes
887  * Returns: boolean
888  */
889 static int mxf_match_uid(const UID key, const UID uid, int len)
890 {
891  int i;
892  for (i = 0; i < len; i++) {
893  if (i != 7 && key[i] != uid[i])
894  return 0;
895  }
896  return 1;
897 }
898 
899 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
900 {
901  while (uls->uid[0]) {
902  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
903  break;
904  uls++;
905  }
906  return uls;
907 }
908 
909 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
910 {
911  int i;
912 
913  if (!strong_ref)
914  return NULL;
915  for (i = 0; i < mxf->metadata_sets_count; i++) {
916  if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
917  (type == AnyType || mxf->metadata_sets[i]->type == type)) {
918  return mxf->metadata_sets[i];
919  }
920  }
921  return NULL;
922 }
923 
924 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
925  // video essence container uls
926  { { 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 */
927  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
928  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
929  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
930 };
931 
932 /* EC ULs for intra-only formats */
933 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
934  { { 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 */
935  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
936 };
937 
938 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
939 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
940  { { 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 */
941  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
942 };
943 
944 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
945  // sound essence container uls
946  { { 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 */
947  { { 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 */
948  { { 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 */
949  { { 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 */
950  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
951 };
952 
953 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
954 {
955  int i, j, nb_segments = 0;
956  MXFIndexTableSegment **unsorted_segments;
957  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
958 
959  /* count number of segments, allocate arrays and copy unsorted segments */
960  for (i = 0; i < mxf->metadata_sets_count; i++)
961  if (mxf->metadata_sets[i]->type == IndexTableSegment)
962  nb_segments++;
963 
964  if (!nb_segments)
965  return AVERROR_INVALIDDATA;
966 
967  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
968  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
969  av_freep(sorted_segments);
970  av_free(unsorted_segments);
971  return AVERROR(ENOMEM);
972  }
973 
974  for (i = j = 0; i < mxf->metadata_sets_count; i++)
975  if (mxf->metadata_sets[i]->type == IndexTableSegment)
976  unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
977 
978  *nb_sorted_segments = 0;
979 
980  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
981  for (i = 0; i < nb_segments; i++) {
982  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
983  uint64_t best_index_duration = 0;
984 
985  for (j = 0; j < nb_segments; j++) {
986  MXFIndexTableSegment *s = unsorted_segments[j];
987 
988  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
989  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
990  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
991  */
992  if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
993  (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
994  (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
995  best = j;
996  best_body_sid = s->body_sid;
997  best_index_sid = s->index_sid;
998  best_index_start = s->index_start_position;
999  best_index_duration = s->index_duration;
1000  }
1001  }
1002 
1003  /* no suitable entry found -> we're done */
1004  if (best == -1)
1005  break;
1006 
1007  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1008  last_body_sid = best_body_sid;
1009  last_index_sid = best_index_sid;
1010  last_index_start = best_index_start;
1011  }
1012 
1013  av_free(unsorted_segments);
1014 
1015  return 0;
1016 }
1017 
1018 /**
1019  * Computes the absolute file offset of the given essence container offset
1020  */
1021 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1022 {
1023  int x;
1024  int64_t offset_in = offset; /* for logging */
1025 
1026  for (x = 0; x < mxf->partitions_count; x++) {
1027  MXFPartition *p = &mxf->partitions[x];
1028 
1029  if (p->body_sid != body_sid)
1030  continue;
1031 
1032  if (offset < p->essence_length || !p->essence_length) {
1033  *offset_out = p->essence_offset + offset;
1034  return 0;
1035  }
1036 
1037  offset -= p->essence_length;
1038  }
1039 
1040  av_log(mxf->fc, AV_LOG_ERROR,
1041  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1042  offset_in, body_sid);
1043 
1044  return AVERROR_INVALIDDATA;
1045 }
1046 
1047 /**
1048  * Returns the end position of the essence container with given BodySID, or zero if unknown
1049  */
1050 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1051 {
1052  int x;
1053  int64_t ret = 0;
1054 
1055  for (x = 0; x < mxf->partitions_count; x++) {
1056  MXFPartition *p = &mxf->partitions[x];
1057 
1058  if (p->body_sid != body_sid)
1059  continue;
1060 
1061  if (!p->essence_length)
1062  return 0;
1063 
1064  ret = p->essence_offset + p->essence_length;
1065  }
1066 
1067  return ret;
1068 }
1069 
1070 /* EditUnit -> absolute offset */
1071 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)
1072 {
1073  int i;
1074  int64_t offset_temp = 0;
1075 
1076  for (i = 0; i < index_table->nb_segments; i++) {
1077  MXFIndexTableSegment *s = index_table->segments[i];
1078 
1079  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1080 
1081  if (edit_unit < s->index_start_position + s->index_duration) {
1082  int64_t index = edit_unit - s->index_start_position;
1083 
1084  if (s->edit_unit_byte_count)
1085  offset_temp += s->edit_unit_byte_count * index;
1086  else if (s->nb_index_entries) {
1087  if (s->nb_index_entries == 2 * s->index_duration + 1)
1088  index *= 2; /* Avid index */
1089 
1090  if (index < 0 || index >= s->nb_index_entries) {
1091  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1092  index_table->index_sid, s->index_start_position);
1093  return AVERROR_INVALIDDATA;
1094  }
1095 
1096  offset_temp = s->stream_offset_entries[index];
1097  } else {
1098  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1099  index_table->index_sid, s->index_start_position);
1100  return AVERROR_INVALIDDATA;
1101  }
1102 
1103  if (edit_unit_out)
1104  *edit_unit_out = edit_unit;
1105 
1106  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1107  } else {
1108  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1109  offset_temp += s->edit_unit_byte_count * s->index_duration;
1110  }
1111  }
1112 
1113  if (nag)
1114  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);
1115 
1116  return AVERROR_INVALIDDATA;
1117 }
1118 
1119 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1120 {
1121  int i, j, x;
1122  int8_t max_temporal_offset = -128;
1123 
1124  /* first compute how many entries we have */
1125  for (i = 0; i < index_table->nb_segments; i++) {
1126  MXFIndexTableSegment *s = index_table->segments[i];
1127 
1128  if (!s->nb_index_entries) {
1129  index_table->nb_ptses = 0;
1130  return 0; /* no TemporalOffsets */
1131  }
1132 
1133  index_table->nb_ptses += s->index_duration;
1134  }
1135 
1136  /* paranoid check */
1137  if (index_table->nb_ptses <= 0)
1138  return 0;
1139 
1140  if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1141  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1142  av_freep(&index_table->ptses);
1143  return AVERROR(ENOMEM);
1144  }
1145 
1146  /* we may have a few bad TemporalOffsets
1147  * make sure the corresponding PTSes don't have the bogus value 0 */
1148  for (x = 0; x < index_table->nb_ptses; x++)
1149  index_table->ptses[x] = AV_NOPTS_VALUE;
1150 
1151  /**
1152  * We have this:
1153  *
1154  * x TemporalOffset
1155  * 0: 0
1156  * 1: 1
1157  * 2: 1
1158  * 3: -2
1159  * 4: 1
1160  * 5: 1
1161  * 6: -2
1162  *
1163  * We want to transform it into this:
1164  *
1165  * x DTS PTS
1166  * 0: -1 0
1167  * 1: 0 3
1168  * 2: 1 1
1169  * 3: 2 2
1170  * 4: 3 6
1171  * 5: 4 4
1172  * 6: 5 5
1173  *
1174  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1175  * then settings mxf->first_dts = -max(TemporalOffset[x]).
1176  * The latter makes DTS <= PTS.
1177  */
1178  for (i = x = 0; i < index_table->nb_segments; i++) {
1179  MXFIndexTableSegment *s = index_table->segments[i];
1180  int index_delta = 1;
1181  int n = s->nb_index_entries;
1182 
1183  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1184  index_delta = 2; /* Avid index */
1185  /* ignore the last entry - it's the size of the essence container */
1186  n--;
1187  }
1188 
1189  for (j = 0; j < n; j += index_delta, x++) {
1190  int offset = s->temporal_offset_entries[j] / index_delta;
1191  int index = x + offset;
1192 
1193  if (x >= index_table->nb_ptses) {
1194  av_log(mxf->fc, AV_LOG_ERROR,
1195  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1196  s->nb_index_entries, s->index_duration);
1197  break;
1198  }
1199 
1200  index_table->fake_index[x].timestamp = x;
1201  index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1202 
1203  if (index < 0 || index >= index_table->nb_ptses) {
1204  av_log(mxf->fc, AV_LOG_ERROR,
1205  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1206  x, offset, index);
1207  continue;
1208  }
1209 
1210  index_table->ptses[index] = x;
1211  max_temporal_offset = FFMAX(max_temporal_offset, offset);
1212  }
1213  }
1214 
1215  index_table->first_dts = -max_temporal_offset;
1216 
1217  return 0;
1218 }
1219 
1220 /**
1221  * Sorts and collects index table segments into index tables.
1222  * Also computes PTSes if possible.
1223  */
1224 static int mxf_compute_index_tables(MXFContext *mxf)
1225 {
1226  int i, j, k, ret, nb_sorted_segments;
1227  MXFIndexTableSegment **sorted_segments = NULL;
1228 
1229  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1230  nb_sorted_segments <= 0) {
1231  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1232  return 0;
1233  }
1234 
1235  /* sanity check and count unique BodySIDs/IndexSIDs */
1236  for (i = 0; i < nb_sorted_segments; i++) {
1237  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1238  mxf->nb_index_tables++;
1239  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1240  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1241  ret = AVERROR_INVALIDDATA;
1242  goto finish_decoding_index;
1243  }
1244  }
1245 
1246  if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
1247  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1248  ret = AVERROR(ENOMEM);
1249  goto finish_decoding_index;
1250  }
1251 
1252  /* distribute sorted segments to index tables */
1253  for (i = j = 0; i < nb_sorted_segments; i++) {
1254  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1255  /* next IndexSID */
1256  j++;
1257  }
1258 
1259  mxf->index_tables[j].nb_segments++;
1260  }
1261 
1262  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1263  MXFIndexTable *t = &mxf->index_tables[j];
1264 
1265  if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
1266  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
1267  ret = AVERROR(ENOMEM);
1268  goto finish_decoding_index;
1269  }
1270 
1271  if (sorted_segments[i]->index_start_position)
1272  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1273  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1274 
1275  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1276  t->index_sid = sorted_segments[i]->index_sid;
1277  t->body_sid = sorted_segments[i]->body_sid;
1278 
1279  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1280  goto finish_decoding_index;
1281 
1282  /* fix zero IndexDurations */
1283  for (k = 0; k < t->nb_segments; k++) {
1284  if (t->segments[k]->index_duration)
1285  continue;
1286 
1287  if (t->nb_segments > 1)
1288  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1289  t->index_sid, k);
1290 
1291  if (mxf->fc->nb_streams <= 0) {
1292  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1293  break;
1294  }
1295 
1296  /* assume the first stream's duration is reasonable
1297  * leave index_duration = 0 on further segments in case we have any (unlikely)
1298  */
1299  t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1300  break;
1301  }
1302  }
1303 
1304  ret = 0;
1305 finish_decoding_index:
1306  av_free(sorted_segments);
1307  return ret;
1308 }
1309 
1310 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1311 {
1312  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1313  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1314  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1315  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1316 }
1317 
1318 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1319 {
1320  char buf[AV_TIMECODE_STR_SIZE];
1321  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1322 
1323  return 0;
1324 }
1325 
1326 static int mxf_parse_structural_metadata(MXFContext *mxf)
1327 {
1328  MXFPackage *material_package = NULL;
1329  MXFPackage *temp_package = NULL;
1330  int i, j, k, ret;
1331 
1332  av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1333  /* TODO: handle multiple material packages (OP3x) */
1334  for (i = 0; i < mxf->packages_count; i++) {
1335  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1336  if (material_package) break;
1337  }
1338  if (!material_package) {
1339  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1340  return AVERROR_INVALIDDATA;
1341  }
1342 
1343  for (i = 0; i < material_package->tracks_count; i++) {
1344  MXFPackage *source_package = NULL;
1345  MXFTrack *material_track = NULL;
1346  MXFTrack *source_track = NULL;
1347  MXFTrack *temp_track = NULL;
1348  MXFDescriptor *descriptor = NULL;
1349  MXFStructuralComponent *component = NULL;
1350  MXFTimecodeComponent *mxf_tc = NULL;
1351  UID *essence_container_ul = NULL;
1352  const MXFCodecUL *codec_ul = NULL;
1353  const MXFCodecUL *container_ul = NULL;
1354  const MXFCodecUL *pix_fmt_ul = NULL;
1355  AVStream *st;
1356  AVTimecode tc;
1357  int flags;
1358 
1359  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1360  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1361  continue;
1362  }
1363 
1364  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1365  mxf_tc = (MXFTimecodeComponent*)component;
1366  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1367  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1368  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1369  }
1370  }
1371 
1372  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1373  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1374  continue;
1375  }
1376 
1377  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1378  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1379  if (!component)
1380  continue;
1381 
1382  mxf_tc = (MXFTimecodeComponent*)component;
1383  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1384  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1385  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1386  break;
1387  }
1388  }
1389 
1390  /* TODO: handle multiple source clips */
1391  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1392  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1393  if (!component)
1394  continue;
1395 
1396  for (k = 0; k < mxf->packages_count; k++) {
1397  temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1398  if (!temp_package)
1399  continue;
1400  if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1401  source_package = temp_package;
1402  break;
1403  }
1404  }
1405  if (!source_package) {
1406  av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1407  break;
1408  }
1409  for (k = 0; k < source_package->tracks_count; k++) {
1410  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1411  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1412  ret = AVERROR_INVALIDDATA;
1413  goto fail_and_free;
1414  }
1415  if (temp_track->track_id == component->source_track_id) {
1416  source_track = temp_track;
1417  break;
1418  }
1419  }
1420  if (!source_track) {
1421  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1422  break;
1423  }
1424  }
1425  if (!source_track || !component)
1426  continue;
1427 
1428  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1429  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1430  ret = AVERROR_INVALIDDATA;
1431  goto fail_and_free;
1432  }
1433 
1434  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1435  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1436  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1437  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1438  continue;
1439  }
1440 
1441  st = avformat_new_stream(mxf->fc, NULL);
1442  if (!st) {
1443  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1444  ret = AVERROR(ENOMEM);
1445  goto fail_and_free;
1446  }
1447  st->id = source_track->track_id;
1448  st->priv_data = source_track;
1449  source_track->original_duration = st->duration = component->duration;
1450  if (st->duration == -1)
1451  st->duration = AV_NOPTS_VALUE;
1452  st->start_time = component->start_position;
1453  if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
1454  av_log(mxf->fc, AV_LOG_WARNING,
1455  "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1456  material_track->edit_rate.num, material_track->edit_rate.den, st->index);
1457  material_track->edit_rate = (AVRational){25, 1};
1458  }
1459  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1460 
1461  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
1462  source_track->edit_rate = material_track->edit_rate;
1463 
1464  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1465  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1466  st->codec->codec_type = codec_ul->id;
1467 
1468  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1469  if (source_package->descriptor) {
1470  if (source_package->descriptor->type == MultipleDescriptor) {
1471  for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1472  MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1473 
1474  if (!sub_descriptor) {
1475  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1476  continue;
1477  }
1478  if (sub_descriptor->linked_track_id == source_track->track_id) {
1479  descriptor = sub_descriptor;
1480  break;
1481  }
1482  }
1483  } else if (source_package->descriptor->type == Descriptor)
1484  descriptor = source_package->descriptor;
1485  }
1486  if (!descriptor) {
1487  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1488  continue;
1489  }
1490  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1491  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1492  essence_container_ul = &descriptor->essence_container_ul;
1493  /* HACK: replacing the original key with mxf_encrypted_essence_container
1494  * is not allowed according to s429-6, try to find correct information anyway */
1495  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1496  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1497  for (k = 0; k < mxf->metadata_sets_count; k++) {
1498  MXFMetadataSet *metadata = mxf->metadata_sets[k];
1499  if (metadata->type == CryptoContext) {
1500  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1501  break;
1502  }
1503  }
1504  }
1505 
1506  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1507  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1508  st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1509  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1510  avcodec_get_name(st->codec->codec_id));
1511  for (k = 0; k < 16; k++) {
1512  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1513  descriptor->essence_codec_ul[k]);
1514  if (!(k+1 & 19) || k == 5)
1515  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1516  }
1517  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1518  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1519  source_track->intra_only = mxf_is_intra_only(descriptor);
1520  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1521  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1522  st->codec->codec_id = container_ul->id;
1523  st->codec->width = descriptor->width;
1524  st->codec->height = descriptor->height; /* Field height, not frame height */
1525  switch (descriptor->frame_layout) {
1526  case SegmentedFrame:
1527  /* This one is a weird layout I don't fully understand. */
1528  av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1529  break;
1530  case FullFrame:
1531  st->codec->field_order = AV_FIELD_PROGRESSIVE;
1532  break;
1533  case OneField:
1534  /* Every other line is stored and needs to be duplicated. */
1535  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1536  break; /* The correct thing to do here is fall through, but by breaking we might be
1537  able to decode some streams at half the vertical resolution, rather than not al all.
1538  It's also for compatibility with the old behavior. */
1539  case MixedFields:
1540  break;
1541  case SeparateFields:
1542  st->codec->height *= 2; /* Turn field height into frame height. */
1543  break;
1544  default:
1545  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1546  }
1547  if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1548  st->codec->pix_fmt = descriptor->pix_fmt;
1549  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1550  pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1551  &descriptor->essence_codec_ul);
1552  st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1553  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1554  /* support files created before RP224v10 by defaulting to UYVY422
1555  if subsampling is 4:2:2 and component depth is 8-bit */
1556  if (descriptor->horiz_subsampling == 2 &&
1557  descriptor->vert_subsampling == 1 &&
1558  descriptor->component_depth == 8) {
1559  st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1560  }
1561  }
1562  }
1563  }
1564  st->need_parsing = AVSTREAM_PARSE_HEADERS;
1565  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1566  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1567  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1568  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))
1569  st->codec->codec_id = (enum AVCodecID)container_ul->id;
1570  st->codec->channels = descriptor->channels;
1571  st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1572 
1573  if (descriptor->sample_rate.den > 0) {
1574  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1575  st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1576  } else {
1577  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) found for stream #%d, time base forced to 1/48000\n",
1578  descriptor->sample_rate.num, descriptor->sample_rate.den, st->index);
1579  avpriv_set_pts_info(st, 64, 1, 48000);
1580  }
1581 
1582  /* if duration is set, rescale it from EditRate to SampleRate */
1583  if (st->duration != AV_NOPTS_VALUE)
1584  st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1585 
1586  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1587  if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1588  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1589  st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1590  else if (descriptor->bits_per_sample == 32)
1591  st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1592  } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1593  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1594  st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1595  else if (descriptor->bits_per_sample == 32)
1596  st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1597  } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1598  st->need_parsing = AVSTREAM_PARSE_FULL;
1599  }
1600  }
1601  if (descriptor->extradata) {
1602  st->codec->extradata = av_mallocz(descriptor->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1603  if (st->codec->extradata)
1604  memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1605  } else if(st->codec->codec_id == CODEC_ID_H264) {
1606  ff_generate_avci_extradata(st);
1607  }
1608  if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1609  /* TODO: decode timestamps */
1610  st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1611  }
1612  }
1613 
1614  ret = 0;
1615 fail_and_free:
1616  return ret;
1617 }
1618 
1619 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1620  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1621  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1622  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1623  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1624  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1625  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1626  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1627  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1628  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1629  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1630  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1631  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1632  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1633  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1634  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1635  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1636  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1637  { { 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 */
1638  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1639  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1640  { { 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 */
1641  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1642  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1643  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1644  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1645  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1646  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1647  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1648  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1649 };
1650 
1651 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1652 {
1653  AVIOContext *pb = mxf->fc->pb;
1654  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1655  uint64_t klv_end = avio_tell(pb) + klv->length;
1656 
1657  if (!ctx)
1658  return AVERROR(ENOMEM);
1659  while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1660  int ret;
1661  int tag = avio_rb16(pb);
1662  int size = avio_rb16(pb); /* KLV specified by 0x53 */
1663  uint64_t next = avio_tell(pb) + size;
1664  UID uid = {0};
1665 
1666  av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1667  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1668  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1669  continue;
1670  }
1671  if (tag > 0x7FFF) { /* dynamic tag */
1672  int i;
1673  for (i = 0; i < mxf->local_tags_count; i++) {
1674  int local_tag = AV_RB16(mxf->local_tags+i*18);
1675  if (local_tag == tag) {
1676  memcpy(uid, mxf->local_tags+i*18+2, 16);
1677  av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1678  PRINT_KEY(mxf->fc, "uid", uid);
1679  }
1680  }
1681  }
1682  if (ctx_size && tag == 0x3C0A)
1683  avio_read(pb, ctx->uid, 16);
1684  else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1685  return ret;
1686 
1687  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1688  * it extending past the end of the KLV though (zzuf5.mxf). */
1689  if (avio_tell(pb) > klv_end) {
1690  if (ctx_size)
1691  av_free(ctx);
1692 
1693  av_log(mxf->fc, AV_LOG_ERROR,
1694  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1695  tag, klv->offset);
1696  return AVERROR_INVALIDDATA;
1697  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1698  avio_seek(pb, next, SEEK_SET);
1699  }
1700  if (ctx_size) ctx->type = type;
1701  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1702 }
1703 
1704 /**
1705  * Seeks to the previous partition, if possible
1706  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1707  */
1708 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1709 {
1710  AVIOContext *pb = mxf->fc->pb;
1711 
1712  if (!mxf->current_partition ||
1713  mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1714  return 0; /* we've parsed all partitions */
1715 
1716  /* seek to previous partition */
1717  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1718  mxf->current_partition = NULL;
1719 
1720  av_dlog(mxf->fc, "seeking to previous partition\n");
1721 
1722  return 1;
1723 }
1724 
1725 /**
1726  * Called when essence is encountered
1727  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1728  */
1729 static int mxf_parse_handle_essence(MXFContext *mxf)
1730 {
1731  AVIOContext *pb = mxf->fc->pb;
1732  int64_t ret;
1733 
1734  if (mxf->parsing_backward) {
1735  return mxf_seek_to_previous_partition(mxf);
1736  } else {
1737  if (!mxf->footer_partition) {
1738  av_dlog(mxf->fc, "no footer\n");
1739  return 0;
1740  }
1741 
1742  av_dlog(mxf->fc, "seeking to footer\n");
1743 
1744  /* remember where we were so we don't end up seeking further back than this */
1745  mxf->last_forward_tell = avio_tell(pb);
1746 
1747  if (!pb->seekable) {
1748  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1749  return -1;
1750  }
1751 
1752  /* seek to footer partition and parse backward */
1753  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1754  av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1755  mxf->run_in + mxf->footer_partition, ret);
1756  return ret;
1757  }
1758 
1759  mxf->current_partition = NULL;
1760  mxf->parsing_backward = 1;
1761  }
1762 
1763  return 1;
1764 }
1765 
1766 /**
1767  * Called when the next partition or EOF is encountered
1768  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1769  */
1770 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1771 {
1772  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1773 }
1774 
1775 /**
1776  * Figures out the proper offset and length of the essence container in each partition
1777  */
1778 static void mxf_compute_essence_containers(MXFContext *mxf)
1779 {
1780  int x;
1781 
1782  /* everything is already correct */
1783  if (mxf->op == OPAtom)
1784  return;
1785 
1786  for (x = 0; x < mxf->partitions_count; x++) {
1787  MXFPartition *p = &mxf->partitions[x];
1788 
1789  if (!p->body_sid)
1790  continue; /* BodySID == 0 -> no essence */
1791 
1792  if (x >= mxf->partitions_count - 1)
1793  break; /* last partition - can't compute length (and we don't need to) */
1794 
1795  /* essence container spans to the next partition */
1796  p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1797 
1798  if (p->essence_length < 0) {
1799  /* next ThisPartition < essence_offset */
1800  p->essence_length = 0;
1801  av_log(mxf->fc, AV_LOG_ERROR,
1802  "partition %i: bad ThisPartition = %"PRIX64"\n",
1803  x+1, mxf->partitions[x+1].this_partition);
1804  }
1805  }
1806 }
1807 
1808 static int64_t round_to_kag(int64_t position, int kag_size)
1809 {
1810  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1811  /* NOTE: kag_size may be any integer between 1 - 2^10 */
1812  int64_t ret = (position / kag_size) * kag_size;
1813  return ret == position ? ret : ret + kag_size;
1814 }
1815 
1816 static int is_pcm(enum AVCodecID codec_id)
1817 {
1818  /* we only care about "normal" PCM codecs until we get samples */
1819  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1820 }
1821 
1822 /**
1823  * Deal with the case where for some audio atoms EditUnitByteCount is
1824  * very small (2, 4..). In those cases we should read more than one
1825  * sample per call to mxf_read_packet().
1826  */
1827 static void mxf_handle_small_eubc(AVFormatContext *s)
1828 {
1829  MXFContext *mxf = s->priv_data;
1830 
1831  /* assuming non-OPAtom == frame wrapped
1832  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1833  if (mxf->op != OPAtom)
1834  return;
1835 
1836  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1837  if (s->nb_streams != 1 ||
1838  s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1839  !is_pcm(s->streams[0]->codec->codec_id) ||
1840  mxf->nb_index_tables != 1 ||
1841  mxf->index_tables[0].nb_segments != 1 ||
1842  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1843  return;
1844 
1845  /* arbitrarily default to 48 kHz PAL audio frame size */
1846  /* TODO: We could compute this from the ratio between the audio
1847  * and video edit rates for 48 kHz NTSC we could use the
1848  * 1802-1802-1802-1802-1801 pattern. */
1849  mxf->edit_units_per_packet = 1920;
1850 }
1851 
1852 static int mxf_read_header(AVFormatContext *s)
1853 {
1854  MXFContext *mxf = s->priv_data;
1855  KLVPacket klv;
1856  int64_t essence_offset = 0;
1857  int ret;
1858 
1859  mxf->last_forward_tell = INT64_MAX;
1860  mxf->edit_units_per_packet = 1;
1861 
1862  if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
1863  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1864  return AVERROR_INVALIDDATA;
1865  }
1866  avio_seek(s->pb, -14, SEEK_CUR);
1867  mxf->fc = s;
1868  mxf->run_in = avio_tell(s->pb);
1869 
1870  while (!url_feof(s->pb)) {
1871  const MXFMetadataReadTableEntry *metadata;
1872 
1873  if (klv_read_packet(&klv, s->pb) < 0) {
1874  /* EOF - seek to previous partition or stop */
1875  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1876  break;
1877  else
1878  continue;
1879  }
1880 
1881  PRINT_KEY(s, "read header", klv.key);
1882  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
1883  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
1884  IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
1885  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
1886  IS_KLV_KEY(klv.key, mxf_system_item_key)) {
1887 
1888  if (!mxf->current_partition) {
1889  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
1890  return AVERROR_INVALIDDATA;
1891  }
1892 
1893  if (!mxf->current_partition->essence_offset) {
1894  /* for OP1a we compute essence_offset
1895  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
1896  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
1897  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
1898  */
1899  int64_t op1a_essence_offset =
1900  round_to_kag(mxf->current_partition->this_partition +
1901  mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
1902  round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
1903  round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
1904 
1905  if (mxf->op == OPAtom) {
1906  /* point essence_offset to the actual data
1907  * OPAtom has all the essence in one big KLV
1908  */
1909  mxf->current_partition->essence_offset = avio_tell(s->pb);
1910  mxf->current_partition->essence_length = klv.length;
1911  } else {
1912  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
1913  mxf->current_partition->essence_offset = op1a_essence_offset;
1914  }
1915  }
1916 
1917  if (!essence_offset)
1918  essence_offset = klv.offset;
1919 
1920  /* seek to footer, previous partition or stop */
1921  if (mxf_parse_handle_essence(mxf) <= 0)
1922  break;
1923  continue;
1924  } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
1925  klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
1926  /* next partition pack - keep going, seek to previous partition or stop */
1927  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1928  break;
1929  else if (mxf->parsing_backward)
1930  continue;
1931  /* we're still parsing forward. proceed to parsing this partition pack */
1932  }
1933 
1934  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
1935  if (IS_KLV_KEY(klv.key, metadata->key)) {
1936  int res;
1937  if (klv.key[5] == 0x53) {
1938  res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
1939  } else {
1940  uint64_t next = avio_tell(s->pb) + klv.length;
1941  res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
1942 
1943  /* only seek forward, else this can loop for a long time */
1944  if (avio_tell(s->pb) > next) {
1945  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
1946  klv.offset);
1947  return AVERROR_INVALIDDATA;
1948  }
1949 
1950  avio_seek(s->pb, next, SEEK_SET);
1951  }
1952  if (res < 0) {
1953  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
1954  return res;
1955  }
1956  break;
1957  }
1958  }
1959  if (!metadata->read)
1960  avio_skip(s->pb, klv.length);
1961  }
1962  /* FIXME avoid seek */
1963  if (!essence_offset) {
1964  av_log(s, AV_LOG_ERROR, "no essence\n");
1965  return AVERROR_INVALIDDATA;
1966  }
1967  avio_seek(s->pb, essence_offset, SEEK_SET);
1968 
1969  mxf_compute_essence_containers(mxf);
1970 
1971  /* we need to do this before computing the index tables
1972  * to be able to fill in zero IndexDurations with st->duration */
1973  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
1974  goto fail;
1975 
1976  if ((ret = mxf_compute_index_tables(mxf)) < 0)
1977  goto fail;
1978 
1979  if (mxf->nb_index_tables > 1) {
1980  /* TODO: look up which IndexSID to use via EssenceContainerData */
1981  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
1982  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
1983  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
1984  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
1985  ret = AVERROR_INVALIDDATA;
1986  goto fail;
1987  }
1988 
1989  mxf_handle_small_eubc(s);
1990 
1991  return 0;
1992 fail:
1993  mxf_read_close(s);
1994 
1995  return ret;
1996 }
1997 
1998 /**
1999  * Sets mxf->current_edit_unit based on what offset we're currently at.
2000  * @return next_ofs if OK, <0 on error
2001  */
2002 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2003 {
2004  int64_t last_ofs = -1, next_ofs = -1;
2005  MXFIndexTable *t = &mxf->index_tables[0];
2006 
2007  /* this is called from the OP1a demuxing logic, which means there
2008  * may be no index tables */
2009  if (mxf->nb_index_tables <= 0)
2010  return -1;
2011 
2012  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2013  while (mxf->current_edit_unit >= 0) {
2014  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2015  return -1;
2016 
2017  if (next_ofs <= last_ofs) {
2018  /* large next_ofs didn't change or current_edit_unit wrapped
2019  * around this fixes the infinite loop on zzuf3.mxf */
2020  av_log(mxf->fc, AV_LOG_ERROR,
2021  "next_ofs didn't change. not deriving packet timestamps\n");
2022  return -1;
2023  }
2024 
2025  if (next_ofs > current_offset)
2026  break;
2027 
2028  last_ofs = next_ofs;
2029  mxf->current_edit_unit++;
2030  }
2031 
2032  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2033  if (mxf->current_edit_unit < 0)
2034  return -1;
2035 
2036  return next_ofs;
2037 }
2038 
2039 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2040 {
2041  int i, total = 0, size = 0;
2042  AVStream *st = mxf->fc->streams[stream_index];
2043  MXFTrack *track = st->priv_data;
2044  AVRational time_base = av_inv_q(track->edit_rate);
2045  AVRational sample_rate = av_inv_q(st->time_base);
2046  const MXFSamplesPerFrame *spf = NULL;
2047 
2048  if ((sample_rate.num / sample_rate.den) == 48000)
2049  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2050  if (!spf) {
2051  int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2052  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2053  av_mul_q(sample_rate, time_base)));
2054  if (remainder)
2055  av_log(mxf->fc, AV_LOG_WARNING,
2056  "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2057  stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2058  return 0;
2059  }
2060 
2061  while (spf->samples_per_frame[size]) {
2062  total += spf->samples_per_frame[size];
2063  size++;
2064  }
2065 
2066  av_assert2(size);
2067 
2068  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2069  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2070  *sample_count += spf->samples_per_frame[i];
2071  }
2072 
2073  return 0;
2074 }
2075 
2076 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2077 {
2078  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2079  pkt->pts = track->sample_count;
2080  if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
2081  return AVERROR(EINVAL);
2082  track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2083  return 0;
2084 }
2085 
2086 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2087 {
2088  KLVPacket klv;
2089  MXFContext *mxf = s->priv_data;
2090 
2091  while (!url_feof(s->pb)) {
2092  int ret;
2093  if (klv_read_packet(&klv, s->pb) < 0)
2094  return -1;
2095  PRINT_KEY(s, "read packet", klv.key);
2096  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2097  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2098  ret = mxf_decrypt_triplet(s, pkt, &klv);
2099  if (ret < 0) {
2100  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2101  return AVERROR_INVALIDDATA;
2102  }
2103  return 0;
2104  }
2105  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2106  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2107  int index = mxf_get_stream_index(s, &klv);
2108  int64_t next_ofs, next_klv;
2109  AVStream *st;
2110  MXFTrack *track;
2111  AVCodecContext *codec;
2112 
2113  if (index < 0) {
2114  av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2115  goto skip;
2116  }
2117 
2118  st = s->streams[index];
2119  track = st->priv_data;
2120 
2121  if (s->streams[index]->discard == AVDISCARD_ALL)
2122  goto skip;
2123 
2124  next_klv = avio_tell(s->pb) + klv.length;
2125  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2126 
2127  if (next_ofs >= 0 && next_klv > next_ofs) {
2128  /* if this check is hit then it's possible OPAtom was treated as OP1a
2129  * truncate the packet since it's probably very large (>2 GiB is common) */
2130  av_log_ask_for_sample(s,
2131  "KLV for edit unit %i extends into next edit unit - OPAtom misinterpreted as OP1a?\n",
2132  mxf->current_edit_unit);
2133  klv.length = next_ofs - avio_tell(s->pb);
2134  }
2135 
2136  /* check for 8 channels AES3 element */
2137  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2138  if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2139  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2140  return AVERROR_INVALIDDATA;
2141  }
2142  } else {
2143  ret = av_get_packet(s->pb, pkt, klv.length);
2144  if (ret < 0)
2145  return ret;
2146  }
2147  pkt->stream_index = index;
2148  pkt->pos = klv.offset;
2149 
2150  codec = s->streams[index]->codec;
2151  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2152  /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2153  MXFIndexTable *t = &mxf->index_tables[0];
2154 
2155  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2156  pkt->dts = mxf->current_edit_unit + t->first_dts;
2157  pkt->pts = t->ptses[mxf->current_edit_unit];
2158  } else if (track->intra_only) {
2159  /* intra-only -> PTS = EditUnit.
2160  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2161  pkt->pts = mxf->current_edit_unit;
2162  }
2163  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2164  int ret = mxf_set_audio_pts(mxf, codec, pkt);
2165  if (ret < 0)
2166  return ret;
2167  }
2168 
2169  /* seek for truncated packets */
2170  avio_seek(s->pb, next_klv, SEEK_SET);
2171 
2172  return 0;
2173  } else
2174  skip:
2175  avio_skip(s->pb, klv.length);
2176  }
2177  return AVERROR_EOF;
2178 }
2179 
2180 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2181 {
2182  MXFContext *mxf = s->priv_data;
2183  int ret, size;
2184  int64_t ret64, pos, next_pos;
2185  AVStream *st;
2186  MXFIndexTable *t;
2187  int edit_units;
2188 
2189  if (mxf->op != OPAtom)
2190  return mxf_read_packet_old(s, pkt);
2191 
2192  /* OPAtom - clip wrapped demuxing */
2193  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2194  st = s->streams[0];
2195  t = &mxf->index_tables[0];
2196 
2197  if (mxf->current_edit_unit >= st->duration)
2198  return AVERROR_EOF;
2199 
2200  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2201 
2202  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2203  return ret;
2204 
2205  /* compute size by finding the next edit unit or the end of the essence container
2206  * not pretty, but it works */
2207  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2208  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2209  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2210  return AVERROR_INVALIDDATA;
2211  }
2212 
2213  if ((size = next_pos - pos) <= 0) {
2214  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2215  return AVERROR_INVALIDDATA;
2216  }
2217 
2218  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2219  return ret64;
2220 
2221  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2222  return size;
2223 
2224  pkt->stream_index = 0;
2225 
2226  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2227  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2228  pkt->dts = mxf->current_edit_unit + t->first_dts;
2229  pkt->pts = t->ptses[mxf->current_edit_unit];
2230  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2231  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2232  if (ret < 0)
2233  return ret;
2234  }
2235 
2236  mxf->current_edit_unit += edit_units;
2237 
2238  return 0;
2239 }
2240 
2241 static int mxf_read_close(AVFormatContext *s)
2242 {
2243  MXFContext *mxf = s->priv_data;
2244  MXFIndexTableSegment *seg;
2245  int i;
2246 
2247  av_freep(&mxf->packages_refs);
2248 
2249  for (i = 0; i < s->nb_streams; i++)
2250  s->streams[i]->priv_data = NULL;
2251 
2252  for (i = 0; i < mxf->metadata_sets_count; i++) {
2253  switch (mxf->metadata_sets[i]->type) {
2254  case Descriptor:
2255  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2256  break;
2257  case MultipleDescriptor:
2258  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2259  break;
2260  case Sequence:
2261  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2262  break;
2263  case SourcePackage:
2264  case MaterialPackage:
2265  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2266  break;
2267  case IndexTableSegment:
2268  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2269  av_freep(&seg->temporal_offset_entries);
2270  av_freep(&seg->flag_entries);
2271  av_freep(&seg->stream_offset_entries);
2272  break;
2273  default:
2274  break;
2275  }
2276  av_freep(&mxf->metadata_sets[i]);
2277  }
2278  av_freep(&mxf->partitions);
2279  av_freep(&mxf->metadata_sets);
2280  av_freep(&mxf->aesc);
2281  av_freep(&mxf->local_tags);
2282 
2283  if (mxf->index_tables) {
2284  for (i = 0; i < mxf->nb_index_tables; i++) {
2285  av_freep(&mxf->index_tables[i].segments);
2286  av_freep(&mxf->index_tables[i].ptses);
2287  av_freep(&mxf->index_tables[i].fake_index);
2288  }
2289  }
2290  av_freep(&mxf->index_tables);
2291 
2292  return 0;
2293 }
2294 
2295 static int mxf_probe(AVProbeData *p) {
2296  const uint8_t *bufp = p->buf;
2297  const uint8_t *end = p->buf + p->buf_size;
2298 
2299  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2300  return 0;
2301 
2302  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2303  end -= sizeof(mxf_header_partition_pack_key);
2304  for (; bufp < end; bufp++) {
2305  if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
2306  return AVPROBE_SCORE_MAX;
2307  }
2308  return 0;
2309 }
2310 
2311 /* rudimentary byte seek */
2312 /* XXX: use MXF Index */
2313 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2314 {
2315  AVStream *st = s->streams[stream_index];
2316  int64_t seconds;
2317  MXFContext* mxf = s->priv_data;
2318  int64_t seekpos;
2319  int i, ret;
2320  MXFIndexTable *t;
2321  MXFTrack *source_track = st->priv_data;
2322 
2323  /* if audio then truncate sample_time to EditRate */
2324  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2325  sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2326 
2327  if (mxf->nb_index_tables <= 0) {
2328  if (!s->bit_rate)
2329  return AVERROR_INVALIDDATA;
2330  if (sample_time < 0)
2331  sample_time = 0;
2332  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2333 
2334  if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2335  return ret;
2336  ff_update_cur_dts(s, st, sample_time);
2337  } else {
2338  t = &mxf->index_tables[0];
2339 
2340  /* clamp above zero, else ff_index_search_timestamp() returns negative
2341  * this also means we allow seeking before the start */
2342  sample_time = FFMAX(sample_time, 0);
2343 
2344  if (t->fake_index) {
2345  /* behave as if we have a proper index */
2346  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2347  return sample_time;
2348  } else {
2349  /* no IndexEntryArray (one or more CBR segments)
2350  * make sure we don't seek past the end */
2351  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2352  }
2353 
2354  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2355  return ret;
2356 
2357  ff_update_cur_dts(s, st, sample_time);
2358  mxf->current_edit_unit = sample_time;
2359  avio_seek(s->pb, seekpos, SEEK_SET);
2360  }
2361 
2362  // Update all tracks sample count
2363  for (i = 0; i < s->nb_streams; i++) {
2364  AVStream *cur_st = s->streams[i];
2365  MXFTrack *cur_track = cur_st->priv_data;
2366  uint64_t current_sample_count = 0;
2367  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2368  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2369  if (ret < 0)
2370  return ret;
2371 
2372  cur_track->sample_count = current_sample_count;
2373  }
2374  }
2375  return 0;
2376 }
2377 
2378 AVInputFormat ff_mxf_demuxer = {
2379  .name = "mxf",
2380  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2381  .priv_data_size = sizeof(MXFContext),
2382  .read_probe = mxf_probe,
2383  .read_header = mxf_read_header,
2384  .read_packet = mxf_read_packet,
2385  .read_close = mxf_read_close,
2386  .read_seek = mxf_read_seek,
2387 };
Generated on Sat May 25 2013 04:01:18 for FFmpeg by   doxygen 1.8.2