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