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