repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavformat / mxfdec.c
CommitLineData
2ba45a60
DM		 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
58typedef enum {
59 Header,
60 BodyPartition,
61 Footer
62} MXFPartitionType;
63
64typedef 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
78typedef 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
94typedef struct {
95 UID uid;
96 enum MXFMetadataSetType type;
97 UID source_container_ul;
98} MXFCryptoContext;
99
100typedef 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
110typedef 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
120typedef 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
129typedef 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
142typedef 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
168typedef 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
183typedef 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
193typedef struct {
194 UID uid;
195 enum MXFMetadataSetType type;
196} MXFMetadataSet;
197
198/* decoded index table */
199typedef 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
210typedef 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
237enum MXFWrappingScheme {
238 Frame,
239 Clip,
240};
241
242/* NOTE: klv_offset is not set (-1) for local keys */
243typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
244
245typedef struct {
246 const UID key;
247 MXFMetadataReadFunc *read;
248 int ctx_size;
249 enum MXFMetadataSetType type;
250} MXFMetadataReadTableEntry;
251
252static int mxf_read_close(AVFormatContext *s);
253
254/* partial keys to match */
255static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
256static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
257static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
258static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
259static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
260/* complete keys to match */
261static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
262static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
263static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
264static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
265static 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
269static 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
284static 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
297static 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
308static 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 */
323static 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
351static 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
414static 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
436static 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
594static 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
607static 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
617static 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
633static 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
655static 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
671static 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
688static 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
709static 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
734static 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
758static 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
781static 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
818static 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
838static 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 */
923static 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
933static 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
943static 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
958static 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 */
967static 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 */
973static 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
979static 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
989static 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 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
992};
993
994static const char* const mxf_data_essence_descriptor[] = {
995 "vbi_vanc_smpte_436M",
996};
997
998static 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 */
1066static 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 */
1095static 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 */
1116static 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
1164static 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 */
1269static 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;
1356finish_decoding_index:
1357 av_free(sorted_segments);
1358 return ret;
1359}
1360
1361static 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
1369static 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
1377static 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;
1705fail_and_free:
1706 return ret;
1707}
1708
1709static 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
1730static 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
1748static 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
1795static 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
1832static 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
1868static 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 */
1925static 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 */
1946static 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 */
1992static 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 */
2000static 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
2030static 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
2038static 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 */
2049static 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
2074static 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
2098end:
2099 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2100}
2101
2102static 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;
2254fail:
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 */
2264static 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
2301static 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
2342static 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
2361static 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
2461static 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
2522static 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
2576static 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 */
2603static 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
2672AVInputFormat 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};
ffmpeg Piment Noir Debian package repository