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