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