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  } else if(st->codec->codec_id == AV_CODEC_ID_H264) {
1607  ff_generate_avci_extradata(st);
1608  }
1609  if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1610  /* TODO: decode timestamps */
1611  st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1612  }
1613  }
1614 
1615  ret = 0;
1616 fail_and_free:
1617  return ret;
1618 }
1619 
1620 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1621 {
1622  int ret;
1623  size_t buf_size;
1624 
1625  if (size < 0)
1626  return AVERROR(EINVAL);
1627 
1628  buf_size = size + size/2 + 1;
1629  *str = av_malloc(buf_size);
1630  if (!*str)
1631  return AVERROR(ENOMEM);
1632 
1633  if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1634  av_freep(str);
1635  return ret;
1636  }
1637 
1638  return ret;
1639 }
1640 
1641 static int mxf_uid_to_str(UID uid, char **str)
1642 {
1643  int i;
1644  char *p;
1645  p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1646  if (!p)
1647  return AVERROR(ENOMEM);
1648  for (i = 0; i < sizeof(UID); i++) {
1649  snprintf(p, 2 + 1, "%.2x", uid[i]);
1650  p += 2;
1651  if (i == 3 || i == 5 || i == 7 || i == 9) {
1652  snprintf(p, 1 + 1, "-");
1653  p++;
1654  }
1655  }
1656  return 0;
1657 }
1658 
1659 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1660 {
1661  struct tm time = {0};
1662  time.tm_year = (timestamp >> 48) - 1900;
1663  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1664  time.tm_mday = (timestamp >> 32 & 0xFF);
1665  time.tm_hour = (timestamp >> 24 & 0xFF);
1666  time.tm_min = (timestamp >> 16 & 0xFF);
1667  time.tm_sec = (timestamp >> 8 & 0xFF);
1668 
1669  /* ensure month/day are valid */
1670  time.tm_mon = FFMAX(time.tm_mon, 0);
1671  time.tm_mday = FFMAX(time.tm_mday, 1);
1672 
1673  *str = av_mallocz(32);
1674  if (!*str)
1675  return AVERROR(ENOMEM);
1676  strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1677 
1678  return 0;
1679 }
1680 
1681 #define SET_STR_METADATA(pb, name, str) do { \
1682  if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1683  return ret; \
1684  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1685 } while (0)
1686 
1687 #define SET_UID_METADATA(pb, name, var, str) do { \
1688  avio_read(pb, var, 16); \
1689  if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1690  return ret; \
1691  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1692 } while (0)
1693 
1694 #define SET_TS_METADATA(pb, name, var, str) do { \
1695  var = avio_rb64(pb); \
1696  if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1697  return ret; \
1698  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1699 } while (0)
1700 
1701 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1702 {
1703  MXFContext *mxf = arg;
1704  AVFormatContext *s = mxf->fc;
1705  int ret;
1706  UID uid = { 0 };
1707  char *str = NULL;
1708  uint64_t ts;
1709  switch (tag) {
1710  case 0x3C01:
1711  SET_STR_METADATA(pb, "company_name", str);
1712  break;
1713  case 0x3C02:
1714  SET_STR_METADATA(pb, "product_name", str);
1715  break;
1716  case 0x3C04:
1717  SET_STR_METADATA(pb, "product_version", str);
1718  break;
1719  case 0x3C05:
1720  SET_UID_METADATA(pb, "product_uid", uid, str);
1721  break;
1722  case 0x3C06:
1723  SET_TS_METADATA(pb, "modification_date", ts, str);
1724  break;
1725  case 0x3C08:
1726  SET_STR_METADATA(pb, "application_platform", str);
1727  break;
1728  case 0x3C09:
1729  SET_UID_METADATA(pb, "generation_uid", uid, str);
1730  break;
1731  case 0x3C0A:
1732  SET_UID_METADATA(pb, "uid", uid, str);
1733  break;
1734  }
1735  return 0;
1736 }
1737 
1738 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1739  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1740  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1741  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1742  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1743  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1744  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1745  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1746  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1747  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1748  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1749  { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1750  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1751  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1752  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1753  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1754  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1755  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1756  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1757  { { 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 */
1758  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1759  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1760  { { 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 */
1761  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1762  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1763  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1764  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1765  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1766  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1767  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1768  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1769 };
1770 
1771 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1772 {
1773  AVIOContext *pb = mxf->fc->pb;
1774  MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1775  uint64_t klv_end = avio_tell(pb) + klv->length;
1776 
1777  if (!ctx)
1778  return AVERROR(ENOMEM);
1779  while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1780  int ret;
1781  int tag = avio_rb16(pb);
1782  int size = avio_rb16(pb); /* KLV specified by 0x53 */
1783  uint64_t next = avio_tell(pb) + size;
1784  UID uid = {0};
1785 
1786  av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1787  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1788  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1789  continue;
1790  }
1791  if (tag > 0x7FFF) { /* dynamic tag */
1792  int i;
1793  for (i = 0; i < mxf->local_tags_count; i++) {
1794  int local_tag = AV_RB16(mxf->local_tags+i*18);
1795  if (local_tag == tag) {
1796  memcpy(uid, mxf->local_tags+i*18+2, 16);
1797  av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1798  PRINT_KEY(mxf->fc, "uid", uid);
1799  }
1800  }
1801  }
1802  if (ctx_size && tag == 0x3C0A)
1803  avio_read(pb, ctx->uid, 16);
1804  else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1805  return ret;
1806 
1807  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1808  * it extending past the end of the KLV though (zzuf5.mxf). */
1809  if (avio_tell(pb) > klv_end) {
1810  if (ctx_size)
1811  av_free(ctx);
1812 
1813  av_log(mxf->fc, AV_LOG_ERROR,
1814  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1815  tag, klv->offset);
1816  return AVERROR_INVALIDDATA;
1817  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1818  avio_seek(pb, next, SEEK_SET);
1819  }
1820  if (ctx_size) ctx->type = type;
1821  return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1822 }
1823 
1824 /**
1825  * Seeks to the previous partition, if possible
1826  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1827  */
1828 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1829 {
1830  AVIOContext *pb = mxf->fc->pb;
1831 
1832  if (!mxf->current_partition ||
1833  mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1834  return 0; /* we've parsed all partitions */
1835 
1836  /* seek to previous partition */
1837  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1838  mxf->current_partition = NULL;
1839 
1840  av_dlog(mxf->fc, "seeking to previous partition\n");
1841 
1842  return 1;
1843 }
1844 
1845 /**
1846  * Called when essence is encountered
1847  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1848  */
1849 static int mxf_parse_handle_essence(MXFContext *mxf)
1850 {
1851  AVIOContext *pb = mxf->fc->pb;
1852  int64_t ret;
1853 
1854  if (mxf->parsing_backward) {
1855  return mxf_seek_to_previous_partition(mxf);
1856  } else {
1857  if (!mxf->footer_partition) {
1858  av_dlog(mxf->fc, "no footer\n");
1859  return 0;
1860  }
1861 
1862  av_dlog(mxf->fc, "seeking to footer\n");
1863 
1864  /* remember where we were so we don't end up seeking further back than this */
1865  mxf->last_forward_tell = avio_tell(pb);
1866 
1867  if (!pb->seekable) {
1868  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1869  return -1;
1870  }
1871 
1872  /* seek to footer partition and parse backward */
1873  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1874  av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1875  mxf->run_in + mxf->footer_partition, ret);
1876  return ret;
1877  }
1878 
1879  mxf->current_partition = NULL;
1880  mxf->parsing_backward = 1;
1881  }
1882 
1883  return 1;
1884 }
1885 
1886 /**
1887  * Called when the next partition or EOF is encountered
1888  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1889  */
1890 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1891 {
1892  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1893 }
1894 
1895 /**
1896  * Figures out the proper offset and length of the essence container in each partition
1897  */
1898 static void mxf_compute_essence_containers(MXFContext *mxf)
1899 {
1900  int x;
1901 
1902  /* everything is already correct */
1903  if (mxf->op == OPAtom)
1904  return;
1905 
1906  for (x = 0; x < mxf->partitions_count; x++) {
1907  MXFPartition *p = &mxf->partitions[x];
1908 
1909  if (!p->body_sid)
1910  continue; /* BodySID == 0 -> no essence */
1911 
1912  if (x >= mxf->partitions_count - 1)
1913  break; /* last partition - can't compute length (and we don't need to) */
1914 
1915  /* essence container spans to the next partition */
1916  p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1917 
1918  if (p->essence_length < 0) {
1919  /* next ThisPartition < essence_offset */
1920  p->essence_length = 0;
1921  av_log(mxf->fc, AV_LOG_ERROR,
1922  "partition %i: bad ThisPartition = %"PRIX64"\n",
1923  x+1, mxf->partitions[x+1].this_partition);
1924  }
1925  }
1926 }
1927 
1928 static int64_t round_to_kag(int64_t position, int kag_size)
1929 {
1930  /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1931  /* NOTE: kag_size may be any integer between 1 - 2^10 */
1932  int64_t ret = (position / kag_size) * kag_size;
1933  return ret == position ? ret : ret + kag_size;
1934 }
1935 
1936 static int is_pcm(enum AVCodecID codec_id)
1937 {
1938  /* we only care about "normal" PCM codecs until we get samples */
1939  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1940 }
1941 
1942 /**
1943  * Deal with the case where for some audio atoms EditUnitByteCount is
1944  * very small (2, 4..). In those cases we should read more than one
1945  * sample per call to mxf_read_packet().
1946  */
1947 static void mxf_handle_small_eubc(AVFormatContext *s)
1948 {
1949  MXFContext *mxf = s->priv_data;
1950 
1951  /* assuming non-OPAtom == frame wrapped
1952  * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1953  if (mxf->op != OPAtom)
1954  return;
1955 
1956  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1957  if (s->nb_streams != 1 ||
1958  s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1959  !is_pcm(s->streams[0]->codec->codec_id) ||
1960  mxf->nb_index_tables != 1 ||
1961  mxf->index_tables[0].nb_segments != 1 ||
1962  mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1963  return;
1964 
1965  /* arbitrarily default to 48 kHz PAL audio frame size */
1966  /* TODO: We could compute this from the ratio between the audio
1967  * and video edit rates for 48 kHz NTSC we could use the
1968  * 1802-1802-1802-1802-1801 pattern. */
1969  mxf->edit_units_per_packet = 1920;
1970 }
1971 
1972 static int mxf_read_header(AVFormatContext *s)
1973 {
1974  MXFContext *mxf = s->priv_data;
1975  KLVPacket klv;
1976  int64_t essence_offset = 0;
1977  int ret;
1978 
1979  mxf->last_forward_tell = INT64_MAX;
1980  mxf->edit_units_per_packet = 1;
1981 
1982  if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
1983  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1984  return AVERROR_INVALIDDATA;
1985  }
1986  avio_seek(s->pb, -14, SEEK_CUR);
1987  mxf->fc = s;
1988  mxf->run_in = avio_tell(s->pb);
1989 
1990  while (!url_feof(s->pb)) {
1991  const MXFMetadataReadTableEntry *metadata;
1992 
1993  if (klv_read_packet(&klv, s->pb) < 0) {
1994  /* EOF - seek to previous partition or stop */
1995  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1996  break;
1997  else
1998  continue;
1999  }
2000 
2001  PRINT_KEY(s, "read header", klv.key);
2002  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2003  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2004  IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2005  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2006  IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2007 
2008  if (!mxf->current_partition) {
2009  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2010  return AVERROR_INVALIDDATA;
2011  }
2012 
2013  if (!mxf->current_partition->essence_offset) {
2014  /* for OP1a we compute essence_offset
2015  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2016  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2017  * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2018  */
2019  int64_t op1a_essence_offset =
2020  round_to_kag(mxf->current_partition->this_partition +
2021  mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2022  round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2023  round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2024 
2025  if (mxf->op == OPAtom) {
2026  /* point essence_offset to the actual data
2027  * OPAtom has all the essence in one big KLV
2028  */
2029  mxf->current_partition->essence_offset = avio_tell(s->pb);
2030  mxf->current_partition->essence_length = klv.length;
2031  } else {
2032  /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2033  mxf->current_partition->essence_offset = op1a_essence_offset;
2034  }
2035  }
2036 
2037  if (!essence_offset)
2038  essence_offset = klv.offset;
2039 
2040  /* seek to footer, previous partition or stop */
2041  if (mxf_parse_handle_essence(mxf) <= 0)
2042  break;
2043  continue;
2044  } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2045  klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2046  /* next partition pack - keep going, seek to previous partition or stop */
2047  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2048  break;
2049  else if (mxf->parsing_backward)
2050  continue;
2051  /* we're still parsing forward. proceed to parsing this partition pack */
2052  }
2053 
2054  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2055  if (IS_KLV_KEY(klv.key, metadata->key)) {
2056  int res;
2057  if (klv.key[5] == 0x53) {
2058  res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2059  } else {
2060  uint64_t next = avio_tell(s->pb) + klv.length;
2061  res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2062 
2063  /* only seek forward, else this can loop for a long time */
2064  if (avio_tell(s->pb) > next) {
2065  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2066  klv.offset);
2067  return AVERROR_INVALIDDATA;
2068  }
2069 
2070  avio_seek(s->pb, next, SEEK_SET);
2071  }
2072  if (res < 0) {
2073  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2074  return res;
2075  }
2076  break;
2077  }
2078  }
2079  if (!metadata->read)
2080  avio_skip(s->pb, klv.length);
2081  }
2082  /* FIXME avoid seek */
2083  if (!essence_offset) {
2084  av_log(s, AV_LOG_ERROR, "no essence\n");
2085  return AVERROR_INVALIDDATA;
2086  }
2087  avio_seek(s->pb, essence_offset, SEEK_SET);
2088 
2089  mxf_compute_essence_containers(mxf);
2090 
2091  /* we need to do this before computing the index tables
2092  * to be able to fill in zero IndexDurations with st->duration */
2093  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2094  goto fail;
2095 
2096  if ((ret = mxf_compute_index_tables(mxf)) < 0)
2097  goto fail;
2098 
2099  if (mxf->nb_index_tables > 1) {
2100  /* TODO: look up which IndexSID to use via EssenceContainerData */
2101  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2102  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2103  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2104  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2105  ret = AVERROR_INVALIDDATA;
2106  goto fail;
2107  }
2108 
2109  mxf_handle_small_eubc(s);
2110 
2111  return 0;
2112 fail:
2113  mxf_read_close(s);
2114 
2115  return ret;
2116 }
2117 
2118 /**
2119  * Sets mxf->current_edit_unit based on what offset we're currently at.
2120  * @return next_ofs if OK, <0 on error
2121  */
2122 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2123 {
2124  int64_t last_ofs = -1, next_ofs = -1;
2125  MXFIndexTable *t = &mxf->index_tables[0];
2126 
2127  /* this is called from the OP1a demuxing logic, which means there
2128  * may be no index tables */
2129  if (mxf->nb_index_tables <= 0)
2130  return -1;
2131 
2132  /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2133  while (mxf->current_edit_unit >= 0) {
2134  if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2135  return -1;
2136 
2137  if (next_ofs <= last_ofs) {
2138  /* large next_ofs didn't change or current_edit_unit wrapped
2139  * around this fixes the infinite loop on zzuf3.mxf */
2140  av_log(mxf->fc, AV_LOG_ERROR,
2141  "next_ofs didn't change. not deriving packet timestamps\n");
2142  return -1;
2143  }
2144 
2145  if (next_ofs > current_offset)
2146  break;
2147 
2148  last_ofs = next_ofs;
2149  mxf->current_edit_unit++;
2150  }
2151 
2152  /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2153  if (mxf->current_edit_unit < 0)
2154  return -1;
2155 
2156  return next_ofs;
2157 }
2158 
2159 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2160 {
2161  int i, total = 0, size = 0;
2162  AVStream *st = mxf->fc->streams[stream_index];
2163  MXFTrack *track = st->priv_data;
2164  AVRational time_base = av_inv_q(track->edit_rate);
2165  AVRational sample_rate = av_inv_q(st->time_base);
2166  const MXFSamplesPerFrame *spf = NULL;
2167 
2168  if ((sample_rate.num / sample_rate.den) == 48000)
2169  spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2170  if (!spf) {
2171  int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2172  *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2173  av_mul_q(sample_rate, time_base)));
2174  if (remainder)
2175  av_log(mxf->fc, AV_LOG_WARNING,
2176  "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2177  stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2178  return 0;
2179  }
2180 
2181  while (spf->samples_per_frame[size]) {
2182  total += spf->samples_per_frame[size];
2183  size++;
2184  }
2185 
2186  av_assert2(size);
2187 
2188  *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2189  for (i = 0; i < mxf->current_edit_unit % size; i++) {
2190  *sample_count += spf->samples_per_frame[i];
2191  }
2192 
2193  return 0;
2194 }
2195 
2196 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2197 {
2198  MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2199  pkt->pts = track->sample_count;
2200  if (codec->channels <= 0 || av_get_bits_per_sample(codec->codec_id) <= 0)
2201  return AVERROR(EINVAL);
2202  track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2203  return 0;
2204 }
2205 
2206 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2207 {
2208  KLVPacket klv;
2209  MXFContext *mxf = s->priv_data;
2210 
2211  while (klv_read_packet(&klv, s->pb) == 0) {
2212  int ret;
2213  PRINT_KEY(s, "read packet", klv.key);
2214  av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2215  if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2216  ret = mxf_decrypt_triplet(s, pkt, &klv);
2217  if (ret < 0) {
2218  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2219  return AVERROR_INVALIDDATA;
2220  }
2221  return 0;
2222  }
2223  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2224  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2225  int index = mxf_get_stream_index(s, &klv);
2226  int64_t next_ofs, next_klv;
2227  AVStream *st;
2228  MXFTrack *track;
2229  AVCodecContext *codec;
2230 
2231  if (index < 0) {
2232  av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2233  goto skip;
2234  }
2235 
2236  st = s->streams[index];
2237  track = st->priv_data;
2238 
2239  if (s->streams[index]->discard == AVDISCARD_ALL)
2240  goto skip;
2241 
2242  next_klv = avio_tell(s->pb) + klv.length;
2243  next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2244 
2245  if (next_ofs >= 0 && next_klv > next_ofs) {
2246  /* if this check is hit then it's possible OPAtom was treated as OP1a
2247  * truncate the packet since it's probably very large (>2 GiB is common) */
2248  avpriv_request_sample(s,
2249  "OPAtom misinterpreted as OP1a?"
2250  "KLV for edit unit %i extending into "
2251  "next edit unit",
2252  mxf->current_edit_unit);
2253  klv.length = next_ofs - avio_tell(s->pb);
2254  }
2255 
2256  /* check for 8 channels AES3 element */
2257  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2258  if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2259  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2260  return AVERROR_INVALIDDATA;
2261  }
2262  } else {
2263  ret = av_get_packet(s->pb, pkt, klv.length);
2264  if (ret < 0)
2265  return ret;
2266  }
2267  pkt->stream_index = index;
2268  pkt->pos = klv.offset;
2269 
2270  codec = s->streams[index]->codec;
2271  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2272  /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2273  MXFIndexTable *t = &mxf->index_tables[0];
2274 
2275  if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2276  pkt->dts = mxf->current_edit_unit + t->first_dts;
2277  pkt->pts = t->ptses[mxf->current_edit_unit];
2278  } else if (track->intra_only) {
2279  /* intra-only -> PTS = EditUnit.
2280  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2281  pkt->pts = mxf->current_edit_unit;
2282  }
2283  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2284  int ret = mxf_set_audio_pts(mxf, codec, pkt);
2285  if (ret < 0)
2286  return ret;
2287  }
2288 
2289  /* seek for truncated packets */
2290  avio_seek(s->pb, next_klv, SEEK_SET);
2291 
2292  return 0;
2293  } else
2294  skip:
2295  avio_skip(s->pb, klv.length);
2296  }
2297  return url_feof(s->pb) ? AVERROR_EOF : -1;
2298 }
2299 
2300 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2301 {
2302  MXFContext *mxf = s->priv_data;
2303  int ret, size;
2304  int64_t ret64, pos, next_pos;
2305  AVStream *st;
2306  MXFIndexTable *t;
2307  int edit_units;
2308 
2309  if (mxf->op != OPAtom)
2310  return mxf_read_packet_old(s, pkt);
2311 
2312  /* OPAtom - clip wrapped demuxing */
2313  /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2314  st = s->streams[0];
2315  t = &mxf->index_tables[0];
2316 
2317  if (mxf->current_edit_unit >= st->duration)
2318  return AVERROR_EOF;
2319 
2320  edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2321 
2322  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2323  return ret;
2324 
2325  /* compute size by finding the next edit unit or the end of the essence container
2326  * not pretty, but it works */
2327  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2328  (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2329  av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2330  return AVERROR_INVALIDDATA;
2331  }
2332 
2333  if ((size = next_pos - pos) <= 0) {
2334  av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2335  return AVERROR_INVALIDDATA;
2336  }
2337 
2338  if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2339  return ret64;
2340 
2341  if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2342  return size;
2343 
2344  pkt->stream_index = 0;
2345 
2346  if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2347  mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2348  pkt->dts = mxf->current_edit_unit + t->first_dts;
2349  pkt->pts = t->ptses[mxf->current_edit_unit];
2350  } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2351  int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2352  if (ret < 0)
2353  return ret;
2354  }
2355 
2356  mxf->current_edit_unit += edit_units;
2357 
2358  return 0;
2359 }
2360 
2361 static int mxf_read_close(AVFormatContext *s)
2362 {
2363  MXFContext *mxf = s->priv_data;
2364  MXFIndexTableSegment *seg;
2365  int i;
2366 
2367  av_freep(&mxf->packages_refs);
2368 
2369  for (i = 0; i < s->nb_streams; i++)
2370  s->streams[i]->priv_data = NULL;
2371 
2372  for (i = 0; i < mxf->metadata_sets_count; i++) {
2373  switch (mxf->metadata_sets[i]->type) {
2374  case Descriptor:
2375  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2376  break;
2377  case MultipleDescriptor:
2378  av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2379  break;
2380  case Sequence:
2381  av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2382  break;
2383  case SourcePackage:
2384  case MaterialPackage:
2385  av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2386  break;
2387  case IndexTableSegment:
2388  seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2389  av_freep(&seg->temporal_offset_entries);
2390  av_freep(&seg->flag_entries);
2391  av_freep(&seg->stream_offset_entries);
2392  break;
2393  default:
2394  break;
2395  }
2396  av_freep(&mxf->metadata_sets[i]);
2397  }
2398  av_freep(&mxf->partitions);
2399  av_freep(&mxf->metadata_sets);
2400  av_freep(&mxf->aesc);
2401  av_freep(&mxf->local_tags);
2402 
2403  if (mxf->index_tables) {
2404  for (i = 0; i < mxf->nb_index_tables; i++) {
2405  av_freep(&mxf->index_tables[i].segments);
2406  av_freep(&mxf->index_tables[i].ptses);
2407  av_freep(&mxf->index_tables[i].fake_index);
2408  }
2409  }
2410  av_freep(&mxf->index_tables);
2411 
2412  return 0;
2413 }
2414 
2415 static int mxf_probe(AVProbeData *p) {
2416  const uint8_t *bufp = p->buf;
2417  const uint8_t *end = p->buf + p->buf_size;
2418 
2419  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2420  return 0;
2421 
2422  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2423  end -= sizeof(mxf_header_partition_pack_key);
2424  for (; bufp < end; bufp++) {
2425  if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
2426  return AVPROBE_SCORE_MAX;
2427  }
2428  return 0;
2429 }
2430 
2431 /* rudimentary byte seek */
2432 /* XXX: use MXF Index */
2433 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2434 {
2435  AVStream *st = s->streams[stream_index];
2436  int64_t seconds;
2437  MXFContext* mxf = s->priv_data;
2438  int64_t seekpos;
2439  int i, ret;
2440  int64_t ret64;
2441  MXFIndexTable *t;
2442  MXFTrack *source_track = st->priv_data;
2443 
2444  /* if audio then truncate sample_time to EditRate */
2445  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2446  sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2447 
2448  if (mxf->nb_index_tables <= 0) {
2449  if (!s->bit_rate)
2450  return AVERROR_INVALIDDATA;
2451  if (sample_time < 0)
2452  sample_time = 0;
2453  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2454 
2455  if ((ret64 = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2456  return ret64;
2457  ff_update_cur_dts(s, st, sample_time);
2458  mxf->current_edit_unit = sample_time;
2459  } else {
2460  t = &mxf->index_tables[0];
2461 
2462  /* clamp above zero, else ff_index_search_timestamp() returns negative
2463  * this also means we allow seeking before the start */
2464  sample_time = FFMAX(sample_time, 0);
2465 
2466  if (t->fake_index) {
2467  /* behave as if we have a proper index */
2468  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2469  return sample_time;
2470  } else {
2471  /* no IndexEntryArray (one or more CBR segments)
2472  * make sure we don't seek past the end */
2473  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2474  }
2475 
2476  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2477  return ret;
2478 
2479  ff_update_cur_dts(s, st, sample_time);
2480  mxf->current_edit_unit = sample_time;
2481  avio_seek(s->pb, seekpos, SEEK_SET);
2482  }
2483 
2484  // Update all tracks sample count
2485  for (i = 0; i < s->nb_streams; i++) {
2486  AVStream *cur_st = s->streams[i];
2487  MXFTrack *cur_track = cur_st->priv_data;
2488  uint64_t current_sample_count = 0;
2489  if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2490  ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2491  if (ret < 0)
2492  return ret;
2493 
2494  cur_track->sample_count = current_sample_count;
2495  }
2496  }
2497  return 0;
2498 }
2499 
2500 AVInputFormat ff_mxf_demuxer = {
2501  .name = "mxf",
2502  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2503  .priv_data_size = sizeof(MXFContext),
2504  .read_probe = mxf_probe,
2505  .read_header = mxf_read_header,
2506  .read_packet = mxf_read_packet,
2507  .read_close = mxf_read_close,
2508  .read_seek = mxf_read_seek,
2509 };
Generated on Sun May 19 2013 19:21:05 for FFmpeg by   doxygen 1.8.2