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  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1510  source_track->intra_only = mxf_is_intra_only(descriptor);
1511  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1512  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1513  st->codec->codec_id = container_ul->id;
1514  st->codec->width = descriptor->width;
1515  st->codec->height = descriptor->height; /* Field height, not frame height */
1516  switch (descriptor->frame_layout) {
1517  case SegmentedFrame:
1518  /* This one is a weird layout I don't fully understand. */
1519  av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1520  break;
1521  case FullFrame:
1522  st->codec->field_order = AV_FIELD_PROGRESSIVE;
1523  break;
1524  case OneField:
1525  /* Every other line is stored and needs to be duplicated. */
1526  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1527  break; /* The correct thing to do here is fall through, but by breaking we might be
1528  able to decode some streams at half the vertical resolution, rather than not al all.
1529  It's also for compatibility with the old behavior. */
1530  case MixedFields:
1531  break;
1532  case SeparateFields:
1533  st->codec->height *= 2; /* Turn field height into frame height. */
1534  break;
1535  default:
1536  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1537  }
1538  if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1539  st->codec->pix_fmt = descriptor->pix_fmt;
1540  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1541  pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1542  &descriptor->essence_codec_ul);
1543  st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1544  if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1545  /* support files created before RP224v10 by defaulting to UYVY422
1546  if subsampling is 4:2:2 and component depth is 8-bit */
1547  if (descriptor->horiz_subsampling == 2 &&
1548  descriptor->vert_subsampling == 1 &&
1549  descriptor->component_depth == 8) {
1550  st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1551  }
1552  }
1553  }
1554  }
1555  st->need_parsing = AVSTREAM_PARSE_HEADERS;
1556  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1557  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1558  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1559  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))
1560  st->codec->codec_id = (enum AVCodecID)container_ul->id;
1561  st->codec->channels = descriptor->channels;
1562  st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1563 
1564  if (descriptor->sample_rate.den > 0) {
1565  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1566  st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1567  } else {
1568  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) found for stream #%d, time base forced to 1/48000\n",
1569  descriptor->sample_rate.num, descriptor->sample_rate.den, st->index);
1570  avpriv_set_pts_info(st, 64, 1, 48000);
1571  }
1572 
1573  /* if duration is set, rescale it from EditRate to SampleRate */
1574  if (st->duration != AV_NOPTS_VALUE)
1575  st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1576 
1577  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1578  if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1579  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1580  st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1581  else if (descriptor->bits_per_sample == 32)
1582  st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1583  } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1584  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1585  st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1586  else if (descriptor->bits_per_sample == 32)
1587  st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1588  } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1589  st->need_parsing = AVSTREAM_PARSE_FULL;
1590  }
1591  }
1592  if (descriptor->extradata) {
1593  st->codec->extradata = av_mallocz(descriptor->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1594  if (st->codec->extradata)
1595  memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1596  } else if(st->codec->codec_id == CODEC_ID_H264) {
1597  ff_generate_avci_extradata(st);
1598  }
1599  if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1600  /* TODO: decode timestamps */
1601  st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1602  }
1603  }
1604 
1605  ret = 0;
1606 fail_and_free:
1607  return ret;
1608 }
1609 
1610 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1611  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1612  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1613  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1614  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1615  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1616  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1617  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1618  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1619  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1620  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1621  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1622  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1623  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1624  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1625  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1626  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1627  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1628  { { 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 */
1629  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1630  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1631  { { 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 */
1632  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1633  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1634  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1635  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1636  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1637  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1638  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1639  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1640 };
1641 
1642 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1643 {
1644  AVIOContext *pb = mxf->fc->pb;
1645  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1646  uint64_t klv_end = avio_tell(pb) + klv->length;
1647 
1648  if (!ctx)
1649  return AVERROR(ENOMEM);
1650  while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1651  int ret;
1652  int tag = avio_rb16(pb);
1653  int size = avio_rb16(pb); /* KLV specified by 0x53 */
1654  uint64_t next = avio_tell(pb) + size;
1655  UID uid = {0};
1656 
1657  av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1658  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1659  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1660  continue;
1661  }
1662  if (tag > 0x7FFF) { /* dynamic tag */
1663  int i;
1664  for (i = 0; i < mxf->local_tags_count; i++) {
1665  int local_tag = AV_RB16(mxf->local_tags+i*18);
1666  if (local_tag == tag) {
1667  memcpy(uid, mxf->local_tags+i*18+2, 16);
1668  av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1669  PRINT_KEY(mxf->fc, "uid", uid);
1670  }
1671  }
1672  }
1673  if (ctx_size && tag == 0x3C0A)
1674  avio_read(pb, ctx->uid, 16);
1675  else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1676  return ret;
1677 
1678  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1679  * it extending past the end of the KLV though (zzuf5.mxf). */
1680  if (avio_tell(pb) > klv_end) {
1681  if (ctx_size)
1682  av_free(ctx);
1683 
1684  av_log(mxf->fc, AV_LOG_ERROR,
1685  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1686  tag, klv->offset);
1687  return AVERROR_INVALIDDATA;
1688  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1689  avio_seek(pb, next, SEEK_SET);
1690  }
1691  if (ctx_size) ctx->type = type;
1692  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1693 }
1694 
1695 /**
1696  * Seeks to the previous partition, if possible
1697  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1698  */
1699 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1700 {
1701  AVIOContext *pb = mxf->fc->pb;
1702 
1703  if (!mxf->current_partition ||
1704  mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1705  return 0; /* we've parsed all partitions */
1706 
1707  /* seek to previous partition */
1708  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1709  mxf->current_partition = NULL;
1710 
1711  av_dlog(mxf->fc, "seeking to previous partition\n");
1712 
1713  return 1;
1714 }
1715 
1716 /**
1717  * Called when essence is encountered
1718  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1719  */
1720 static int mxf_parse_handle_essence(MXFContext *mxf)
1721 {
1722  AVIOContext *pb = mxf->fc->pb;
1723  int64_t ret;
1724 
1725  if (mxf->parsing_backward) {
1726  return mxf_seek_to_previous_partition(mxf);
1727  } else {
1728  if (!mxf->footer_partition) {
1729  av_dlog(mxf->fc, "no footer\n");
1730  return 0;
1731  }
1732 
1733  av_dlog(mxf->fc, "seeking to footer\n");
1734 
1735  /* remember where we were so we don't end up seeking further back than this */
1736  mxf->last_forward_tell = avio_tell(pb);
1737 
1738  if (!pb->seekable) {
1739  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1740  return -1;
1741  }
1742 
1743  /* seek to footer partition and parse backward */
1744  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1745  av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1746  mxf->run_in + mxf->footer_partition, ret);
1747  return ret;
1748  }
1749 
1750  mxf->current_partition = NULL;
1751  mxf->parsing_backward = 1;
1752  }
1753 
1754  return 1;
1755 }
1756 
1757 /**
1758  * Called when the next partition or EOF is encountered
1759  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1760  */
1761 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1762 {
1763  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1764 }
1765 
1766 /**
1767  * Figures out the proper offset and length of the essence container in each partition
1768  */
1769 static void mxf_compute_essence_containers(MXFContext *mxf)
1770 {
1771  int x;
1772 
1773  /* everything is already correct */
1774  if (mxf->op == OPAtom)
1775  return;
1776 
1777  for (x = 0; x < mxf->partitions_count; x++) {
1778  MXFPartition *p = &mxf->partitions[x];
1779 
1780  if (!p->body_sid)
1781  continue; /* BodySID == 0 -> no essence */
1782 
1783  if (x >= mxf->partitions_count - 1)
1784  break; /* last partition - can't compute length (and we don't need to) */
1785 
1786  /* essence container spans to the next partition */
1787  p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1788 
1789  if (p->essence_length < 0) {
1790  /* next ThisPartition < essence_offset */
1791  p->essence_length = 0;
1792  av_log(mxf->fc, AV_LOG_ERROR,
1793  "partition %i: bad ThisPartition = %"PRIX64"\n",
1794  x+1, mxf->partitions[x+1].this_partition);
1795  }
1796  }
1797 }
1798 
1799 static int64_t round_to_kag(int64_t position, int kag_size)
1800 {
1801  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1802  /* NOTE: kag_size may be any integer between 1 - 2^10 */
1803  int64_t ret = (position / kag_size) * kag_size;
1804  return ret == position ? ret : ret + kag_size;
1805 }
1806 
1807 static int is_pcm(enum AVCodecID codec_id)
1808 {
1809  /* we only care about "normal" PCM codecs until we get samples */
1810  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1811 }
1812 
1813 /**
1814  * Deal with the case where for some audio atoms EditUnitByteCount is
1815  * very small (2, 4..). In those cases we should read more than one
1816  * sample per call to mxf_read_packet().
1817  */
1818 static void mxf_handle_small_eubc(AVFormatContext *s)
1819 {
1820  MXFContext *mxf = s->priv_data;
1821 
1822  /* assuming non-OPAtom == frame wrapped
1823  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1824  if (mxf->op != OPAtom)
1825  return;
1826 
1827  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1828  if (s->nb_streams != 1 ||
1829  s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1830  !is_pcm(s->streams[0]->codec->codec_id) ||
1831  mxf->nb_index_tables != 1 ||
1832  mxf->index_tables[0].nb_segments != 1 ||
1833  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1834  return;
1835 
1836  /* arbitrarily default to 48 kHz PAL audio frame size */
1837  /* TODO: We could compute this from the ratio between the audio
1838  * and video edit rates for 48 kHz NTSC we could use the
1839  * 1802-1802-1802-1802-1801 pattern. */
1840  mxf->edit_units_per_packet = 1920;
1841 }
1842 
1843 static int mxf_read_header(AVFormatContext *s)
1844 {
1845  MXFContext *mxf = s->priv_data;
1846  KLVPacket klv;
1847  int64_t essence_offset = 0;
1848  int ret;
1849 
1850  mxf->last_forward_tell = INT64_MAX;
1851  mxf->edit_units_per_packet = 1;
1852 
1853  if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
1854  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1855  return AVERROR_INVALIDDATA;
1856  }
1857  avio_seek(s->pb, -14, SEEK_CUR);
1858  mxf->fc = s;
1859  mxf->run_in = avio_tell(s->pb);
1860 
1861  while (!url_feof(s->pb)) {
1862  const MXFMetadataReadTableEntry *metadata;
1863 
1864  if (klv_read_packet(&klv, s->pb) < 0) {
1865  /* EOF - seek to previous partition or stop */
1866  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1867  break;
1868  else
1869  continue;
1870  }
1871 
1872  PRINT_KEY(s, "read header", klv.key);
1873  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
1874  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
1875  IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
1876  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
1877  IS_KLV_KEY(klv.key, mxf_system_item_key)) {
1878 
1879  if (!mxf->current_partition) {
1880  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
1881  return AVERROR_INVALIDDATA;
1882  }
1883 
1884  if (!mxf->current_partition->essence_offset) {
1885  /* for OP1a we compute essence_offset
1886  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
1887  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
1888  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
1889  */
1890  int64_t op1a_essence_offset =
1891  round_to_kag(mxf->current_partition->this_partition +
1892  mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
1893  round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
1894  round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
1895 
1896  if (mxf->op == OPAtom) {
1897  /* point essence_offset to the actual data
1898  * OPAtom has all the essence in one big KLV
1899  */
1900  mxf->current_partition->essence_offset = avio_tell(s->pb);
1901  mxf->current_partition->essence_length = klv.length;
1902  } else {
1903  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
1904  mxf->current_partition->essence_offset = op1a_essence_offset;
1905  }
1906  }
1907 
1908  if (!essence_offset)
1909  essence_offset = klv.offset;
1910 
1911  /* seek to footer, previous partition or stop */
1912  if (mxf_parse_handle_essence(mxf) <= 0)
1913  break;
1914  continue;
1915  } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
1916  klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
1917  /* next partition pack - keep going, seek to previous partition or stop */
1918  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1919  break;
1920  else if (mxf->parsing_backward)
1921  continue;
1922  /* we're still parsing forward. proceed to parsing this partition pack */
1923  }
1924 
1925  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
1926  if (IS_KLV_KEY(klv.key, metadata->key)) {
1927  int res;
1928  if (klv.key[5] == 0x53) {
1929  res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
1930  } else {
1931  uint64_t next = avio_tell(s->pb) + klv.length;
1932  res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
1933 
1934  /* only seek forward, else this can loop for a long time */
1935  if (avio_tell(s->pb) > next) {
1936  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
1937  klv.offset);
1938  return AVERROR_INVALIDDATA;
1939  }
1940 
1941  avio_seek(s->pb, next, SEEK_SET);
1942  }
1943  if (res < 0) {
1944  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
1945  return res;
1946  }
1947  break;
1948  }
1949  }
1950  if (!metadata->read)
1951  avio_skip(s->pb, klv.length);
1952  }
1953  /* FIXME avoid seek */
1954  if (!essence_offset) {
1955  av_log(s, AV_LOG_ERROR, "no essence\n");
1956  return AVERROR_INVALIDDATA;
1957  }
1958  avio_seek(s->pb, essence_offset, SEEK_SET);
1959 
1960  mxf_compute_essence_containers(mxf);
1961 
1962  /* we need to do this before computing the index tables
1963  * to be able to fill in zero IndexDurations with st->duration */
1964  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
1965  goto fail;
1966 
1967  if ((ret = mxf_compute_index_tables(mxf)) < 0)
1968  goto fail;
1969 
1970  if (mxf->nb_index_tables > 1) {
1971  /* TODO: look up which IndexSID to use via EssenceContainerData */
1972  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
1973  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
1974  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
1975  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
1976  ret = AVERROR_INVALIDDATA;
1977  goto fail;
1978  }
1979 
1980  mxf_handle_small_eubc(s);
1981 
1982  return 0;
1983 fail:
1984  mxf_read_close(s);
1985 
1986  return ret;
1987 }
1988 
1989 /**
1990  * Sets mxf->current_edit_unit based on what offset we're currently at.
1991  * @return next_ofs if OK, <0 on error
1992  */
1993 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
1994 {
1995  int64_t last_ofs = -1, next_ofs = -1;
1996  MXFIndexTable *t = &mxf->index_tables[0];
1997 
1998  /* this is called from the OP1a demuxing logic, which means there
1999  * may be no index tables */
2000  if (mxf->nb_index_tables <= 0)
2001  return -1;
2002 
2003  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2004  while (mxf->current_edit_unit >= 0) {
2005  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2006  return -1;
2007 
2008  if (next_ofs <= last_ofs) {
2009  /* large next_ofs didn't change or current_edit_unit wrapped
2010  * around this fixes the infinite loop on zzuf3.mxf */
2011  av_log(mxf->fc, AV_LOG_ERROR,
2012  "next_ofs didn't change. not deriving packet timestamps\n");
2013  return -1;
2014  }
2015 
2016  if (next_ofs > current_offset)
2017  break;
2018 
2019  last_ofs = next_ofs;
2020  mxf->current_edit_unit++;
2021  }
2022 
2023  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2024  if (mxf->current_edit_unit < 0)
2025  return -1;
2026 
2027  return next_ofs;
2028 }
2029 
2030 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2031 {
2032  int i, total = 0, size = 0;
2033  AVStream *st = mxf->fc->streams[stream_index];
2034  MXFTrack *track = st->priv_data;
2035  AVRational time_base = av_inv_q(track->edit_rate);
2036  AVRational sample_rate = av_inv_q(st->time_base);
2037  const MXFSamplesPerFrame *spf = NULL;
2038 
2039  if ((sample_rate.num / sample_rate.den) == 48000)
2040  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2041  if (!spf) {
2042  int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2043  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2044  av_mul_q(sample_rate, time_base)));
2045  if (remainder)
2046  av_log(mxf->fc, AV_LOG_WARNING,
2047  "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2048  stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2049  return 0;
2050  }
2051 
2052  while (spf->samples_per_frame[size]) {
2053  total += spf->samples_per_frame[size];
2054  size++;
2055  }
2056 
2057  av_assert2(size);
2058 
2059  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2060  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2061  *sample_count += spf->samples_per_frame[i];
2062  }
2063 
2064  return 0;
2065 }
2066 
2067 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2068 {
2069  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2070  pkt->pts = track->sample_count;
2071  if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
2072  return AVERROR(EINVAL);
2073  track->sample_count += pkt->size / (codec->channels * av_get_bits_per_sample(codec->codec_id) / 8);
2074  return 0;
2075 }
2076 
2077 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2078 {
2079  KLVPacket klv;
2080  MXFContext *mxf = s->priv_data;
2081 
2082  while (!url_feof(s->pb)) {
2083  int ret;
2084  if (klv_read_packet(&klv, s->pb) < 0)
2085  return -1;
2086  PRINT_KEY(s, "read packet", klv.key);
2087  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2088  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2089  ret = mxf_decrypt_triplet(s, pkt, &klv);
2090  if (ret < 0) {
2091  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2092  return AVERROR_INVALIDDATA;
2093  }
2094  return 0;
2095  }
2096  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2097  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2098  int index = mxf_get_stream_index(s, &klv);
2099  int64_t next_ofs, next_klv;
2100  AVStream *st;
2101  MXFTrack *track;
2102  AVCodecContext *codec;
2103 
2104  if (index < 0) {
2105  av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2106  goto skip;
2107  }
2108 
2109  st = s->streams[index];
2110  track = st->priv_data;
2111 
2112  if (s->streams[index]->discard == AVDISCARD_ALL)
2113  goto skip;
2114 
2115  next_klv = avio_tell(s->pb) + klv.length;
2116  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2117 
2118  if (next_ofs >= 0 && next_klv > next_ofs) {
2119  /* if this check is hit then it's possible OPAtom was treated as OP1a
2120  * truncate the packet since it's probably very large (>2 GiB is common) */
2121  av_log_ask_for_sample(s,
2122  "KLV for edit unit %i extends into next edit unit - OPAtom misinterpreted as OP1a?\n",
2123  mxf->current_edit_unit);
2124  klv.length = next_ofs - avio_tell(s->pb);
2125  }
2126 
2127  /* check for 8 channels AES3 element */
2128  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2129  if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2130  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2131  return AVERROR_INVALIDDATA;
2132  }
2133  } else {
2134  ret = av_get_packet(s->pb, pkt, klv.length);
2135  if (ret < 0)
2136  return ret;
2137  }
2138  pkt->stream_index = index;
2139  pkt->pos = klv.offset;
2140 
2141  codec = s->streams[index]->codec;
2142  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2143  /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2144  MXFIndexTable *t = &mxf->index_tables[0];
2145 
2146  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2147  pkt->dts = mxf->current_edit_unit + t->first_dts;
2148  pkt->pts = t->ptses[mxf->current_edit_unit];
2149  } else if (track->intra_only) {
2150  /* intra-only -> PTS = EditUnit.
2151  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2152  pkt->pts = mxf->current_edit_unit;
2153  }
2154  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2155  int ret = mxf_set_audio_pts(mxf, codec, pkt);
2156  if (ret < 0)
2157  return ret;
2158  }
2159 
2160  /* seek for truncated packets */
2161  avio_seek(s->pb, next_klv, SEEK_SET);
2162 
2163  return 0;
2164  } else
2165  skip:
2166  avio_skip(s->pb, klv.length);
2167  }
2168  return AVERROR_EOF;
2169 }
2170 
2171 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2172 {
2173  MXFContext *mxf = s->priv_data;
2174  int ret, size;
2175  int64_t ret64, pos, next_pos;
2176  AVStream *st;
2177  MXFIndexTable *t;
2178  int edit_units;
2179 
2180  if (mxf->op != OPAtom)
2181  return mxf_read_packet_old(s, pkt);
2182 
2183  /* OPAtom - clip wrapped demuxing */
2184  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2185  st = s->streams[0];
2186  t = &mxf->index_tables[0];
2187 
2188  if (mxf->current_edit_unit >= st->duration)
2189  return AVERROR_EOF;
2190 
2191  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2192 
2193  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2194  return ret;
2195 
2196  /* compute size by finding the next edit unit or the end of the essence container
2197  * not pretty, but it works */
2198  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2199  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2200  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2201  return AVERROR_INVALIDDATA;
2202  }
2203 
2204  if ((size = next_pos - pos) <= 0) {
2205  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2206  return AVERROR_INVALIDDATA;
2207  }
2208 
2209  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2210  return ret64;
2211 
2212  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2213  return size;
2214 
2215  pkt->stream_index = 0;
2216 
2217  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2218  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2219  pkt->dts = mxf->current_edit_unit + t->first_dts;
2220  pkt->pts = t->ptses[mxf->current_edit_unit];
2221  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2222  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2223  if (ret < 0)
2224  return ret;
2225  }
2226 
2227  mxf->current_edit_unit += edit_units;
2228 
2229  return 0;
2230 }
2231 
2232 static int mxf_read_close(AVFormatContext *s)
2233 {
2234  MXFContext *mxf = s->priv_data;
2235  MXFIndexTableSegment *seg;
2236  int i;
2237 
2238  av_freep(&mxf->packages_refs);
2239 
2240  for (i = 0; i < s->nb_streams; i++)
2241  s->streams[i]->priv_data = NULL;
2242 
2243  for (i = 0; i < mxf->metadata_sets_count; i++) {
2244  switch (mxf->metadata_sets[i]->type) {
2245  case Descriptor:
2246  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2247  break;
2248  case MultipleDescriptor:
2249  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2250  break;
2251  case Sequence:
2252  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2253  break;
2254  case SourcePackage:
2255  case MaterialPackage:
2256  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2257  break;
2258  case IndexTableSegment:
2259  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2260  av_freep(&seg->temporal_offset_entries);
2261  av_freep(&seg->flag_entries);
2262  av_freep(&seg->stream_offset_entries);
2263  break;
2264  default:
2265  break;
2266  }
2267  av_freep(&mxf->metadata_sets[i]);
2268  }
2269  av_freep(&mxf->partitions);
2270  av_freep(&mxf->metadata_sets);
2271  av_freep(&mxf->aesc);
2272  av_freep(&mxf->local_tags);
2273 
2274  if (mxf->index_tables) {
2275  for (i = 0; i < mxf->nb_index_tables; i++) {
2276  av_freep(&mxf->index_tables[i].segments);
2277  av_freep(&mxf->index_tables[i].ptses);
2278  av_freep(&mxf->index_tables[i].fake_index);
2279  }
2280  }
2281  av_freep(&mxf->index_tables);
2282 
2283  return 0;
2284 }
2285 
2286 static int mxf_probe(AVProbeData *p) {
2287  const uint8_t *bufp = p->buf;
2288  const uint8_t *end = p->buf + p->buf_size;
2289 
2290  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2291  return 0;
2292 
2293  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2294  end -= sizeof(mxf_header_partition_pack_key);
2295  for (; bufp < end; bufp++) {
2296  if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
2297  return AVPROBE_SCORE_MAX;
2298  }
2299  return 0;
2300 }
2301 
2302 /* rudimentary byte seek */
2303 /* XXX: use MXF Index */
2304 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2305 {
2306  AVStream *st = s->streams[stream_index];
2307  int64_t seconds;
2308  MXFContext* mxf = s->priv_data;
2309  int64_t seekpos;
2310  int i, ret;
2311  MXFIndexTable *t;
2312  MXFTrack *source_track = st->priv_data;
2313 
2314  /* if audio then truncate sample_time to EditRate */
2315  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2316  sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2317 
2318  if (mxf->nb_index_tables <= 0) {
2319  if (!s->bit_rate)
2320  return AVERROR_INVALIDDATA;
2321  if (sample_time < 0)
2322  sample_time = 0;
2323  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2324 
2325  if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2326  return ret;
2327  ff_update_cur_dts(s, st, sample_time);
2328  } else {
2329  t = &mxf->index_tables[0];
2330 
2331  /* clamp above zero, else ff_index_search_timestamp() returns negative
2332  * this also means we allow seeking before the start */
2333  sample_time = FFMAX(sample_time, 0);
2334 
2335  if (t->fake_index) {
2336  /* behave as if we have a proper index */
2337  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2338  return sample_time;
2339  } else {
2340  /* no IndexEntryArray (one or more CBR segments)
2341  * make sure we don't seek past the end */
2342  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2343  }
2344 
2345  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2346  return ret;
2347 
2348  ff_update_cur_dts(s, st, sample_time);
2349  mxf->current_edit_unit = sample_time;
2350  avio_seek(s->pb, seekpos, SEEK_SET);
2351  }
2352 
2353  // Update all tracks sample count
2354  for (i = 0; i < s->nb_streams; i++) {
2355  AVStream *cur_st = s->streams[i];
2356  MXFTrack *cur_track = cur_st->priv_data;
2357  uint64_t current_sample_count = 0;
2358  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2359  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2360  if (ret < 0)
2361  return ret;
2362 
2363  cur_track->sample_count = current_sample_count;
2364  }
2365  }
2366  return 0;
2367 }
2368 
2369 AVInputFormat ff_mxf_demuxer = {
2370  .name = "mxf",
2371  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2372  .priv_data_size = sizeof(MXFContext),
2373  .read_probe = mxf_probe,
2374  .read_header = mxf_read_header,
2375  .read_packet = mxf_read_packet,
2376  .read_close = mxf_read_close,
2377  .read_seek = mxf_read_seek,
2378 };
Generated on Sat May 25 2013 03:58:47 for FFmpeg by   doxygen 1.8.2