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 * SMPTE 2067-21 Interoperable Master Format — Application #2E
32 *
33 * Principle
34 * Search for Track numbers which will identify essence element KLV packets.
35 * Search for SourcePackage which define tracks which contains Track numbers.
36 * Material Package contains tracks with reference to SourcePackage tracks.
37 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
38 * Assign Descriptors to correct Tracks.
39 *
40 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
41 * Metadata parsing resolves Strong References to objects.
42 *
43 * Simple demuxer, only OP1A supported and some files might not work at all.
44 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
45 */
46
47 #include <inttypes.h>
48
49 #include "libavutil/aes.h"
50 #include "libavutil/avstring.h"
51 #include "libavutil/mastering_display_metadata.h"
52 #include "libavutil/mathematics.h"
53 #include "libavcodec/bytestream.h"
54 #include "libavcodec/internal.h"
55 #include "libavutil/channel_layout.h"
56 #include "libavutil/intreadwrite.h"
57 #include "libavutil/parseutils.h"
58 #include "libavutil/timecode.h"
59 #include "libavutil/opt.h"
60 #include "avformat.h"
61 #include "avlanguage.h"
62 #include "demux.h"
63 #include "internal.h"
64 #include "mxf.h"
65
66 #define MXF_MAX_CHUNK_SIZE (32 << 20)
67 #define RUN_IN_MAX (65535+1) // S377m-2004 section 5.5 and S377-1-2009 section 6.5, the +1 is to be slightly more tolerant
68
69 typedef enum {
70 Header,
71 BodyPartition,
72 Footer
73 } MXFPartitionType;
74
75 typedef enum {
76 OP1a = 1,
77 OP1b,
78 OP1c,
79 OP2a,
80 OP2b,
81 OP2c,
82 OP3a,
83 OP3b,
84 OP3c,
85 OPAtom,
86 OPSONYOpt, /* FATE sample, violates the spec in places */
87 } MXFOP;
88
89 typedef enum {
90 UnknownWrapped = 0,
91 FrameWrapped,
92 ClipWrapped,
93 } MXFWrappingScheme;
94
95 typedef struct MXFPartition {
96 int closed;
97 int complete;
98 MXFPartitionType type;
99 uint64_t previous_partition;
100 int index_sid;
101 int body_sid;
102 int64_t essence_offset; ///< absolute offset of essence
103 int64_t essence_length;
104 int32_t kag_size;
105 int64_t header_byte_count;
106 int64_t index_byte_count;
107 int pack_length;
108 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
109 int64_t body_offset;
110 KLVPacket first_essence_klv;
111 } MXFPartition;
112
113 typedef struct MXFMetadataSet {
114 UID uid;
115 uint64_t partition_score;
116 enum MXFMetadataSetType type;
117 } MXFMetadataSet;
118
119 typedef struct MXFCryptoContext {
120 MXFMetadataSet meta;
121 UID source_container_ul;
122 } MXFCryptoContext;
123
124 typedef struct MXFStructuralComponent {
125 MXFMetadataSet meta;
126 UID source_package_ul;
127 UID source_package_uid;
128 UID data_definition_ul;
129 int64_t duration;
130 int64_t start_position;
131 int source_track_id;
132 } MXFStructuralComponent;
133
134 typedef struct MXFSequence {
135 MXFMetadataSet meta;
136 UID data_definition_ul;
137 UID *structural_components_refs;
138 int structural_components_count;
139 int64_t duration;
140 uint8_t origin;
141 } MXFSequence;
142
143 typedef struct MXFTimecodeComponent {
144 MXFMetadataSet meta;
145 int drop_frame;
146 int start_frame;
147 struct AVRational rate;
148 AVTimecode tc;
149 } MXFTimecodeComponent;
150
151 typedef struct {
152 MXFMetadataSet meta;
153 UID input_segment_ref;
154 } MXFPulldownComponent;
155
156 typedef struct {
157 MXFMetadataSet meta;
158 UID *structural_components_refs;
159 int structural_components_count;
160 int64_t duration;
161 } MXFEssenceGroup;
162
163 typedef struct {
164 MXFMetadataSet meta;
165 char *name;
166 char *value;
167 } MXFTaggedValue;
168
169 typedef struct {
170 MXFMetadataSet meta;
171 MXFSequence *sequence; /* mandatory, and only one */
172 UID sequence_ref;
173 int track_id;
174 char *name;
175 uint8_t track_number[4];
176 AVRational edit_rate;
177 int intra_only;
178 uint64_t sample_count;
179 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
180 int index_sid;
181 int body_sid;
182 MXFWrappingScheme wrapping;
183 int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
184 int require_reordering;
185 int channel_ordering[FF_SANE_NB_CHANNELS];
186 } MXFTrack;
187
188 typedef struct MXFDescriptor {
189 MXFMetadataSet meta;
190 UID essence_container_ul;
191 UID essence_codec_ul;
192 UID codec_ul;
193 AVRational sample_rate;
194 AVRational aspect_ratio;
195 int width;
196 int height; /* Field height, not frame height */
197 int frame_layout; /* See MXFFrameLayout enum */
198 int video_line_map[2];
199 #define MXF_FIELD_DOMINANCE_DEFAULT 0
200 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
201 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
202 int field_dominance;
203 int channels;
204 int bits_per_sample;
205 int64_t duration; /* ContainerDuration optional property */
206 unsigned int component_depth;
207 unsigned int black_ref_level;
208 unsigned int white_ref_level;
209 unsigned int color_range;
210 unsigned int horiz_subsampling;
211 unsigned int vert_subsampling;
212 UID *file_descriptors_refs;
213 int file_descriptors_count;
214 UID *sub_descriptors_refs;
215 int sub_descriptors_count;
216 int linked_track_id;
217 uint8_t *extradata;
218 int extradata_size;
219 enum AVPixelFormat pix_fmt;
220 UID color_primaries_ul;
221 UID color_trc_ul;
222 UID color_space_ul;
223 AVMasteringDisplayMetadata *mastering;
224 AVContentLightMetadata *coll;
225 size_t coll_size;
226 } MXFDescriptor;
227
228 typedef struct MXFMCASubDescriptor {
229 MXFMetadataSet meta;
230 UID uid;
231 UID mca_link_id;
232 UID soundfield_group_link_id;
233 UID *group_of_soundfield_groups_link_id_refs;
234 int group_of_soundfield_groups_link_id_count;
235 UID mca_label_dictionary_id;
236 int mca_channel_id;
237 char *language;
238 } MXFMCASubDescriptor;
239
240 typedef struct MXFIndexTableSegment {
241 MXFMetadataSet meta;
242 int edit_unit_byte_count;
243 int index_sid;
244 int body_sid;
245 AVRational index_edit_rate;
246 uint64_t index_start_position;
247 uint64_t index_duration;
248 int8_t *temporal_offset_entries;
249 int *flag_entries;
250 uint64_t *stream_offset_entries;
251 int nb_index_entries;
252 } MXFIndexTableSegment;
253
254 typedef struct MXFPackage {
255 MXFMetadataSet meta;
256 UID package_uid;
257 UID package_ul;
258 UID *tracks_refs;
259 int tracks_count;
260 MXFDescriptor *descriptor; /* only one */
261 UID descriptor_ref;
262 char *name;
263 UID *comment_refs;
264 int comment_count;
265 } MXFPackage;
266
267 typedef struct MXFEssenceContainerData {
268 MXFMetadataSet meta;
269 UID package_uid;
270 UID package_ul;
271 int index_sid;
272 int body_sid;
273 } MXFEssenceContainerData;
274
275 /* decoded index table */
276 typedef struct MXFIndexTable {
277 int index_sid;
278 int body_sid;
279 int nb_ptses; /* number of PTSes or total duration of index */
280 int64_t first_dts; /* DTS = EditUnit + first_dts */
281 int64_t *ptses; /* maps EditUnit -> PTS */
282 int nb_segments;
283 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
284 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
285 int8_t *offsets; /* temporal offsets for display order to stored order conversion */
286 } MXFIndexTable;
287
288 typedef struct MXFContext {
289 const AVClass *class; /**< Class for private options. */
290 MXFPartition *partitions;
291 unsigned partitions_count;
292 MXFOP op;
293 UID *packages_refs;
294 int packages_count;
295 UID *essence_container_data_refs;
296 int essence_container_data_count;
297 MXFMetadataSet **metadata_sets;
298 int metadata_sets_count;
299 AVFormatContext *fc;
300 struct AVAES *aesc;
301 uint8_t *local_tags;
302 int local_tags_count;
303 uint64_t footer_partition;
304 KLVPacket current_klv_data;
305 int run_in;
306 MXFPartition *current_partition;
307 int parsing_backward;
308 int64_t last_forward_tell;
309 int last_forward_partition;
310 int nb_index_tables;
311 MXFIndexTable *index_tables;
312 int eia608_extract;
313 } MXFContext;
314
315 /* NOTE: klv_offset is not set (-1) for local keys */
316 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
317
318 typedef struct MXFMetadataReadTableEntry {
319 const UID key;
320 MXFMetadataReadFunc *read;
321 int ctx_size;
322 enum MXFMetadataSetType type;
323 } MXFMetadataReadTableEntry;
324
325 /* partial keys to match */
326 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
327 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
328 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
329 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
330 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
331 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
332 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
333 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
334
335 /* complete keys to match */
336 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
337 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
338 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
339 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
340 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
341 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00 };
342 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
343 static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
344 static const uint8_t mxf_apple_coll_max_cll[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x01 };
345 static const uint8_t mxf_apple_coll_max_fall[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x02 };
346
347 static const uint8_t mxf_mca_label_dictionary_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x01,0x00,0x00,0x00 };
348 static const uint8_t mxf_mca_tag_symbol[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x02,0x00,0x00,0x00 };
349 static const uint8_t mxf_mca_tag_name[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x03,0x00,0x00,0x00 };
350 static const uint8_t mxf_group_of_soundfield_groups_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x04,0x00,0x00,0x00 };
351 static const uint8_t mxf_mca_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x05,0x00,0x00,0x00 };
352 static const uint8_t mxf_mca_channel_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x04,0x0a,0x00,0x00,0x00,0x00 };
353 static const uint8_t mxf_soundfield_group_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x06,0x00,0x00,0x00 };
354 static const uint8_t mxf_mca_rfc5646_spoken_language[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0d,0x03,0x01,0x01,0x02,0x03,0x15,0x00,0x00 };
355
356 static const uint8_t mxf_sub_descriptor[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00 };
357
358 static const uint8_t mxf_mastering_display_prefix[13] = { FF_MXF_MasteringDisplay_PREFIX };
359 static const uint8_t mxf_mastering_display_uls[4][16] = {
360 FF_MXF_MasteringDisplayPrimaries,
361 FF_MXF_MasteringDisplayWhitePointChromaticity,
362 FF_MXF_MasteringDisplayMaximumLuminance,
363 FF_MXF_MasteringDisplayMinimumLuminance,
364 };
365
366 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
367
mxf_free_metadataset(MXFMetadataSet ** ctx,int freectx)368 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
369 {
370 MXFIndexTableSegment *seg;
371 switch ((*ctx)->type) {
372 case Descriptor:
373 case MultipleDescriptor:
374 av_freep(&((MXFDescriptor *)*ctx)->extradata);
375 av_freep(&((MXFDescriptor *)*ctx)->mastering);
376 av_freep(&((MXFDescriptor *)*ctx)->coll);
377 av_freep(&((MXFDescriptor *)*ctx)->file_descriptors_refs);
378 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
379 break;
380 case AudioChannelLabelSubDescriptor:
381 case SoundfieldGroupLabelSubDescriptor:
382 case GroupOfSoundfieldGroupsLabelSubDescriptor:
383 av_freep(&((MXFMCASubDescriptor *)*ctx)->language);
384 av_freep(&((MXFMCASubDescriptor *)*ctx)->group_of_soundfield_groups_link_id_refs);
385 break;
386 case Sequence:
387 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
388 break;
389 case EssenceGroup:
390 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
391 break;
392 case SourcePackage:
393 case MaterialPackage:
394 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
395 av_freep(&((MXFPackage *)*ctx)->name);
396 av_freep(&((MXFPackage *)*ctx)->comment_refs);
397 break;
398 case TaggedValue:
399 av_freep(&((MXFTaggedValue *)*ctx)->name);
400 av_freep(&((MXFTaggedValue *)*ctx)->value);
401 break;
402 case Track:
403 av_freep(&((MXFTrack *)*ctx)->name);
404 break;
405 case IndexTableSegment:
406 seg = (MXFIndexTableSegment *)*ctx;
407 av_freep(&seg->temporal_offset_entries);
408 av_freep(&seg->flag_entries);
409 av_freep(&seg->stream_offset_entries);
410 default:
411 break;
412 }
413 if (freectx) {
414 av_freep(ctx);
415 }
416 }
417
klv_decode_ber_length(AVIOContext * pb)418 static int64_t klv_decode_ber_length(AVIOContext *pb)
419 {
420 uint64_t size = avio_r8(pb);
421 if (size & 0x80) { /* long form */
422 int bytes_num = size & 0x7f;
423 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
424 if (bytes_num > 8)
425 return AVERROR_INVALIDDATA;
426 size = 0;
427 while (bytes_num--)
428 size = size << 8 | avio_r8(pb);
429 }
430 if (size > INT64_MAX)
431 return AVERROR_INVALIDDATA;
432 return size;
433 }
434
mxf_read_sync(AVIOContext * pb,const uint8_t * key,unsigned size)435 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
436 {
437 int i, b;
438 for (i = 0; i < size && !avio_feof(pb); i++) {
439 b = avio_r8(pb);
440 if (b == key[0])
441 i = 0;
442 else if (b != key[i])
443 i = -1;
444 }
445 return i == size;
446 }
447
klv_read_packet(MXFContext * mxf,KLVPacket * klv,AVIOContext * pb)448 static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
449 {
450 int64_t length, pos;
451 if (!mxf_read_sync(pb, mxf_klv_key, 4))
452 return AVERROR_INVALIDDATA;
453 klv->offset = avio_tell(pb) - 4;
454 if (klv->offset < mxf->run_in)
455 return AVERROR_INVALIDDATA;
456
457 memcpy(klv->key, mxf_klv_key, 4);
458 avio_read(pb, klv->key + 4, 12);
459 length = klv_decode_ber_length(pb);
460 if (length < 0)
461 return length;
462 klv->length = length;
463 pos = avio_tell(pb);
464 if (pos > INT64_MAX - length)
465 return AVERROR_INVALIDDATA;
466 klv->next_klv = pos + length;
467 return 0;
468 }
469
mxf_get_stream_index(AVFormatContext * s,KLVPacket * klv,int body_sid)470 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
471 {
472 int i;
473
474 for (i = 0; i < s->nb_streams; i++) {
475 MXFTrack *track = s->streams[i]->priv_data;
476 /* SMPTE 379M 7.3 */
477 if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
478 return i;
479 }
480 /* return 0 if only one stream, for OP Atom files with 0 as track number */
481 return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
482 }
483
find_body_sid_by_absolute_offset(MXFContext * mxf,int64_t offset)484 static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
485 {
486 // we look for partition where the offset is placed
487 int a, b, m;
488 int64_t pack_ofs;
489
490 a = -1;
491 b = mxf->partitions_count;
492
493 while (b - a > 1) {
494 m = (a + b) >> 1;
495 pack_ofs = mxf->partitions[m].pack_ofs;
496 if (pack_ofs <= offset)
497 a = m;
498 else
499 b = m;
500 }
501
502 if (a == -1)
503 return 0;
504 return mxf->partitions[a].body_sid;
505 }
506
mxf_get_eia608_packet(AVFormatContext * s,AVStream * st,AVPacket * pkt,int64_t length)507 static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
508 {
509 int count = avio_rb16(s->pb);
510 int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
511 int line_num, sample_coding, sample_count;
512 int did, sdid, data_length;
513 int i, ret;
514
515 if (count != 1)
516 av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
517
518 for (i = 0; i < count; i++) {
519 if (length < 6) {
520 av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
521 return AVERROR_INVALIDDATA;
522 }
523 line_num = avio_rb16(s->pb);
524 avio_r8(s->pb); // wrapping type
525 sample_coding = avio_r8(s->pb);
526 sample_count = avio_rb16(s->pb);
527 length -= 6 + 8 + sample_count;
528 if (line_num != 9 && line_num != 11)
529 continue;
530 if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
531 av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
532 continue;
533 }
534 if (length < 0)
535 return AVERROR_INVALIDDATA;
536
537 avio_rb32(s->pb); // array count
538 avio_rb32(s->pb); // array elem size
539 did = avio_r8(s->pb);
540 sdid = avio_r8(s->pb);
541 data_length = avio_r8(s->pb);
542 if (did != 0x61 || sdid != 1) {
543 av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
544 continue;
545 }
546 cdp_identifier = avio_rb16(s->pb); // cdp id
547 if (cdp_identifier != 0x9669) {
548 av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
549 return AVERROR_INVALIDDATA;
550 }
551 cdp_length = avio_r8(s->pb);
552 avio_r8(s->pb); // cdp_frame_rate
553 avio_r8(s->pb); // cdp_flags
554 avio_rb16(s->pb); // cdp_hdr_sequence_cntr
555 ccdata_id = avio_r8(s->pb); // ccdata_id
556 if (ccdata_id != 0x72) {
557 av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
558 return AVERROR_INVALIDDATA;
559 }
560 cc_count = avio_r8(s->pb) & 0x1f;
561 ret = av_get_packet(s->pb, pkt, cc_count * 3);
562 if (ret < 0)
563 return ret;
564 if (cdp_length - 9 - 4 < cc_count * 3) {
565 av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
566 return AVERROR_INVALIDDATA;
567 }
568 avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
569 cdp_footer_id = avio_r8(s->pb);
570 if (cdp_footer_id != 0x74) {
571 av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
572 return AVERROR_INVALIDDATA;
573 }
574 avio_rb16(s->pb); // cdp_ftr_sequence_cntr
575 avio_r8(s->pb); // packet_checksum
576 break;
577 }
578
579 return 0;
580 }
581
582 /* XXX: use AVBitStreamFilter */
mxf_get_d10_aes3_packet(AVIOContext * pb,AVStream * st,AVPacket * pkt,int64_t length)583 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
584 {
585 const uint8_t *buf_ptr, *end_ptr;
586 uint8_t *data_ptr;
587 int i;
588
589 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
590 return AVERROR_INVALIDDATA;
591 length = av_get_packet(pb, pkt, length);
592 if (length < 0)
593 return length;
594 data_ptr = pkt->data;
595 end_ptr = pkt->data + length;
596 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
597
598 if (st->codecpar->ch_layout.nb_channels > 8)
599 return AVERROR_INVALIDDATA;
600
601 for (; end_ptr - buf_ptr >= st->codecpar->ch_layout.nb_channels * 4; ) {
602 for (i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {
603 uint32_t sample = bytestream_get_le32(&buf_ptr);
604 if (st->codecpar->bits_per_coded_sample == 24)
605 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
606 else
607 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
608 }
609 // always 8 channels stored SMPTE 331M
610 buf_ptr += 32 - st->codecpar->ch_layout.nb_channels * 4;
611 }
612 av_shrink_packet(pkt, data_ptr - pkt->data);
613 return 0;
614 }
615
mxf_decrypt_triplet(AVFormatContext * s,AVPacket * pkt,KLVPacket * klv)616 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
617 {
618 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
619 MXFContext *mxf = s->priv_data;
620 AVIOContext *pb = s->pb;
621 int64_t end = avio_tell(pb) + klv->length;
622 int64_t size;
623 uint64_t orig_size;
624 uint64_t plaintext_size;
625 uint8_t ivec[16];
626 uint8_t tmpbuf[16];
627 int index;
628 int body_sid;
629
630 if (!mxf->aesc && s->key && s->keylen == 16) {
631 mxf->aesc = av_aes_alloc();
632 if (!mxf->aesc)
633 return AVERROR(ENOMEM);
634 av_aes_init(mxf->aesc, s->key, 128, 1);
635 }
636 // crypto context
637 size = klv_decode_ber_length(pb);
638 if (size < 0)
639 return size;
640 avio_skip(pb, size);
641 // plaintext offset
642 klv_decode_ber_length(pb);
643 plaintext_size = avio_rb64(pb);
644 // source klv key
645 klv_decode_ber_length(pb);
646 avio_read(pb, klv->key, 16);
647 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
648 return AVERROR_INVALIDDATA;
649
650 body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
651 index = mxf_get_stream_index(s, klv, body_sid);
652 if (index < 0)
653 return AVERROR_INVALIDDATA;
654 // source size
655 klv_decode_ber_length(pb);
656 orig_size = avio_rb64(pb);
657 if (orig_size < plaintext_size)
658 return AVERROR_INVALIDDATA;
659 // enc. code
660 size = klv_decode_ber_length(pb);
661 if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)
662 return AVERROR_INVALIDDATA;
663 avio_read(pb, ivec, 16);
664 avio_read(pb, tmpbuf, 16);
665 if (mxf->aesc)
666 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
667 if (memcmp(tmpbuf, checkv, 16))
668 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
669 size -= 32;
670 size = av_get_packet(pb, pkt, size);
671 if (size < 0)
672 return size;
673 else if (size < plaintext_size)
674 return AVERROR_INVALIDDATA;
675 size -= plaintext_size;
676 if (mxf->aesc)
677 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
678 &pkt->data[plaintext_size], size >> 4, ivec, 1);
679 av_shrink_packet(pkt, orig_size);
680 pkt->stream_index = index;
681 avio_skip(pb, end - avio_tell(pb));
682 return 0;
683 }
684
mxf_read_primer_pack(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)685 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
686 {
687 MXFContext *mxf = arg;
688 int item_num = avio_rb32(pb);
689 int item_len = avio_rb32(pb);
690
691 if (item_len != 18) {
692 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
693 return AVERROR_PATCHWELCOME;
694 }
695 if (item_num > 65536 || item_num < 0) {
696 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
697 return AVERROR_INVALIDDATA;
698 }
699 if (mxf->local_tags)
700 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
701 av_free(mxf->local_tags);
702 mxf->local_tags_count = 0;
703 mxf->local_tags = av_calloc(item_num, item_len);
704 if (!mxf->local_tags)
705 return AVERROR(ENOMEM);
706 mxf->local_tags_count = item_num;
707 avio_read(pb, mxf->local_tags, item_num*item_len);
708 return 0;
709 }
710
mxf_read_partition_pack(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)711 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
712 {
713 MXFContext *mxf = arg;
714 AVFormatContext *s = mxf->fc;
715 MXFPartition *partition, *tmp_part;
716 UID op;
717 uint64_t footer_partition;
718 uint32_t nb_essence_containers;
719 uint64_t this_partition;
720
721 if (mxf->partitions_count >= INT_MAX / 2)
722 return AVERROR_INVALIDDATA;
723
724 av_assert0(klv_offset >= mxf->run_in);
725
726 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
727 if (!tmp_part)
728 return AVERROR(ENOMEM);
729 mxf->partitions = tmp_part;
730
731 if (mxf->parsing_backward) {
732 /* insert the new partition pack in the middle
733 * this makes the entries in mxf->partitions sorted by offset */
734 memmove(&mxf->partitions[mxf->last_forward_partition+1],
735 &mxf->partitions[mxf->last_forward_partition],
736 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
737 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
738 } else {
739 mxf->last_forward_partition++;
740 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
741 }
742
743 memset(partition, 0, sizeof(*partition));
744 mxf->partitions_count++;
745 partition->pack_length = avio_tell(pb) - klv_offset + size;
746 partition->pack_ofs = klv_offset;
747
748 switch(uid[13]) {
749 case 2:
750 partition->type = Header;
751 break;
752 case 3:
753 partition->type = BodyPartition;
754 break;
755 case 4:
756 partition->type = Footer;
757 break;
758 default:
759 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
760 return AVERROR_INVALIDDATA;
761 }
762
763 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
764 partition->closed = partition->type == Footer || !(uid[14] & 1);
765 partition->complete = uid[14] > 2;
766 avio_skip(pb, 4);
767 partition->kag_size = avio_rb32(pb);
768 this_partition = avio_rb64(pb);
769 if (this_partition != klv_offset - mxf->run_in) {
770 av_log(mxf->fc, AV_LOG_ERROR,
771 "this_partition %"PRId64" mismatches %"PRId64"\n",
772 this_partition, klv_offset - mxf->run_in);
773 return AVERROR_INVALIDDATA;
774 }
775 partition->previous_partition = avio_rb64(pb);
776 footer_partition = avio_rb64(pb);
777 partition->header_byte_count = avio_rb64(pb);
778 partition->index_byte_count = avio_rb64(pb);
779 partition->index_sid = avio_rb32(pb);
780 partition->body_offset = avio_rb64(pb);
781 partition->body_sid = avio_rb32(pb);
782 if (partition->body_offset < 0)
783 return AVERROR_INVALIDDATA;
784
785 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
786 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
787 return AVERROR_INVALIDDATA;
788 }
789 nb_essence_containers = avio_rb32(pb);
790
791 if (partition->type == Header) {
792 char str[36];
793 snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));
794 av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);
795 }
796
797 if (this_partition &&
798 partition->previous_partition == this_partition) {
799 av_log(mxf->fc, AV_LOG_ERROR,
800 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
801 partition->previous_partition);
802 /* override with the actual previous partition offset */
803 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
804 MXFPartition *prev =
805 mxf->partitions + mxf->last_forward_partition - 2;
806 partition->previous_partition = prev->pack_ofs - mxf->run_in;
807 }
808 /* if no previous body partition are found point to the header
809 * partition */
810 if (partition->previous_partition == this_partition)
811 partition->previous_partition = 0;
812 av_log(mxf->fc, AV_LOG_ERROR,
813 "Overriding PreviousPartition with %"PRIx64"\n",
814 partition->previous_partition);
815 }
816
817 /* some files don't have FooterPartition set in every partition */
818 if (footer_partition) {
819 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
820 av_log(mxf->fc, AV_LOG_ERROR,
821 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
822 mxf->footer_partition, footer_partition);
823 } else {
824 mxf->footer_partition = footer_partition;
825 }
826 }
827
828 av_log(mxf->fc, AV_LOG_TRACE,
829 "PartitionPack: ThisPartition = 0x%"PRIX64
830 ", PreviousPartition = 0x%"PRIX64", "
831 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
832 this_partition,
833 partition->previous_partition, footer_partition,
834 partition->index_sid, partition->body_sid);
835
836 /* sanity check PreviousPartition if set */
837 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
838 if (partition->previous_partition &&
839 mxf->run_in + partition->previous_partition >= klv_offset) {
840 av_log(mxf->fc, AV_LOG_ERROR,
841 "PreviousPartition points to this partition or forward\n");
842 return AVERROR_INVALIDDATA;
843 }
844
845 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
846 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
847 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
848 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
849 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
850 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
851 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
852 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
853 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
854 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
855 else if (op[12] == 0x10) {
856 /* SMPTE 390m: "There shall be exactly one essence container"
857 * The following block deals with files that violate this, namely:
858 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
859 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
860 if (nb_essence_containers != 1) {
861 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
862
863 /* only nag once */
864 if (!mxf->op)
865 av_log(mxf->fc, AV_LOG_WARNING,
866 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
867 nb_essence_containers,
868 op == OP1a ? "OP1a" : "OPAtom");
869
870 mxf->op = op;
871 } else
872 mxf->op = OPAtom;
873 } else {
874 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
875 mxf->op = OP1a;
876 }
877
878 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
879 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
880 partition->kag_size);
881
882 if (mxf->op == OPSONYOpt)
883 partition->kag_size = 512;
884 else
885 partition->kag_size = 1;
886
887 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
888 }
889
890 return 0;
891 }
892
partition_score(MXFPartition * p)893 static uint64_t partition_score(MXFPartition *p)
894 {
895 uint64_t score;
896 if (!p)
897 return 0;
898 if (p->type == Footer)
899 score = 5;
900 else if (p->complete)
901 score = 4;
902 else if (p->closed)
903 score = 3;
904 else
905 score = 1;
906 return (score << 60) | ((uint64_t)p->pack_ofs >> 4);
907 }
908
mxf_add_metadata_set(MXFContext * mxf,MXFMetadataSet ** metadata_set)909 static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set)
910 {
911 MXFMetadataSet **tmp;
912 enum MXFMetadataSetType type = (*metadata_set)->type;
913
914 // Index Table is special because it might be added manually without
915 // partition and we iterate thorugh all instances of them. Also some files
916 // use the same Instance UID for different index tables...
917 if (type != IndexTableSegment) {
918 for (int i = 0; i < mxf->metadata_sets_count; i++) {
919 if (!memcmp((*metadata_set)->uid, mxf->metadata_sets[i]->uid, 16) && type == mxf->metadata_sets[i]->type) {
920 uint64_t old_s = mxf->metadata_sets[i]->partition_score;
921 uint64_t new_s = (*metadata_set)->partition_score;
922 if (old_s > new_s) {
923 mxf_free_metadataset(metadata_set, 1);
924 return 0;
925 }
926 }
927 }
928 }
929 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
930 if (!tmp) {
931 mxf_free_metadataset(metadata_set, 1);
932 return AVERROR(ENOMEM);
933 }
934 mxf->metadata_sets = tmp;
935 mxf->metadata_sets[mxf->metadata_sets_count] = *metadata_set;
936 mxf->metadata_sets_count++;
937 return 0;
938 }
939
mxf_read_cryptographic_context(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)940 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
941 {
942 MXFCryptoContext *cryptocontext = arg;
943 if (size != 16)
944 return AVERROR_INVALIDDATA;
945 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
946 avio_read(pb, cryptocontext->source_container_ul, 16);
947 return 0;
948 }
949
mxf_read_strong_ref_array(AVIOContext * pb,UID ** refs,int * count)950 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
951 {
952 int64_t ret;
953 unsigned c = avio_rb32(pb);
954
955 //avio_read() used int
956 if (c > INT_MAX / sizeof(UID))
957 return AVERROR_PATCHWELCOME;
958 *count = c;
959
960 av_free(*refs);
961 *refs = av_malloc_array(*count, sizeof(UID));
962 if (!*refs) {
963 *count = 0;
964 return AVERROR(ENOMEM);
965 }
966 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
967 ret = avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
968 if (ret != *count * sizeof(UID)) {
969 *count = ret < 0 ? 0 : ret / sizeof(UID);
970 return ret < 0 ? ret : AVERROR_INVALIDDATA;
971 }
972
973 return 0;
974 }
975
mxf_read_us_ascii_string(AVIOContext * pb,int size,char ** str)976 static inline int mxf_read_us_ascii_string(AVIOContext *pb, int size, char** str)
977 {
978 int ret;
979 size_t buf_size;
980
981 if (size < 0 || size > INT_MAX - 1)
982 return AVERROR(EINVAL);
983
984 buf_size = size + 1;
985 av_free(*str);
986 *str = av_malloc(buf_size);
987 if (!*str)
988 return AVERROR(ENOMEM);
989
990 ret = avio_get_str(pb, size, *str, buf_size);
991
992 if (ret < 0) {
993 av_freep(str);
994 return ret;
995 }
996
997 return ret;
998 }
999
mxf_read_utf16_string(AVIOContext * pb,int size,char ** str,int be)1000 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
1001 {
1002 int ret;
1003 size_t buf_size;
1004
1005 if (size < 0 || size > INT_MAX/2)
1006 return AVERROR(EINVAL);
1007
1008 buf_size = size + size / 2 + 1;
1009 av_free(*str);
1010 *str = av_malloc(buf_size);
1011 if (!*str)
1012 return AVERROR(ENOMEM);
1013
1014 if (be)
1015 ret = avio_get_str16be(pb, size, *str, buf_size);
1016 else
1017 ret = avio_get_str16le(pb, size, *str, buf_size);
1018
1019 if (ret < 0) {
1020 av_freep(str);
1021 return ret;
1022 }
1023
1024 return ret;
1025 }
1026
1027 #define READ_STR16(type, big_endian) \
1028 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
1029 { \
1030 return mxf_read_utf16_string(pb, size, str, big_endian); \
1031 }
1032 READ_STR16(be, 1)
1033 READ_STR16(le, 0)
1034 #undef READ_STR16
1035
mxf_read_content_storage(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1036 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1037 {
1038 MXFContext *mxf = arg;
1039 switch (tag) {
1040 case 0x1901:
1041 if (mxf->packages_refs)
1042 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
1043 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
1044 case 0x1902:
1045 return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
1046 }
1047 return 0;
1048 }
1049
mxf_read_source_clip(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1050 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1051 {
1052 MXFStructuralComponent *source_clip = arg;
1053 switch(tag) {
1054 case 0x0202:
1055 source_clip->duration = avio_rb64(pb);
1056 break;
1057 case 0x1201:
1058 source_clip->start_position = avio_rb64(pb);
1059 break;
1060 case 0x1101:
1061 /* UMID, only get last 16 bytes */
1062 avio_read(pb, source_clip->source_package_ul, 16);
1063 avio_read(pb, source_clip->source_package_uid, 16);
1064 break;
1065 case 0x1102:
1066 source_clip->source_track_id = avio_rb32(pb);
1067 break;
1068 }
1069 return 0;
1070 }
1071
mxf_read_timecode_component(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1072 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1073 {
1074 MXFTimecodeComponent *mxf_timecode = arg;
1075 switch(tag) {
1076 case 0x1501:
1077 mxf_timecode->start_frame = avio_rb64(pb);
1078 break;
1079 case 0x1502:
1080 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
1081 break;
1082 case 0x1503:
1083 mxf_timecode->drop_frame = avio_r8(pb);
1084 break;
1085 }
1086 return 0;
1087 }
1088
mxf_read_pulldown_component(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1089 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1090 {
1091 MXFPulldownComponent *mxf_pulldown = arg;
1092 switch(tag) {
1093 case 0x0d01:
1094 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
1095 break;
1096 }
1097 return 0;
1098 }
1099
mxf_read_track(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1100 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1101 {
1102 MXFTrack *track = arg;
1103 switch(tag) {
1104 case 0x4801:
1105 track->track_id = avio_rb32(pb);
1106 break;
1107 case 0x4804:
1108 avio_read(pb, track->track_number, 4);
1109 break;
1110 case 0x4802:
1111 mxf_read_utf16be_string(pb, size, &track->name);
1112 break;
1113 case 0x4b01:
1114 track->edit_rate.num = avio_rb32(pb);
1115 track->edit_rate.den = avio_rb32(pb);
1116 break;
1117 case 0x4803:
1118 avio_read(pb, track->sequence_ref, 16);
1119 break;
1120 }
1121 return 0;
1122 }
1123
mxf_read_sequence(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1124 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1125 {
1126 MXFSequence *sequence = arg;
1127 switch(tag) {
1128 case 0x0202:
1129 sequence->duration = avio_rb64(pb);
1130 break;
1131 case 0x0201:
1132 avio_read(pb, sequence->data_definition_ul, 16);
1133 break;
1134 case 0x4b02:
1135 sequence->origin = avio_r8(pb);
1136 break;
1137 case 0x1001:
1138 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
1139 &sequence->structural_components_count);
1140 }
1141 return 0;
1142 }
1143
mxf_read_essence_group(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1144 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1145 {
1146 MXFEssenceGroup *essence_group = arg;
1147 switch (tag) {
1148 case 0x0202:
1149 essence_group->duration = avio_rb64(pb);
1150 break;
1151 case 0x0501:
1152 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
1153 &essence_group->structural_components_count);
1154 }
1155 return 0;
1156 }
1157
mxf_read_package(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1158 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1159 {
1160 MXFPackage *package = arg;
1161 switch(tag) {
1162 case 0x4403:
1163 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
1164 &package->tracks_count);
1165 case 0x4401:
1166 /* UMID */
1167 avio_read(pb, package->package_ul, 16);
1168 avio_read(pb, package->package_uid, 16);
1169 break;
1170 case 0x4701:
1171 avio_read(pb, package->descriptor_ref, 16);
1172 break;
1173 case 0x4402:
1174 return mxf_read_utf16be_string(pb, size, &package->name);
1175 case 0x4406:
1176 return mxf_read_strong_ref_array(pb, &package->comment_refs,
1177 &package->comment_count);
1178 }
1179 return 0;
1180 }
1181
mxf_read_essence_container_data(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1182 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1183 {
1184 MXFEssenceContainerData *essence_data = arg;
1185 switch(tag) {
1186 case 0x2701:
1187 /* linked package umid UMID */
1188 avio_read(pb, essence_data->package_ul, 16);
1189 avio_read(pb, essence_data->package_uid, 16);
1190 break;
1191 case 0x3f06:
1192 essence_data->index_sid = avio_rb32(pb);
1193 break;
1194 case 0x3f07:
1195 essence_data->body_sid = avio_rb32(pb);
1196 break;
1197 }
1198 return 0;
1199 }
1200
mxf_read_index_entry_array(AVIOContext * pb,MXFIndexTableSegment * segment)1201 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
1202 {
1203 int i, length;
1204
1205 if (segment->temporal_offset_entries)
1206 return AVERROR_INVALIDDATA;
1207
1208 segment->nb_index_entries = avio_rb32(pb);
1209
1210 length = avio_rb32(pb);
1211 if(segment->nb_index_entries && length < 11)
1212 return AVERROR_INVALIDDATA;
1213
1214 if (!FF_ALLOC_TYPED_ARRAY(segment->temporal_offset_entries, segment->nb_index_entries) ||
1215 !FF_ALLOC_TYPED_ARRAY(segment->flag_entries , segment->nb_index_entries) ||
1216 !FF_ALLOC_TYPED_ARRAY(segment->stream_offset_entries , segment->nb_index_entries)) {
1217 av_freep(&segment->temporal_offset_entries);
1218 av_freep(&segment->flag_entries);
1219 return AVERROR(ENOMEM);
1220 }
1221
1222 for (i = 0; i < segment->nb_index_entries; i++) {
1223 if(avio_feof(pb))
1224 return AVERROR_INVALIDDATA;
1225 segment->temporal_offset_entries[i] = avio_r8(pb);
1226 avio_r8(pb); /* KeyFrameOffset */
1227 segment->flag_entries[i] = avio_r8(pb);
1228 segment->stream_offset_entries[i] = avio_rb64(pb);
1229 avio_skip(pb, length - 11);
1230 }
1231 return 0;
1232 }
1233
mxf_read_index_table_segment(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1234 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1235 {
1236 MXFIndexTableSegment *segment = arg;
1237 switch(tag) {
1238 case 0x3F05:
1239 segment->edit_unit_byte_count = avio_rb32(pb);
1240 av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1241 break;
1242 case 0x3F06:
1243 segment->index_sid = avio_rb32(pb);
1244 av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1245 break;
1246 case 0x3F07:
1247 segment->body_sid = avio_rb32(pb);
1248 av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1249 break;
1250 case 0x3F0A:
1251 av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1252 return mxf_read_index_entry_array(pb, segment);
1253 case 0x3F0B:
1254 segment->index_edit_rate.num = avio_rb32(pb);
1255 segment->index_edit_rate.den = avio_rb32(pb);
1256 av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1257 segment->index_edit_rate.den);
1258 break;
1259 case 0x3F0C:
1260 segment->index_start_position = avio_rb64(pb);
1261 av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1262 break;
1263 case 0x3F0D:
1264 segment->index_duration = avio_rb64(pb);
1265 av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1266 break;
1267 }
1268 return 0;
1269 }
1270
mxf_read_pixel_layout(AVIOContext * pb,MXFDescriptor * descriptor)1271 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1272 {
1273 int code, value, ofs = 0;
1274 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1275
1276 do {
1277 code = avio_r8(pb);
1278 value = avio_r8(pb);
1279 av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1280
1281 if (ofs <= 14) {
1282 layout[ofs++] = code;
1283 layout[ofs++] = value;
1284 } else
1285 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1286 } while (code != 0); /* SMPTE 377M E.2.46 */
1287
1288 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1289 }
1290
mxf_read_generic_descriptor(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1291 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1292 {
1293 MXFDescriptor *descriptor = arg;
1294 int entry_count, entry_size;
1295
1296 switch(tag) {
1297 case 0x3F01:
1298 return mxf_read_strong_ref_array(pb, &descriptor->file_descriptors_refs,
1299 &descriptor->file_descriptors_count);
1300 case 0x3002: /* ContainerDuration */
1301 descriptor->duration = avio_rb64(pb);
1302 break;
1303 case 0x3004:
1304 avio_read(pb, descriptor->essence_container_ul, 16);
1305 break;
1306 case 0x3005:
1307 avio_read(pb, descriptor->codec_ul, 16);
1308 break;
1309 case 0x3006:
1310 descriptor->linked_track_id = avio_rb32(pb);
1311 break;
1312 case 0x3201: /* PictureEssenceCoding */
1313 avio_read(pb, descriptor->essence_codec_ul, 16);
1314 break;
1315 case 0x3203:
1316 descriptor->width = avio_rb32(pb);
1317 break;
1318 case 0x3202:
1319 descriptor->height = avio_rb32(pb);
1320 break;
1321 case 0x320C:
1322 descriptor->frame_layout = avio_r8(pb);
1323 break;
1324 case 0x320D:
1325 entry_count = avio_rb32(pb);
1326 entry_size = avio_rb32(pb);
1327 if (entry_size == 4) {
1328 if (entry_count > 0)
1329 descriptor->video_line_map[0] = avio_rb32(pb);
1330 else
1331 descriptor->video_line_map[0] = 0;
1332 if (entry_count > 1)
1333 descriptor->video_line_map[1] = avio_rb32(pb);
1334 else
1335 descriptor->video_line_map[1] = 0;
1336 } else
1337 av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1338 break;
1339 case 0x320E:
1340 descriptor->aspect_ratio.num = avio_rb32(pb);
1341 descriptor->aspect_ratio.den = avio_rb32(pb);
1342 break;
1343 case 0x3210:
1344 avio_read(pb, descriptor->color_trc_ul, 16);
1345 break;
1346 case 0x3212:
1347 descriptor->field_dominance = avio_r8(pb);
1348 break;
1349 case 0x3219:
1350 avio_read(pb, descriptor->color_primaries_ul, 16);
1351 break;
1352 case 0x321A:
1353 avio_read(pb, descriptor->color_space_ul, 16);
1354 break;
1355 case 0x3301:
1356 descriptor->component_depth = avio_rb32(pb);
1357 break;
1358 case 0x3302:
1359 descriptor->horiz_subsampling = avio_rb32(pb);
1360 break;
1361 case 0x3304:
1362 descriptor->black_ref_level = avio_rb32(pb);
1363 break;
1364 case 0x3305:
1365 descriptor->white_ref_level = avio_rb32(pb);
1366 break;
1367 case 0x3306:
1368 descriptor->color_range = avio_rb32(pb);
1369 break;
1370 case 0x3308:
1371 descriptor->vert_subsampling = avio_rb32(pb);
1372 break;
1373 case 0x3D03:
1374 descriptor->sample_rate.num = avio_rb32(pb);
1375 descriptor->sample_rate.den = avio_rb32(pb);
1376 break;
1377 case 0x3D06: /* SoundEssenceCompression */
1378 avio_read(pb, descriptor->essence_codec_ul, 16);
1379 break;
1380 case 0x3D07:
1381 descriptor->channels = avio_rb32(pb);
1382 break;
1383 case 0x3D01:
1384 descriptor->bits_per_sample = avio_rb32(pb);
1385 break;
1386 case 0x3401:
1387 mxf_read_pixel_layout(pb, descriptor);
1388 break;
1389 default:
1390 /* Private uid used by SONY C0023S01.mxf */
1391 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1392 if (descriptor->extradata)
1393 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1394 av_free(descriptor->extradata);
1395 descriptor->extradata_size = 0;
1396 descriptor->extradata = av_malloc(size);
1397 if (!descriptor->extradata)
1398 return AVERROR(ENOMEM);
1399 descriptor->extradata_size = size;
1400 avio_read(pb, descriptor->extradata, size);
1401 }
1402 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1403 uint32_t rsiz = avio_rb16(pb);
1404 if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1405 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1406 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1407 }
1408 if (IS_KLV_KEY(uid, mxf_mastering_display_prefix)) {
1409 if (!descriptor->mastering) {
1410 descriptor->mastering = av_mastering_display_metadata_alloc();
1411 if (!descriptor->mastering)
1412 return AVERROR(ENOMEM);
1413 }
1414 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[0])) {
1415 for (int i = 0; i < 3; i++) {
1416 /* Order: large x, large y, other (i.e. RGB) */
1417 descriptor->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1418 descriptor->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1419 }
1420 /* Check we have seen mxf_mastering_display_white_point_chromaticity */
1421 if (descriptor->mastering->white_point[0].den != 0)
1422 descriptor->mastering->has_primaries = 1;
1423 }
1424 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[1])) {
1425 descriptor->mastering->white_point[0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1426 descriptor->mastering->white_point[1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1427 /* Check we have seen mxf_mastering_display_primaries */
1428 if (descriptor->mastering->display_primaries[0][0].den != 0)
1429 descriptor->mastering->has_primaries = 1;
1430 }
1431 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[2])) {
1432 descriptor->mastering->max_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1433 /* Check we have seen mxf_mastering_display_minimum_luminance */
1434 if (descriptor->mastering->min_luminance.den != 0)
1435 descriptor->mastering->has_luminance = 1;
1436 }
1437 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[3])) {
1438 descriptor->mastering->min_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1439 /* Check we have seen mxf_mastering_display_maximum_luminance */
1440 if (descriptor->mastering->max_luminance.den != 0)
1441 descriptor->mastering->has_luminance = 1;
1442 }
1443 }
1444 if (IS_KLV_KEY(uid, mxf_apple_coll_prefix)) {
1445 if (!descriptor->coll) {
1446 descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1447 if (!descriptor->coll)
1448 return AVERROR(ENOMEM);
1449 }
1450 if (IS_KLV_KEY(uid, mxf_apple_coll_max_cll)) {
1451 descriptor->coll->MaxCLL = avio_rb16(pb);
1452 }
1453 if (IS_KLV_KEY(uid, mxf_apple_coll_max_fall)) {
1454 descriptor->coll->MaxFALL = avio_rb16(pb);
1455 }
1456 }
1457
1458 if (IS_KLV_KEY(uid, mxf_sub_descriptor))
1459 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs, &descriptor->sub_descriptors_count);
1460
1461 break;
1462 }
1463 return 0;
1464 }
1465
mxf_read_mca_sub_descriptor(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1466 static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1467 {
1468 MXFMCASubDescriptor *mca_sub_descriptor = arg;
1469
1470 if (IS_KLV_KEY(uid, mxf_mca_label_dictionary_id))
1471 avio_read(pb, mca_sub_descriptor->mca_label_dictionary_id, 16);
1472
1473 if (IS_KLV_KEY(uid, mxf_mca_link_id))
1474 avio_read(pb, mca_sub_descriptor->mca_link_id, 16);
1475
1476 if (IS_KLV_KEY(uid, mxf_soundfield_group_link_id))
1477 avio_read(pb, mca_sub_descriptor->soundfield_group_link_id, 16);
1478
1479 if (IS_KLV_KEY(uid, mxf_group_of_soundfield_groups_link_id))
1480 return mxf_read_strong_ref_array(pb, &mca_sub_descriptor->group_of_soundfield_groups_link_id_refs, &mca_sub_descriptor->group_of_soundfield_groups_link_id_count);
1481
1482 if (IS_KLV_KEY(uid, mxf_mca_channel_id))
1483 mca_sub_descriptor->mca_channel_id = avio_rb32(pb);
1484
1485 if (IS_KLV_KEY(uid, mxf_mca_rfc5646_spoken_language))
1486 return mxf_read_us_ascii_string(pb, size, &mca_sub_descriptor->language);
1487
1488 return 0;
1489 }
1490
mxf_read_indirect_value(void * arg,AVIOContext * pb,int size)1491 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1492 {
1493 MXFTaggedValue *tagged_value = arg;
1494 uint8_t key[17];
1495
1496 if (size <= 17)
1497 return 0;
1498
1499 avio_read(pb, key, 17);
1500 /* TODO: handle other types of of indirect values */
1501 if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1502 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1503 } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1504 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1505 }
1506 return 0;
1507 }
1508
mxf_read_tagged_value(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)1509 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1510 {
1511 MXFTaggedValue *tagged_value = arg;
1512 switch (tag){
1513 case 0x5001:
1514 return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1515 case 0x5003:
1516 return mxf_read_indirect_value(tagged_value, pb, size);
1517 }
1518 return 0;
1519 }
1520
1521 /*
1522 * Match an uid independently of the version byte and up to len common bytes
1523 * Returns: boolean
1524 */
mxf_match_uid(const UID key,const UID uid,int len)1525 static int mxf_match_uid(const UID key, const UID uid, int len)
1526 {
1527 int i;
1528 for (i = 0; i < len; i++) {
1529 if (i != 7 && key[i] != uid[i])
1530 return 0;
1531 }
1532 return 1;
1533 }
1534
mxf_get_codec_ul(const MXFCodecUL * uls,UID * uid)1535 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1536 {
1537 while (uls->uid[0]) {
1538 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1539 break;
1540 uls++;
1541 }
1542 return uls;
1543 }
1544
mxf_resolve_strong_ref(MXFContext * mxf,UID * strong_ref,enum MXFMetadataSetType type)1545 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1546 {
1547 int i;
1548
1549 if (!strong_ref)
1550 return NULL;
1551 for (i = mxf->metadata_sets_count - 1; i >= 0; i--) {
1552 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1553 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1554 return mxf->metadata_sets[i];
1555 }
1556 }
1557 return NULL;
1558 }
1559
1560 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1561 // video essence container uls
1562 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14, J2KWrap },
1563 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264, NULL, 15 }, /* H.264 */
1564 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14, AV_CODEC_ID_DNXHD, NULL, 14 }, /* VC-3 */
1565 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1, NULL, 14 }, /* VC-1 */
1566 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1567 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14, AV_CODEC_ID_DIRAC, NULL, 14 }, /* VC-2 */
1568 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14, AV_CODEC_ID_CFHD, NULL, 14 }, /* VC-5 */
1569 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1570 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1571 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15, D10D11Wrap }, /* SMPTE D-10 mapping */
1572 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO, NULL, 15 }, /* DV 625 25mbps */
1573 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO, NULL, 15, RawVWrap }, /* uncompressed picture */
1574 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1575 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1576 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16, AV_CODEC_ID_HEVC, NULL, 15 }, /* Canon XF-HEVC */
1577 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1578 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1579 };
1580
1581 /* EC ULs for intra-only formats */
1582 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1583 { { 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 */
1584 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1585 };
1586
1587 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1588 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1589 { { 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 */
1590 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1591 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1592 };
1593
1594 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1595 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1596 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1597 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1598 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1599 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1600 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1601 };
1602
1603 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1604 // sound essence container uls
1605 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 14, RawAWrap }, /* BWF */
1606 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2, NULL, 15 }, /* MPEG-ES */
1607 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 13 }, /* D-10 Mapping 50Mbps PAL Extended Template */
1608 { { 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 */
1609 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1610 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1611 };
1612
1613 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1614 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_smpte_436M", 11 },
1615 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_vanc_smpte_436M", 11 },
1616 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1617 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1618 };
1619
1620 typedef struct MXFChannelOrderingUL {
1621 UID uid;
1622 uint64_t layout_mask;
1623 enum AVAudioServiceType service_type;
1624 } MXFChannelOrderingUL;
1625
1626 static const MXFChannelOrderingUL mxf_channel_ordering[] = {
1627 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x01,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left
1628 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x02,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right
1629 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x03,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center
1630 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x04,0x00,0x00,0x00,0x00 }, AV_CH_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Low Frequency Effects
1631 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x05,0x00,0x00,0x00,0x00 }, AV_CH_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround
1632 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x06,0x00,0x00,0x00,0x00 }, AV_CH_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround
1633 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x07,0x00,0x00,0x00,0x00 }, AV_CH_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround
1634 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x08,0x00,0x00,0x00,0x00 }, AV_CH_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround
1635 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x09,0x00,0x00,0x00,0x00 }, AV_CH_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround
1636 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0a,0x00,0x00,0x00,0x00 }, AV_CH_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround
1637 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0b,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_LEFT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Center
1638 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0c,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_RIGHT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Center
1639 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0d,0x00,0x00,0x00,0x00 }, AV_CH_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Surround
1640 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0e,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, // Hearing impaired audio channel
1641 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0f,0x00,0x00,0x00,0x00 }, AV_CH_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED }, // Visually impaired narrative audio channel
1642 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x03,0x00,0x00,0x00 }, AV_CH_STEREO_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Total
1643 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x04,0x00,0x00,0x00 }, AV_CH_STEREO_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Total
1644 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x01,0x00,0x00 }, AV_CH_TOP_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Height
1645 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x02,0x00,0x00 }, AV_CH_TOP_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Height
1646 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x03,0x00,0x00 }, AV_CH_TOP_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Height
1647 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x04,0x00,0x00 }, AV_CH_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround Height
1648 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x05,0x00,0x00 }, AV_CH_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround Height
1649 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x06,0x00,0x00 }, AV_CH_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround Height
1650 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x07,0x00,0x00 }, AV_CH_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround Height
1651 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x08,0x00,0x00 }, AV_CH_TOP_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround Height
1652 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x09,0x00,0x00 }, AV_CH_TOP_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround Height
1653 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0a,0x00,0x00 }, AV_CH_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Top Surround
1654 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0b,0x00,0x00 }, AV_CH_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Top Surround
1655 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0c,0x00,0x00 }, AV_CH_TOP_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Top Surround
1656 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0d,0x00,0x00 }, AV_CH_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Front Subwoofer
1657 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0e,0x00,0x00 }, AV_CH_LOW_FREQUENCY_2, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Front Subwoofer
1658 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0f,0x00,0x00 }, AV_CH_TOP_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear Height
1659 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x10,0x00,0x00 }, AV_CH_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear
1660 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x11,0x00,0x00 }, AV_CH_BOTTOM_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Below
1661 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x12,0x00,0x00 }, AV_CH_BOTTOM_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Below
1662 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x13,0x00,0x00 }, AV_CH_BOTTOM_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Below
1663 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_AUDIO_SERVICE_TYPE_NB },
1664 };
1665
mxf_get_wrapping_kind(UID * essence_container_ul)1666 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1667 {
1668 int val;
1669 const MXFCodecUL *codec_ul;
1670
1671 codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1672 if (!codec_ul->uid[0])
1673 codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1674 if (!codec_ul->uid[0])
1675 codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1676 if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1677 return UnknownWrapped;
1678
1679 val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1680 switch (codec_ul->wrapping_indicator_type) {
1681 case RawVWrap:
1682 val = val % 4;
1683 break;
1684 case RawAWrap:
1685 if (val == 0x03 || val == 0x04)
1686 val -= 0x02;
1687 break;
1688 case D10D11Wrap:
1689 if (val == 0x02)
1690 val = 0x01;
1691 break;
1692 case J2KWrap:
1693 if (val != 0x02)
1694 val = 0x01;
1695 break;
1696 }
1697 if (val == 0x01)
1698 return FrameWrapped;
1699 if (val == 0x02)
1700 return ClipWrapped;
1701 return UnknownWrapped;
1702 }
1703
mxf_get_sorted_table_segments(MXFContext * mxf,int * nb_sorted_segments,MXFIndexTableSegment *** sorted_segments)1704 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1705 {
1706 int i, j, nb_segments = 0;
1707 MXFIndexTableSegment **unsorted_segments;
1708 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1709
1710 /* count number of segments, allocate arrays and copy unsorted segments */
1711 for (i = 0; i < mxf->metadata_sets_count; i++)
1712 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1713 nb_segments++;
1714
1715 if (!nb_segments)
1716 return AVERROR_INVALIDDATA;
1717
1718 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1719 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1720 av_freep(sorted_segments);
1721 av_free(unsorted_segments);
1722 return AVERROR(ENOMEM);
1723 }
1724
1725 for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1726 if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1727 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1728 if (s->edit_unit_byte_count || s->nb_index_entries)
1729 unsorted_segments[nb_segments++] = s;
1730 else
1731 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1732 s->index_sid, s->index_start_position);
1733 }
1734 }
1735
1736 if (!nb_segments) {
1737 av_freep(sorted_segments);
1738 av_free(unsorted_segments);
1739 return AVERROR_INVALIDDATA;
1740 }
1741
1742 *nb_sorted_segments = 0;
1743
1744 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1745 for (i = 0; i < nb_segments; i++) {
1746 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1747 uint64_t best_index_duration = 0;
1748
1749 for (j = 0; j < nb_segments; j++) {
1750 MXFIndexTableSegment *s = unsorted_segments[j];
1751
1752 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1753 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1754 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1755 */
1756 if ((i == 0 ||
1757 s->body_sid > last_body_sid ||
1758 s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1759 s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1760 (best == -1 ||
1761 s->body_sid < best_body_sid ||
1762 s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1763 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1764 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1765 best = j;
1766 best_body_sid = s->body_sid;
1767 best_index_sid = s->index_sid;
1768 best_index_start = s->index_start_position;
1769 best_index_duration = s->index_duration;
1770 }
1771 }
1772
1773 /* no suitable entry found -> we're done */
1774 if (best == -1)
1775 break;
1776
1777 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1778 last_body_sid = best_body_sid;
1779 last_index_sid = best_index_sid;
1780 last_index_start = best_index_start;
1781 }
1782
1783 av_free(unsorted_segments);
1784
1785 return 0;
1786 }
1787
1788 /**
1789 * Computes the absolute file offset of the given essence container offset
1790 */
mxf_absolute_bodysid_offset(MXFContext * mxf,int body_sid,int64_t offset,int64_t * offset_out,MXFPartition ** partition_out)1791 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1792 {
1793 MXFPartition *last_p = NULL;
1794 int a, b, m, m0;
1795
1796 if (offset < 0)
1797 return AVERROR(EINVAL);
1798
1799 a = -1;
1800 b = mxf->partitions_count;
1801
1802 while (b - a > 1) {
1803 m0 = m = (a + b) >> 1;
1804
1805 while (m < b && mxf->partitions[m].body_sid != body_sid)
1806 m++;
1807
1808 if (m < b && mxf->partitions[m].body_offset <= offset)
1809 a = m;
1810 else
1811 b = m0;
1812 }
1813
1814 if (a >= 0)
1815 last_p = &mxf->partitions[a];
1816
1817 if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1818 *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1819 if (partition_out)
1820 *partition_out = last_p;
1821 return 0;
1822 }
1823
1824 av_log(mxf->fc, AV_LOG_ERROR,
1825 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1826 offset, body_sid);
1827
1828 return AVERROR_INVALIDDATA;
1829 }
1830
1831 /**
1832 * Returns the end position of the essence container with given BodySID, or zero if unknown
1833 */
mxf_essence_container_end(MXFContext * mxf,int body_sid)1834 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1835 {
1836 for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1837 MXFPartition *p = &mxf->partitions[x];
1838
1839 if (p->body_sid != body_sid)
1840 continue;
1841
1842 if (!p->essence_length)
1843 return 0;
1844
1845 return p->essence_offset + p->essence_length;
1846 }
1847
1848 return 0;
1849 }
1850
1851 /* EditUnit -> absolute offset */
mxf_edit_unit_absolute_offset(MXFContext * mxf,MXFIndexTable * index_table,int64_t edit_unit,AVRational edit_rate,int64_t * edit_unit_out,int64_t * offset_out,MXFPartition ** partition_out,int nag)1852 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
1853 {
1854 int i;
1855 int64_t offset_temp = 0;
1856
1857 edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1858
1859 for (i = 0; i < index_table->nb_segments; i++) {
1860 MXFIndexTableSegment *s = index_table->segments[i];
1861
1862 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1863
1864 if (edit_unit < s->index_start_position + s->index_duration) {
1865 int64_t index = edit_unit - s->index_start_position;
1866
1867 if (s->edit_unit_byte_count)
1868 offset_temp += s->edit_unit_byte_count * index;
1869 else {
1870 if (s->nb_index_entries == 2 * s->index_duration + 1)
1871 index *= 2; /* Avid index */
1872
1873 if (index < 0 || index >= s->nb_index_entries) {
1874 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1875 index_table->index_sid, s->index_start_position);
1876 return AVERROR_INVALIDDATA;
1877 }
1878
1879 offset_temp = s->stream_offset_entries[index];
1880 }
1881
1882 if (edit_unit_out)
1883 *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1884
1885 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1886 } else {
1887 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1888 offset_temp += s->edit_unit_byte_count * s->index_duration;
1889 }
1890 }
1891
1892 if (nag)
1893 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);
1894
1895 return AVERROR_INVALIDDATA;
1896 }
1897
mxf_compute_ptses_fake_index(MXFContext * mxf,MXFIndexTable * index_table)1898 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1899 {
1900 int i, j, x;
1901 int8_t max_temporal_offset = -128;
1902 uint8_t *flags;
1903
1904 /* first compute how many entries we have */
1905 for (i = 0; i < index_table->nb_segments; i++) {
1906 MXFIndexTableSegment *s = index_table->segments[i];
1907
1908 if (!s->nb_index_entries) {
1909 index_table->nb_ptses = 0;
1910 return 0; /* no TemporalOffsets */
1911 }
1912
1913 if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1914 index_table->nb_ptses = 0;
1915 av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1916 return 0;
1917 }
1918
1919 index_table->nb_ptses += s->index_duration;
1920 }
1921
1922 /* paranoid check */
1923 if (index_table->nb_ptses <= 0)
1924 return 0;
1925
1926 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1927 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1928 !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1929 !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1930 av_freep(&index_table->ptses);
1931 av_freep(&index_table->fake_index);
1932 av_freep(&index_table->offsets);
1933 return AVERROR(ENOMEM);
1934 }
1935
1936 /* we may have a few bad TemporalOffsets
1937 * make sure the corresponding PTSes don't have the bogus value 0 */
1938 for (x = 0; x < index_table->nb_ptses; x++)
1939 index_table->ptses[x] = AV_NOPTS_VALUE;
1940
1941 /**
1942 * We have this:
1943 *
1944 * x TemporalOffset
1945 * 0: 0
1946 * 1: 1
1947 * 2: 1
1948 * 3: -2
1949 * 4: 1
1950 * 5: 1
1951 * 6: -2
1952 *
1953 * We want to transform it into this:
1954 *
1955 * x DTS PTS
1956 * 0: -1 0
1957 * 1: 0 3
1958 * 2: 1 1
1959 * 3: 2 2
1960 * 4: 3 6
1961 * 5: 4 4
1962 * 6: 5 5
1963 *
1964 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1965 * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
1966 * The latter makes DTS <= PTS.
1967 */
1968 for (i = x = 0; i < index_table->nb_segments; i++) {
1969 MXFIndexTableSegment *s = index_table->segments[i];
1970 int index_delta = 1;
1971 int n = s->nb_index_entries;
1972
1973 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1974 index_delta = 2; /* Avid index */
1975 /* ignore the last entry - it's the size of the essence container */
1976 n--;
1977 }
1978
1979 for (j = 0; j < n; j += index_delta, x++) {
1980 int offset = s->temporal_offset_entries[j] / index_delta;
1981 int index = x + offset;
1982
1983 if (x >= index_table->nb_ptses) {
1984 av_log(mxf->fc, AV_LOG_ERROR,
1985 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1986 s->nb_index_entries, s->index_duration);
1987 break;
1988 }
1989
1990 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1991
1992 if (index < 0 || index >= index_table->nb_ptses) {
1993 av_log(mxf->fc, AV_LOG_ERROR,
1994 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1995 x, offset, index);
1996 continue;
1997 }
1998
1999 index_table->offsets[x] = offset;
2000 index_table->ptses[index] = x;
2001 max_temporal_offset = FFMAX(max_temporal_offset, offset);
2002 }
2003 }
2004
2005 /* calculate the fake index table in display order */
2006 for (x = 0; x < index_table->nb_ptses; x++) {
2007 index_table->fake_index[x].timestamp = x;
2008 if (index_table->ptses[x] != AV_NOPTS_VALUE)
2009 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2010 }
2011 av_freep(&flags);
2012
2013 index_table->first_dts = -max_temporal_offset;
2014
2015 return 0;
2016 }
2017
2018 /**
2019 * Sorts and collects index table segments into index tables.
2020 * Also computes PTSes if possible.
2021 */
mxf_compute_index_tables(MXFContext * mxf)2022 static int mxf_compute_index_tables(MXFContext *mxf)
2023 {
2024 int i, j, k, ret, nb_sorted_segments;
2025 MXFIndexTableSegment **sorted_segments = NULL;
2026
2027 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2028 nb_sorted_segments <= 0) {
2029 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2030 return 0;
2031 }
2032
2033 /* sanity check and count unique BodySIDs/IndexSIDs */
2034 for (i = 0; i < nb_sorted_segments; i++) {
2035 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2036 mxf->nb_index_tables++;
2037 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2038 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2039 ret = AVERROR_INVALIDDATA;
2040 goto finish_decoding_index;
2041 }
2042 }
2043
2044 mxf->index_tables = av_calloc(mxf->nb_index_tables,
2045 sizeof(*mxf->index_tables));
2046 if (!mxf->index_tables) {
2047 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2048 ret = AVERROR(ENOMEM);
2049 goto finish_decoding_index;
2050 }
2051
2052 /* distribute sorted segments to index tables */
2053 for (i = j = 0; i < nb_sorted_segments; i++) {
2054 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2055 /* next IndexSID */
2056 j++;
2057 }
2058
2059 mxf->index_tables[j].nb_segments++;
2060 }
2061
2062 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2063 MXFIndexTable *t = &mxf->index_tables[j];
2064 MXFTrack *mxf_track = NULL;
2065
2066 t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2067 if (!t->segments) {
2068 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2069 " pointer array\n");
2070 ret = AVERROR(ENOMEM);
2071 goto finish_decoding_index;
2072 }
2073
2074 if (sorted_segments[i]->index_start_position)
2075 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2076 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2077
2078 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2079 t->index_sid = sorted_segments[i]->index_sid;
2080 t->body_sid = sorted_segments[i]->body_sid;
2081
2082 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2083 goto finish_decoding_index;
2084
2085 for (k = 0; k < mxf->fc->nb_streams; k++) {
2086 MXFTrack *track = mxf->fc->streams[k]->priv_data;
2087 if (track && track->index_sid == t->index_sid) {
2088 mxf_track = track;
2089 break;
2090 }
2091 }
2092
2093 /* fix zero IndexDurations */
2094 for (k = 0; k < t->nb_segments; k++) {
2095 if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2096 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2097 t->index_sid, k);
2098 if (mxf_track)
2099 t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2100 }
2101
2102 if (t->segments[k]->index_duration)
2103 continue;
2104
2105 if (t->nb_segments > 1)
2106 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2107 t->index_sid, k);
2108
2109 if (!mxf_track) {
2110 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2111 break;
2112 }
2113
2114 /* assume the first stream's duration is reasonable
2115 * leave index_duration = 0 on further segments in case we have any (unlikely)
2116 */
2117 t->segments[k]->index_duration = mxf_track->original_duration;
2118 break;
2119 }
2120 }
2121
2122 ret = 0;
2123 finish_decoding_index:
2124 av_free(sorted_segments);
2125 return ret;
2126 }
2127
mxf_is_intra_only(MXFDescriptor * descriptor)2128 static int mxf_is_intra_only(MXFDescriptor *descriptor)
2129 {
2130 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
2131 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
2132 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
2133 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
2134 }
2135
mxf_umid_to_str(const UID ul,const UID uid,char str[2+sizeof (UID)* 4+1])2136 static void mxf_umid_to_str(const UID ul, const UID uid,
2137 char str[2 + sizeof(UID) * 4 + 1])
2138 {
2139 snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2140 ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2141 ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2142 }
2143
mxf_version_to_str(uint16_t major,uint16_t minor,uint16_t tertiary,uint16_t patch,uint16_t release,char ** str)2144 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2145 uint16_t patch, uint16_t release, char **str)
2146 {
2147 *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2148 if (!*str)
2149 return AVERROR(ENOMEM);
2150 return 0;
2151 }
2152
mxf_add_umid_metadata(AVDictionary ** pm,const char * key,MXFPackage * package)2153 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2154 {
2155 char str[2 + 4 * sizeof(UID) + 1];
2156 if (!package)
2157 return 0;
2158 mxf_umid_to_str(package->package_ul, package->package_uid, str);
2159 av_dict_set(pm, key, str, 0);
2160 return 0;
2161 }
2162
mxf_add_timecode_metadata(AVDictionary ** pm,const char * key,AVTimecode * tc)2163 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2164 {
2165 char buf[AV_TIMECODE_STR_SIZE];
2166 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2167
2168 return 0;
2169 }
2170
mxf_resolve_timecode_component(MXFContext * mxf,UID * strong_ref)2171 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2172 {
2173 MXFStructuralComponent *component = NULL;
2174 MXFPulldownComponent *pulldown = NULL;
2175
2176 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2177 if (!component)
2178 return NULL;
2179
2180 switch (component->meta.type) {
2181 case TimecodeComponent:
2182 return (MXFTimecodeComponent*)component;
2183 case PulldownComponent: /* timcode component may be located on a pulldown component */
2184 pulldown = (MXFPulldownComponent*)component;
2185 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2186 default:
2187 break;
2188 }
2189 return NULL;
2190 }
2191
mxf_resolve_source_package(MXFContext * mxf,UID package_ul,UID package_uid)2192 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2193 {
2194 MXFPackage *package = NULL;
2195 int i;
2196
2197 for (i = 0; i < mxf->packages_count; i++) {
2198 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2199 if (!package)
2200 continue;
2201
2202 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2203 return package;
2204 }
2205 return NULL;
2206 }
2207
mxf_resolve_multidescriptor(MXFContext * mxf,MXFDescriptor * descriptor,int track_id)2208 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
2209 {
2210 MXFDescriptor *file_descriptor = NULL;
2211 int i;
2212
2213 if (!descriptor)
2214 return NULL;
2215
2216 if (descriptor->meta.type == MultipleDescriptor) {
2217 for (i = 0; i < descriptor->file_descriptors_count; i++) {
2218 file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2219
2220 if (!file_descriptor) {
2221 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2222 continue;
2223 }
2224 if (file_descriptor->linked_track_id == track_id) {
2225 return file_descriptor;
2226 }
2227 }
2228 } else if (descriptor->meta.type == Descriptor)
2229 return descriptor;
2230
2231 return NULL;
2232 }
2233
mxf_resolve_essence_group_choice(MXFContext * mxf,MXFEssenceGroup * essence_group)2234 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
2235 {
2236 MXFStructuralComponent *component = NULL;
2237 MXFPackage *package = NULL;
2238 MXFDescriptor *descriptor = NULL;
2239 int i;
2240
2241 if (!essence_group || !essence_group->structural_components_count)
2242 return NULL;
2243
2244 /* essence groups contains multiple representations of the same media,
2245 this return the first components with a valid Descriptor typically index 0 */
2246 for (i =0; i < essence_group->structural_components_count; i++){
2247 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2248 if (!component)
2249 continue;
2250
2251 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2252 continue;
2253
2254 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2255 if (descriptor)
2256 return component;
2257 }
2258 return NULL;
2259 }
2260
mxf_resolve_sourceclip(MXFContext * mxf,UID * strong_ref)2261 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2262 {
2263 MXFStructuralComponent *component = NULL;
2264
2265 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2266 if (!component)
2267 return NULL;
2268 switch (component->meta.type) {
2269 case SourceClip:
2270 return component;
2271 case EssenceGroup:
2272 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2273 default:
2274 break;
2275 }
2276 return NULL;
2277 }
2278
mxf_parse_package_comments(MXFContext * mxf,AVDictionary ** pm,MXFPackage * package)2279 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2280 {
2281 MXFTaggedValue *tag;
2282 int i;
2283 char *key = NULL;
2284
2285 for (i = 0; i < package->comment_count; i++) {
2286 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2287 if (!tag || !tag->name || !tag->value)
2288 continue;
2289
2290 key = av_asprintf("comment_%s", tag->name);
2291 if (!key)
2292 return AVERROR(ENOMEM);
2293
2294 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2295 }
2296 return 0;
2297 }
2298
mxf_parse_physical_source_package(MXFContext * mxf,MXFTrack * source_track,AVStream * st)2299 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2300 {
2301 MXFPackage *physical_package = NULL;
2302 MXFTrack *physical_track = NULL;
2303 MXFStructuralComponent *sourceclip = NULL;
2304 MXFTimecodeComponent *mxf_tc = NULL;
2305 int i, j, k;
2306 AVTimecode tc;
2307 int flags;
2308 int64_t start_position;
2309
2310 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2311 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2312 if (!sourceclip)
2313 continue;
2314
2315 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2316 break;
2317
2318 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2319
2320 /* the name of physical source package is name of the reel or tape */
2321 if (physical_package->name && physical_package->name[0])
2322 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2323
2324 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2325 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2326 */
2327 for (j = 0; j < physical_package->tracks_count; j++) {
2328 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2329 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2330 continue;
2331 }
2332
2333 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2334 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2335 continue;
2336 }
2337
2338 if (physical_track->edit_rate.num <= 0 ||
2339 physical_track->edit_rate.den <= 0) {
2340 av_log(mxf->fc, AV_LOG_WARNING,
2341 "Invalid edit rate (%d/%d) found on structural"
2342 " component #%d, defaulting to 25/1\n",
2343 physical_track->edit_rate.num,
2344 physical_track->edit_rate.den, i);
2345 physical_track->edit_rate = (AVRational){25, 1};
2346 }
2347
2348 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2349 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2350 continue;
2351
2352 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2353 /* scale sourceclip start_position to match physical track edit rate */
2354 start_position = av_rescale_q(sourceclip->start_position,
2355 physical_track->edit_rate,
2356 source_track->edit_rate);
2357
2358 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2359 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2360 return 0;
2361 }
2362 }
2363 }
2364 }
2365
2366 return 0;
2367 }
2368
mxf_add_metadata_stream(MXFContext * mxf,MXFTrack * track)2369 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2370 {
2371 MXFStructuralComponent *component = NULL;
2372 const MXFCodecUL *codec_ul = NULL;
2373 MXFPackage tmp_package;
2374 AVStream *st;
2375 int j;
2376
2377 for (j = 0; j < track->sequence->structural_components_count; j++) {
2378 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2379 if (!component)
2380 continue;
2381 break;
2382 }
2383 if (!component)
2384 return 0;
2385
2386 st = avformat_new_stream(mxf->fc, NULL);
2387 if (!st) {
2388 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2389 return AVERROR(ENOMEM);
2390 }
2391
2392 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2393 st->codecpar->codec_id = AV_CODEC_ID_NONE;
2394 st->id = track->track_id;
2395
2396 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2397 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2398 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2399 if (track->name && track->name[0])
2400 av_dict_set(&st->metadata, "track_name", track->name, 0);
2401
2402 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2403 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2404 return 0;
2405 }
2406
mxf_get_color_range(MXFContext * mxf,MXFDescriptor * descriptor)2407 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2408 {
2409 if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2410 /* CDCI range metadata */
2411 if (!descriptor->component_depth)
2412 return AVCOL_RANGE_UNSPECIFIED;
2413 if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2414 descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2415 (descriptor->color_range == (1<<descriptor->component_depth) ||
2416 descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2417 return AVCOL_RANGE_JPEG;
2418 if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2419 descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2420 descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2421 descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2422 return AVCOL_RANGE_MPEG;
2423 avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2424 descriptor->color_range, descriptor->black_ref_level,
2425 descriptor->white_ref_level, descriptor->component_depth);
2426 }
2427
2428 return AVCOL_RANGE_UNSPECIFIED;
2429 }
2430
is_pcm(enum AVCodecID codec_id)2431 static int is_pcm(enum AVCodecID codec_id)
2432 {
2433 /* we only care about "normal" PCM codecs until we get samples */
2434 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2435 }
2436
set_language(AVFormatContext * s,const char * rfc5646,AVDictionary ** met)2437 static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2438 {
2439 // language abbr should contain at least 2 chars
2440 if (rfc5646 && strlen(rfc5646) > 1) {
2441 char primary_tag[4] =
2442 {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2443
2444 const char *iso6392 = ff_convert_lang_to(primary_tag,
2445 AV_LANG_ISO639_2_BIBL);
2446 if (iso6392)
2447 return(av_dict_set(met, "language", iso6392, 0));
2448 }
2449 return 0;
2450 }
2451
find_mca_link_id(MXFContext * mxf,enum MXFMetadataSetType type,UID * mca_link_id)2452 static MXFMCASubDescriptor *find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
2453 {
2454 for (int k = 0; k < mxf->metadata_sets_count; k++) {
2455 MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mxf->metadata_sets[k];
2456 if (group->meta.type == type && !memcmp(&group->mca_link_id, mca_link_id, 16))
2457 return group;
2458 }
2459 return NULL;
2460 }
2461
parse_mca_labels(MXFContext * mxf,MXFTrack * source_track,MXFDescriptor * descriptor,AVStream * st)2462 static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2463 {
2464 uint64_t routing[FF_SANE_NB_CHANNELS] = {0};
2465 char *language = NULL;
2466 int ambigous_language = 0;
2467 enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2468 int ambigous_service_type = 0;
2469 int has_channel_label = 0;
2470
2471 for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2472 char *channel_language;
2473
2474 MXFMCASubDescriptor *label = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], AudioChannelLabelSubDescriptor);
2475 if (label == NULL)
2476 continue;
2477
2478 has_channel_label = 1;
2479 for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2480 if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2481 int target_channel = label->mca_channel_id;
2482 if (target_channel == 0 && descriptor->channels == 1)
2483 target_channel = 1;
2484 if (target_channel <= 0 || target_channel > descriptor->channels) {
2485 av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2486 return AVERROR_INVALIDDATA;
2487 }
2488 routing[target_channel - 1] = channel_ordering->layout_mask;
2489 if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2490 service_type = channel_ordering->service_type;
2491 else if (service_type != channel_ordering->service_type)
2492 ambigous_service_type = 1;
2493 break;
2494 }
2495 }
2496
2497 channel_language = label->language;
2498 if (!channel_language) {
2499 MXFMCASubDescriptor *group = find_mca_link_id(mxf, SoundfieldGroupLabelSubDescriptor, &label->soundfield_group_link_id);
2500 if (group) {
2501 channel_language = group->language;
2502 if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2503 MXFMCASubDescriptor *supergroup = find_mca_link_id(mxf, GroupOfSoundfieldGroupsLabelSubDescriptor,
2504 group->group_of_soundfield_groups_link_id_refs);
2505 if (supergroup)
2506 channel_language = supergroup->language;
2507 }
2508 }
2509 }
2510 if (channel_language) {
2511 if (language && strcmp(language, channel_language))
2512 ambigous_language = 1;
2513 else
2514 language = channel_language;
2515 }
2516 }
2517
2518 if (language && !ambigous_language) {
2519 int ret = set_language(mxf->fc, language, &st->metadata);
2520 if (ret < 0)
2521 return ret;
2522 }
2523
2524 if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2525 enum AVAudioServiceType *ast;
2526 uint8_t* side_data = av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE, sizeof(*ast));
2527 if (!side_data)
2528 return AVERROR(ENOMEM);
2529 ast = (enum AVAudioServiceType*)side_data;
2530 *ast = service_type;
2531 }
2532
2533 if (has_channel_label) {
2534 uint64_t channel_layout = 0;
2535 int ret;
2536
2537 for (int i = 0; i < descriptor->channels; i++) {
2538 if (!routing[i]) {
2539 av_log(mxf->fc, AV_LOG_WARNING, "Designation of audio channel %d in stream #%d is unknown or unsupported, "
2540 "falling back to unknown channel layout\n", st->index, i);
2541 return 0;
2542 }
2543 if (channel_layout & routing[i]) {
2544 char buf[32];
2545 av_channel_name(buf, sizeof(buf), routing[i]);
2546 av_log(mxf->fc, AV_LOG_WARNING, "%s audio channel is used multiple times in stream #%d, "
2547 "falling back to unknown channel layout\n",
2548 buf, st->index);
2549 return 0;
2550 }
2551 if (routing[i] < channel_layout) {
2552 av_log(mxf->fc, AV_LOG_WARNING, "stream #%d is not in in native channel order, "
2553 "falling back to unknown channel layout\n", st->index);
2554 return 0;
2555 }
2556 channel_layout |= routing[i];
2557 }
2558
2559 av_assert0(descriptor->channels == av_popcount64(channel_layout));
2560
2561 ret = av_channel_layout_from_mask(&st->codecpar->ch_layout, channel_layout);
2562 if (ret < 0)
2563 return ret;
2564 }
2565
2566 return 0;
2567 }
2568
mxf_parse_structural_metadata(MXFContext * mxf)2569 static int mxf_parse_structural_metadata(MXFContext *mxf)
2570 {
2571 MXFPackage *material_package = NULL;
2572 int i, j, k, ret;
2573
2574 av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2575 /* TODO: handle multiple material packages (OP3x) */
2576 for (i = 0; i < mxf->packages_count; i++) {
2577 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2578 if (material_package) break;
2579 }
2580 if (!material_package) {
2581 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2582 return AVERROR_INVALIDDATA;
2583 }
2584
2585 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2586 if (material_package->name && material_package->name[0])
2587 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2588 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2589
2590 for (i = 0; i < material_package->tracks_count; i++) {
2591 MXFPackage *source_package = NULL;
2592 MXFTrack *material_track = NULL;
2593 MXFTrack *source_track = NULL;
2594 MXFTrack *temp_track = NULL;
2595 MXFDescriptor *descriptor = NULL;
2596 MXFStructuralComponent *component = NULL;
2597 MXFTimecodeComponent *mxf_tc = NULL;
2598 UID *essence_container_ul = NULL;
2599 const MXFCodecUL *codec_ul = NULL;
2600 const MXFCodecUL *container_ul = NULL;
2601 const MXFCodecUL *pix_fmt_ul = NULL;
2602 AVStream *st;
2603 FFStream *sti;
2604 AVTimecode tc;
2605 int flags;
2606
2607 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2608 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2609 continue;
2610 }
2611
2612 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2613 mxf_tc = (MXFTimecodeComponent*)component;
2614 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2615 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2616 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2617 }
2618 }
2619
2620 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2621 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2622 continue;
2623 }
2624
2625 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2626 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2627 if (!component)
2628 continue;
2629
2630 mxf_tc = (MXFTimecodeComponent*)component;
2631 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2632 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2633 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2634 break;
2635 }
2636 }
2637
2638 /* TODO: handle multiple source clips, only finds first valid source clip */
2639 if(material_track->sequence->structural_components_count > 1)
2640 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2641 material_track->track_id, material_track->sequence->structural_components_count);
2642
2643 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2644 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2645 if (!component)
2646 continue;
2647
2648 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2649 if (!source_package) {
2650 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2651 continue;
2652 }
2653 for (k = 0; k < source_package->tracks_count; k++) {
2654 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2655 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2656 ret = AVERROR_INVALIDDATA;
2657 goto fail_and_free;
2658 }
2659 if (temp_track->track_id == component->source_track_id) {
2660 source_track = temp_track;
2661 break;
2662 }
2663 }
2664 if (!source_track) {
2665 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2666 break;
2667 }
2668
2669 for (k = 0; k < mxf->essence_container_data_count; k++) {
2670 MXFEssenceContainerData *essence_data;
2671
2672 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2673 av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2674 continue;
2675 }
2676 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2677 source_track->body_sid = essence_data->body_sid;
2678 source_track->index_sid = essence_data->index_sid;
2679 break;
2680 }
2681 }
2682
2683 if(source_track && component)
2684 break;
2685 }
2686 if (!source_track || !component || !source_package) {
2687 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2688 goto fail_and_free;
2689 continue;
2690 }
2691
2692 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2693 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2694 ret = AVERROR_INVALIDDATA;
2695 goto fail_and_free;
2696 }
2697
2698 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2699 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2700 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2701 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2702 continue;
2703 }
2704
2705 st = avformat_new_stream(mxf->fc, NULL);
2706 if (!st) {
2707 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2708 ret = AVERROR(ENOMEM);
2709 goto fail_and_free;
2710 }
2711 sti = ffstream(st);
2712 st->id = material_track->track_id;
2713 st->priv_data = source_track;
2714
2715 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2716 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2717
2718 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2719 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2720 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2721 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2722 else
2723 source_track->original_duration = st->duration = component->duration;
2724
2725 if (st->duration == -1)
2726 st->duration = AV_NOPTS_VALUE;
2727 st->start_time = component->start_position;
2728 if (material_track->edit_rate.num <= 0 ||
2729 material_track->edit_rate.den <= 0) {
2730 av_log(mxf->fc, AV_LOG_WARNING,
2731 "Invalid edit rate (%d/%d) found on stream #%d, "
2732 "defaulting to 25/1\n",
2733 material_track->edit_rate.num,
2734 material_track->edit_rate.den, st->index);
2735 material_track->edit_rate = (AVRational){25, 1};
2736 }
2737 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2738
2739 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2740 * the former is accessible via st->priv_data */
2741 source_track->edit_rate = material_track->edit_rate;
2742
2743 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2744 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2745 st->codecpar->codec_type = codec_ul->id;
2746
2747 if (!descriptor) {
2748 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2749 continue;
2750 }
2751 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2752 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2753 essence_container_ul = &descriptor->essence_container_ul;
2754 source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2755 if (source_track->wrapping == UnknownWrapped)
2756 av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2757 /* HACK: replacing the original key with mxf_encrypted_essence_container
2758 * is not allowed according to s429-6, try to find correct information anyway */
2759 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2760 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2761 for (k = 0; k < mxf->metadata_sets_count; k++) {
2762 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2763 if (metadata->type == CryptoContext) {
2764 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2765 break;
2766 }
2767 }
2768 }
2769
2770 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2771 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2772 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2773 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2774 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2775 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2776 }
2777
2778 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2779 avcodec_get_name(st->codecpar->codec_id));
2780 for (k = 0; k < 16; k++) {
2781 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2782 descriptor->essence_codec_ul[k]);
2783 if (!(k+1 & 19) || k == 5)
2784 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2785 }
2786 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2787
2788 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2789 if (source_package->name && source_package->name[0])
2790 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2791 if (material_track->name && material_track->name[0])
2792 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2793
2794 mxf_parse_physical_source_package(mxf, source_track, st);
2795
2796 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2797 source_track->intra_only = mxf_is_intra_only(descriptor);
2798 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2799 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2800 st->codecpar->codec_id = container_ul->id;
2801 st->codecpar->width = descriptor->width;
2802 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2803 switch (descriptor->frame_layout) {
2804 case FullFrame:
2805 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2806 break;
2807 case OneField:
2808 /* Every other line is stored and needs to be duplicated. */
2809 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2810 break; /* The correct thing to do here is fall through, but by breaking we might be
2811 able to decode some streams at half the vertical resolution, rather than not al all.
2812 It's also for compatibility with the old behavior. */
2813 case MixedFields:
2814 break;
2815 case SegmentedFrame:
2816 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2817 case SeparateFields:
2818 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2819 descriptor->video_line_map[0], descriptor->video_line_map[1],
2820 descriptor->field_dominance);
2821 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2822 /* Detect coded field order from VideoLineMap:
2823 * (even, even) => bottom field coded first
2824 * (even, odd) => top field coded first
2825 * (odd, even) => top field coded first
2826 * (odd, odd) => bottom field coded first
2827 */
2828 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2829 switch (descriptor->field_dominance) {
2830 case MXF_FIELD_DOMINANCE_DEFAULT:
2831 case MXF_FIELD_DOMINANCE_FF:
2832 st->codecpar->field_order = AV_FIELD_TT;
2833 break;
2834 case MXF_FIELD_DOMINANCE_FL:
2835 st->codecpar->field_order = AV_FIELD_TB;
2836 break;
2837 default:
2838 avpriv_request_sample(mxf->fc,
2839 "Field dominance %d support",
2840 descriptor->field_dominance);
2841 }
2842 } else {
2843 switch (descriptor->field_dominance) {
2844 case MXF_FIELD_DOMINANCE_DEFAULT:
2845 case MXF_FIELD_DOMINANCE_FF:
2846 st->codecpar->field_order = AV_FIELD_BB;
2847 break;
2848 case MXF_FIELD_DOMINANCE_FL:
2849 st->codecpar->field_order = AV_FIELD_BT;
2850 break;
2851 default:
2852 avpriv_request_sample(mxf->fc,
2853 "Field dominance %d support",
2854 descriptor->field_dominance);
2855 }
2856 }
2857 }
2858 /* Turn field height into frame height. */
2859 st->codecpar->height *= 2;
2860 break;
2861 default:
2862 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2863 }
2864
2865 if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2866 switch (descriptor->essence_codec_ul[14]) {
2867 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2868 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2869 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2870 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2871 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2872 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2873 }
2874 }
2875
2876 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2877 st->codecpar->format = descriptor->pix_fmt;
2878 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2879 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2880 &descriptor->essence_codec_ul);
2881 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2882 if (st->codecpar->format== AV_PIX_FMT_NONE) {
2883 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2884 &descriptor->essence_codec_ul)->id;
2885 if (!st->codecpar->codec_tag) {
2886 /* support files created before RP224v10 by defaulting to UYVY422
2887 if subsampling is 4:2:2 and component depth is 8-bit */
2888 if (descriptor->horiz_subsampling == 2 &&
2889 descriptor->vert_subsampling == 1 &&
2890 descriptor->component_depth == 8) {
2891 st->codecpar->format = AV_PIX_FMT_UYVY422;
2892 }
2893 }
2894 }
2895 }
2896 }
2897 sti->need_parsing = AVSTREAM_PARSE_HEADERS;
2898 if (material_track->sequence->origin) {
2899 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2900 }
2901 if (source_track->sequence->origin) {
2902 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2903 }
2904 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2905 sti->display_aspect_ratio = descriptor->aspect_ratio;
2906 st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2907 st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2908 st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2909 st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2910 if (descriptor->mastering) {
2911 ret = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2912 (uint8_t *)descriptor->mastering,
2913 sizeof(*descriptor->mastering));
2914 if (ret < 0)
2915 goto fail_and_free;
2916 descriptor->mastering = NULL;
2917 }
2918 if (descriptor->coll) {
2919 ret = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2920 (uint8_t *)descriptor->coll,
2921 descriptor->coll_size);
2922 if (ret < 0)
2923 goto fail_and_free;
2924 descriptor->coll = NULL;
2925 }
2926 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2927 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2928 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2929 if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
2930 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2931 st->codecpar->ch_layout.nb_channels = descriptor->channels;
2932
2933 if (descriptor->sample_rate.den > 0) {
2934 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2935 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2936 } else {
2937 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2938 "found for stream #%d, time base forced to 1/48000\n",
2939 descriptor->sample_rate.num, descriptor->sample_rate.den,
2940 st->index);
2941 avpriv_set_pts_info(st, 64, 1, 48000);
2942 }
2943
2944 /* if duration is set, rescale it from EditRate to SampleRate */
2945 if (st->duration != AV_NOPTS_VALUE)
2946 st->duration = av_rescale_q(st->duration,
2947 av_inv_q(material_track->edit_rate),
2948 st->time_base);
2949
2950 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2951 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2952 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2953 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2954 else if (descriptor->bits_per_sample == 32)
2955 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2956 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2957 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2958 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2959 else if (descriptor->bits_per_sample == 32)
2960 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2961 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2962 sti->need_parsing = AVSTREAM_PARSE_FULL;
2963 }
2964 st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2965
2966 if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
2967 av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
2968 return AVERROR_INVALIDDATA;
2969 }
2970
2971 ret = parse_mca_labels(mxf, source_track, descriptor, st);
2972 if (ret < 0)
2973 return ret;
2974 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2975 enum AVMediaType type;
2976 container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2977 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2978 st->codecpar->codec_id = container_ul->id;
2979 type = avcodec_get_type(st->codecpar->codec_id);
2980 if (type == AVMEDIA_TYPE_SUBTITLE)
2981 st->codecpar->codec_type = type;
2982 if (container_ul->desc)
2983 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2984 if (mxf->eia608_extract &&
2985 !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2986 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2987 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
2988 }
2989 }
2990 if (descriptor->extradata) {
2991 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2992 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2993 }
2994 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2995 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2996 &descriptor->essence_codec_ul)->id;
2997 if (coded_width)
2998 st->codecpar->width = coded_width;
2999 ret = ff_generate_avci_extradata(st);
3000 if (ret < 0)
3001 return ret;
3002 }
3003 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
3004 /* TODO: decode timestamps */
3005 sti->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
3006 }
3007 }
3008
3009 for (int i = 0; i < mxf->fc->nb_streams; i++) {
3010 MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
3011 if (track1 && track1->body_sid) {
3012 for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
3013 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
3014 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
3015 if (track1->wrapping == UnknownWrapped)
3016 track1->wrapping = track2->wrapping;
3017 else if (track2->wrapping == UnknownWrapped)
3018 track2->wrapping = track1->wrapping;
3019 else
3020 av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
3021 "with different wrapping\n", i, j, track1->body_sid);
3022 }
3023 }
3024 }
3025 }
3026
3027 ret = 0;
3028 fail_and_free:
3029 return ret;
3030 }
3031
mxf_timestamp_to_int64(uint64_t timestamp)3032 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
3033 {
3034 struct tm time = { 0 };
3035 int msecs;
3036 time.tm_year = (timestamp >> 48) - 1900;
3037 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
3038 time.tm_mday = (timestamp >> 32 & 0xFF);
3039 time.tm_hour = (timestamp >> 24 & 0xFF);
3040 time.tm_min = (timestamp >> 16 & 0xFF);
3041 time.tm_sec = (timestamp >> 8 & 0xFF);
3042 msecs = (timestamp & 0xFF) * 4;
3043
3044 /* Clip values for legacy reasons. Maybe we should return error instead? */
3045 time.tm_mon = av_clip(time.tm_mon, 0, 11);
3046 time.tm_mday = av_clip(time.tm_mday, 1, 31);
3047 time.tm_hour = av_clip(time.tm_hour, 0, 23);
3048 time.tm_min = av_clip(time.tm_min, 0, 59);
3049 time.tm_sec = av_clip(time.tm_sec, 0, 59);
3050 msecs = av_clip(msecs, 0, 999);
3051
3052 return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
3053 }
3054
3055 #define SET_STR_METADATA(pb, name, str) do { \
3056 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
3057 return ret; \
3058 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3059 } while (0)
3060
3061 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
3062 major = avio_rb16(pb); \
3063 minor = avio_rb16(pb); \
3064 tertiary = avio_rb16(pb); \
3065 patch = avio_rb16(pb); \
3066 release = avio_rb16(pb); \
3067 if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
3068 return ret; \
3069 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3070 } while (0)
3071
3072 #define SET_UID_METADATA(pb, name, var, str) do { \
3073 char uuid_str[2 * AV_UUID_LEN + 4 + 1]; \
3074 avio_read(pb, var, 16); \
3075 av_uuid_unparse(uid, uuid_str); \
3076 av_dict_set(&s->metadata, name, uuid_str, 0); \
3077 } while (0)
3078
3079 #define SET_TS_METADATA(pb, name, var, str) do { \
3080 var = avio_rb64(pb); \
3081 if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
3082 return ret; \
3083 } while (0)
3084
mxf_read_identification_metadata(void * arg,AVIOContext * pb,int tag,int size,UID _uid,int64_t klv_offset)3085 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
3086 {
3087 MXFContext *mxf = arg;
3088 AVFormatContext *s = mxf->fc;
3089 int ret;
3090 UID uid = { 0 };
3091 char *str = NULL;
3092 uint64_t ts;
3093 uint16_t major, minor, tertiary, patch, release;
3094 switch (tag) {
3095 case 0x3C01:
3096 SET_STR_METADATA(pb, "company_name", str);
3097 break;
3098 case 0x3C02:
3099 SET_STR_METADATA(pb, "product_name", str);
3100 break;
3101 case 0x3C03:
3102 SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
3103 break;
3104 case 0x3C04:
3105 SET_STR_METADATA(pb, "product_version", str);
3106 break;
3107 case 0x3C05:
3108 SET_UID_METADATA(pb, "product_uid", uid, str);
3109 break;
3110 case 0x3C06:
3111 SET_TS_METADATA(pb, "modification_date", ts, str);
3112 break;
3113 case 0x3C07:
3114 SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
3115 break;
3116 case 0x3C08:
3117 SET_STR_METADATA(pb, "application_platform", str);
3118 break;
3119 case 0x3C09:
3120 SET_UID_METADATA(pb, "generation_uid", uid, str);
3121 break;
3122 case 0x3C0A:
3123 SET_UID_METADATA(pb, "uid", uid, str);
3124 break;
3125 }
3126 return 0;
3127 }
3128
mxf_read_preface_metadata(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)3129 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
3130 {
3131 MXFContext *mxf = arg;
3132 AVFormatContext *s = mxf->fc;
3133 int ret;
3134 char *str = NULL;
3135
3136 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
3137 SET_STR_METADATA(pb, "project_name", str);
3138 }
3139 return 0;
3140 }
3141
3142 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
3143 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
3144 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
3145 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
3146 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
3147 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
3148 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
3149 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
3150 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
3151 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
3152 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
3153 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
3154 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
3155 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
3156 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
3157 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
3158 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
3159 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
3160 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
3161 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
3162 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
3163 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
3164 { { 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 */
3165 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
3166 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
3167 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
3168 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
3169 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
3170 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VBI - SMPTE 436M */
3171 { { 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 */
3172 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
3173 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* DC Timed Text Descriptor */
3174 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6b,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), AudioChannelLabelSubDescriptor },
3175 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6c,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), SoundfieldGroupLabelSubDescriptor },
3176 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6d,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor },
3177 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
3178 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
3179 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
3180 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
3181 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
3182 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
3183 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
3184 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
3185 };
3186
mxf_metadataset_init(MXFMetadataSet * ctx,enum MXFMetadataSetType type,MXFPartition * partition)3187 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
3188 {
3189 ctx->type = type;
3190 ctx->partition_score = partition_score(partition);
3191 switch (type){
3192 case MultipleDescriptor:
3193 case Descriptor:
3194 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
3195 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
3196 break;
3197 default:
3198 break;
3199 }
3200 return 0;
3201 }
3202
mxf_read_local_tags(MXFContext * mxf,KLVPacket * klv,MXFMetadataReadFunc * read_child,int ctx_size,enum MXFMetadataSetType type)3203 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
3204 {
3205 AVIOContext *pb = mxf->fc->pb;
3206 uint64_t klv_end = avio_tell(pb) + klv->length;
3207 MXFMetadataSet *meta;
3208 void *ctx;
3209
3210 if (ctx_size) {
3211 meta = av_mallocz(ctx_size);
3212 if (!meta)
3213 return AVERROR(ENOMEM);
3214 ctx = meta;
3215 mxf_metadataset_init(meta, type, mxf->current_partition);
3216 } else {
3217 meta = NULL;
3218 ctx = mxf;
3219 }
3220 while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
3221 int ret;
3222 int tag = avio_rb16(pb);
3223 int size = avio_rb16(pb); /* KLV specified by 0x53 */
3224 int64_t next = avio_tell(pb);
3225 UID uid = {0};
3226 if (next < 0 || next > INT64_MAX - size) {
3227 if (meta) {
3228 mxf_free_metadataset(&meta, 1);
3229 }
3230 return next < 0 ? next : AVERROR_INVALIDDATA;
3231 }
3232 next += size;
3233
3234 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
3235 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
3236 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
3237 continue;
3238 }
3239 if (tag > 0x7FFF) { /* dynamic tag */
3240 int i;
3241 for (i = 0; i < mxf->local_tags_count; i++) {
3242 int local_tag = AV_RB16(mxf->local_tags+i*18);
3243 if (local_tag == tag) {
3244 memcpy(uid, mxf->local_tags+i*18+2, 16);
3245 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
3246 PRINT_KEY(mxf->fc, "uid", uid);
3247 }
3248 }
3249 }
3250 if (meta && tag == 0x3C0A) {
3251 avio_read(pb, meta->uid, 16);
3252 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
3253 if (meta) {
3254 mxf_free_metadataset(&meta, 1);
3255 }
3256 return ret;
3257 }
3258
3259 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
3260 * it extending past the end of the KLV though (zzuf5.mxf). */
3261 if (avio_tell(pb) > klv_end) {
3262 if (meta) {
3263 mxf_free_metadataset(&meta, 1);
3264 }
3265
3266 av_log(mxf->fc, AV_LOG_ERROR,
3267 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
3268 tag, klv->offset);
3269 return AVERROR_INVALIDDATA;
3270 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
3271 avio_seek(pb, next, SEEK_SET);
3272 }
3273 return meta ? mxf_add_metadata_set(mxf, &meta) : 0;
3274 }
3275
3276 /**
3277 * Matches any partition pack key, in other words:
3278 * - HeaderPartition
3279 * - BodyPartition
3280 * - FooterPartition
3281 * @return non-zero if the key is a partition pack key, zero otherwise
3282 */
mxf_is_partition_pack_key(UID key)3283 static int mxf_is_partition_pack_key(UID key)
3284 {
3285 //NOTE: this is a little lax since it doesn't constraint key[14]
3286 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
3287 key[13] >= 2 && key[13] <= 4;
3288 }
3289
3290 /**
3291 * Parses a metadata KLV
3292 * @return <0 on error, 0 otherwise
3293 */
mxf_parse_klv(MXFContext * mxf,KLVPacket klv,MXFMetadataReadFunc * read,int ctx_size,enum MXFMetadataSetType type)3294 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
3295 int ctx_size, enum MXFMetadataSetType type)
3296 {
3297 AVFormatContext *s = mxf->fc;
3298 int res;
3299 if (klv.key[5] == 0x53) {
3300 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
3301 } else {
3302 uint64_t next = avio_tell(s->pb) + klv.length;
3303 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
3304
3305 /* only seek forward, else this can loop for a long time */
3306 if (avio_tell(s->pb) > next) {
3307 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
3308 klv.offset);
3309 return AVERROR_INVALIDDATA;
3310 }
3311
3312 avio_seek(s->pb, next, SEEK_SET);
3313 }
3314 if (res < 0) {
3315 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3316 return res;
3317 }
3318 return 0;
3319 }
3320
3321 /**
3322 * Seeks to the previous partition and parses it, if possible
3323 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3324 */
mxf_seek_to_previous_partition(MXFContext * mxf)3325 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3326 {
3327 AVIOContext *pb = mxf->fc->pb;
3328 KLVPacket klv;
3329 int64_t current_partition_ofs;
3330 int ret;
3331
3332 if (!mxf->current_partition ||
3333 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3334 return 0; /* we've parsed all partitions */
3335
3336 /* seek to previous partition */
3337 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3338 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3339 mxf->current_partition = NULL;
3340
3341 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3342
3343 /* Make sure this is actually a PartitionPack, and if so parse it.
3344 * See deadlock2.mxf
3345 */
3346 if ((ret = klv_read_packet(mxf, &klv, pb)) < 0) {
3347 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3348 return ret;
3349 }
3350
3351 if (!mxf_is_partition_pack_key(klv.key)) {
3352 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3353 return AVERROR_INVALIDDATA;
3354 }
3355
3356 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3357 * can point to just before the current partition, causing klv_read_packet()
3358 * to sync back up to it. See deadlock3.mxf
3359 */
3360 if (klv.offset >= current_partition_ofs) {
3361 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3362 PRIx64 " indirectly points to itself\n", current_partition_ofs);
3363 return AVERROR_INVALIDDATA;
3364 }
3365
3366 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3367 return ret;
3368
3369 return 1;
3370 }
3371
3372 /**
3373 * Called when essence is encountered
3374 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3375 */
mxf_parse_handle_essence(MXFContext * mxf)3376 static int mxf_parse_handle_essence(MXFContext *mxf)
3377 {
3378 AVIOContext *pb = mxf->fc->pb;
3379 int64_t ret;
3380
3381 if (mxf->parsing_backward) {
3382 return mxf_seek_to_previous_partition(mxf);
3383 } else {
3384 if (!mxf->footer_partition) {
3385 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3386 return 0;
3387 }
3388
3389 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3390
3391 /* remember where we were so we don't end up seeking further back than this */
3392 mxf->last_forward_tell = avio_tell(pb);
3393
3394 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3395 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3396 return -1;
3397 }
3398
3399 /* seek to FooterPartition and parse backward */
3400 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3401 av_log(mxf->fc, AV_LOG_ERROR,
3402 "failed to seek to FooterPartition @ 0x%" PRIx64
3403 " (%"PRId64") - partial file?\n",
3404 mxf->run_in + mxf->footer_partition, ret);
3405 return ret;
3406 }
3407
3408 mxf->current_partition = NULL;
3409 mxf->parsing_backward = 1;
3410 }
3411
3412 return 1;
3413 }
3414
3415 /**
3416 * Called when the next partition or EOF is encountered
3417 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3418 */
mxf_parse_handle_partition_or_eof(MXFContext * mxf)3419 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3420 {
3421 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3422 }
3423
mxf_get_wrapping_by_body_sid(AVFormatContext * s,int body_sid)3424 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3425 {
3426 for (int i = 0; i < s->nb_streams; i++) {
3427 MXFTrack *track = s->streams[i]->priv_data;
3428 if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3429 return track->wrapping;
3430 }
3431 return UnknownWrapped;
3432 }
3433
3434 /**
3435 * Figures out the proper offset and length of the essence container in each partition
3436 */
mxf_compute_essence_containers(AVFormatContext * s)3437 static void mxf_compute_essence_containers(AVFormatContext *s)
3438 {
3439 MXFContext *mxf = s->priv_data;
3440 int x;
3441
3442 for (x = 0; x < mxf->partitions_count; x++) {
3443 MXFPartition *p = &mxf->partitions[x];
3444 MXFWrappingScheme wrapping;
3445
3446 if (!p->body_sid)
3447 continue; /* BodySID == 0 -> no essence */
3448
3449 /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3450 * otherwise we point essence_offset at the key of the first essence KLV.
3451 */
3452
3453 wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3454
3455 if (wrapping == ClipWrapped) {
3456 p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3457 p->essence_length = p->first_essence_klv.length;
3458 } else {
3459 p->essence_offset = p->first_essence_klv.offset;
3460
3461 /* essence container spans to the next partition */
3462 if (x < mxf->partitions_count - 1)
3463 p->essence_length = mxf->partitions[x+1].pack_ofs - mxf->run_in - p->essence_offset;
3464
3465 if (p->essence_length < 0) {
3466 /* next ThisPartition < essence_offset */
3467 p->essence_length = 0;
3468 av_log(mxf->fc, AV_LOG_ERROR,
3469 "partition %i: bad ThisPartition = %"PRIX64"\n",
3470 x+1, mxf->partitions[x+1].pack_ofs - mxf->run_in);
3471 }
3472 }
3473 }
3474 }
3475
mxf_find_index_table(MXFContext * mxf,int index_sid)3476 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3477 {
3478 int i;
3479 for (i = 0; i < mxf->nb_index_tables; i++)
3480 if (mxf->index_tables[i].index_sid == index_sid)
3481 return &mxf->index_tables[i];
3482 return NULL;
3483 }
3484
3485 /**
3486 * Deal with the case where for some audio atoms EditUnitByteCount is
3487 * very small (2, 4..). In those cases we should read more than one
3488 * sample per call to mxf_read_packet().
3489 */
mxf_compute_edit_units_per_packet(MXFContext * mxf,AVStream * st)3490 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3491 {
3492 MXFTrack *track = st->priv_data;
3493 MXFIndexTable *t;
3494
3495 if (!track)
3496 return;
3497 track->edit_units_per_packet = 1;
3498 if (track->wrapping != ClipWrapped)
3499 return;
3500
3501 t = mxf_find_index_table(mxf, track->index_sid);
3502
3503 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3504 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3505 !is_pcm(st->codecpar->codec_id) ||
3506 !t ||
3507 t->nb_segments != 1 ||
3508 t->segments[0]->edit_unit_byte_count >= 32)
3509 return;
3510
3511 /* arbitrarily default to 48 kHz PAL audio frame size */
3512 /* TODO: We could compute this from the ratio between the audio
3513 * and video edit rates for 48 kHz NTSC we could use the
3514 * 1802-1802-1802-1802-1801 pattern. */
3515 track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3516 }
3517
3518 /**
3519 * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3520 */
mxf_handle_missing_index_segment(MXFContext * mxf,AVStream * st)3521 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3522 {
3523 MXFTrack *track = st->priv_data;
3524 MXFIndexTableSegment *segment = NULL;
3525 MXFPartition *p = NULL;
3526 int essence_partition_count = 0;
3527 int edit_unit_byte_count = 0;
3528 int i, ret;
3529
3530 if (!track || track->wrapping != ClipWrapped)
3531 return 0;
3532
3533 /* check if track already has an IndexTableSegment */
3534 for (i = 0; i < mxf->metadata_sets_count; i++) {
3535 if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3536 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3537 if (s->body_sid == track->body_sid)
3538 return 0;
3539 }
3540 }
3541
3542 /* find the essence partition */
3543 for (i = 0; i < mxf->partitions_count; i++) {
3544 /* BodySID == 0 -> no essence */
3545 if (mxf->partitions[i].body_sid != track->body_sid)
3546 continue;
3547
3548 p = &mxf->partitions[i];
3549 essence_partition_count++;
3550 }
3551
3552 /* only handle files with a single essence partition */
3553 if (essence_partition_count != 1)
3554 return 0;
3555
3556 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3557 edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) *
3558 st->codecpar->ch_layout.nb_channels) >> 3;
3559 } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3560 edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3561 }
3562
3563 if (edit_unit_byte_count <= 0)
3564 return 0;
3565
3566 av_log(mxf->fc, AV_LOG_WARNING, "guessing index for stream %d using edit unit byte count %d\n", st->index, edit_unit_byte_count);
3567
3568 if (!(segment = av_mallocz(sizeof(*segment))))
3569 return AVERROR(ENOMEM);
3570
3571 if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3572 return ret;
3573
3574 /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3575 * using the same SID for index is forbidden in MXF. */
3576 if (!track->index_sid)
3577 track->index_sid = track->body_sid;
3578
3579 segment->meta.type = IndexTableSegment;
3580 /* stream will be treated as small EditUnitByteCount */
3581 segment->edit_unit_byte_count = edit_unit_byte_count;
3582 segment->index_start_position = 0;
3583 segment->index_duration = st->duration;
3584 segment->index_edit_rate = av_inv_q(st->time_base);
3585 segment->index_sid = track->index_sid;
3586 segment->body_sid = p->body_sid;
3587 return 0;
3588 }
3589
mxf_read_random_index_pack(AVFormatContext * s)3590 static void mxf_read_random_index_pack(AVFormatContext *s)
3591 {
3592 MXFContext *mxf = s->priv_data;
3593 uint32_t length;
3594 int64_t file_size, max_rip_length, min_rip_length;
3595 KLVPacket klv;
3596
3597 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3598 return;
3599
3600 file_size = avio_size(s->pb);
3601
3602 /* S377m says to check the RIP length for "silly" values, without defining "silly".
3603 * The limit below assumes a file with nothing but partition packs and a RIP.
3604 * Before changing this, consider that a muxer may place each sample in its own partition.
3605 *
3606 * 105 is the size of the smallest possible PartitionPack
3607 * 12 is the size of each RIP entry
3608 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3609 */
3610 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3611 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3612
3613 /* We're only interested in RIPs with at least two entries.. */
3614 min_rip_length = 16+1+24+4;
3615
3616 /* See S377m section 11 */
3617 avio_seek(s->pb, file_size - 4, SEEK_SET);
3618 length = avio_rb32(s->pb);
3619
3620 if (length < min_rip_length || length > max_rip_length)
3621 goto end;
3622 avio_seek(s->pb, file_size - length, SEEK_SET);
3623 if (klv_read_packet(mxf, &klv, s->pb) < 0 ||
3624 !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3625 goto end;
3626 if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3627 av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3628 goto end;
3629 }
3630
3631 avio_skip(s->pb, klv.length - 12);
3632 mxf->footer_partition = avio_rb64(s->pb);
3633
3634 /* sanity check */
3635 if (mxf->run_in + mxf->footer_partition >= file_size) {
3636 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3637 mxf->footer_partition = 0;
3638 }
3639
3640 end:
3641 avio_seek(s->pb, mxf->run_in, SEEK_SET);
3642 }
3643
mxf_read_header(AVFormatContext * s)3644 static int mxf_read_header(AVFormatContext *s)
3645 {
3646 MXFContext *mxf = s->priv_data;
3647 KLVPacket klv;
3648 int64_t essence_offset = 0;
3649 int ret;
3650 int64_t run_in;
3651
3652 mxf->last_forward_tell = INT64_MAX;
3653
3654 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3655 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3656 return AVERROR_INVALIDDATA;
3657 }
3658 avio_seek(s->pb, -14, SEEK_CUR);
3659 mxf->fc = s;
3660 run_in = avio_tell(s->pb);
3661 if (run_in < 0 || run_in > RUN_IN_MAX)
3662 return AVERROR_INVALIDDATA;
3663 mxf->run_in = run_in;
3664
3665 mxf_read_random_index_pack(s);
3666
3667 while (!avio_feof(s->pb)) {
3668 const MXFMetadataReadTableEntry *metadata;
3669
3670 if (klv_read_packet(mxf, &klv, s->pb) < 0) {
3671 /* EOF - seek to previous partition or stop */
3672 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3673 break;
3674 else
3675 continue;
3676 }
3677
3678 PRINT_KEY(s, "read header", klv.key);
3679 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3680 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3681 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3682 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3683 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3684 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3685 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3686
3687 if (!mxf->current_partition) {
3688 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3689 return AVERROR_INVALIDDATA;
3690 }
3691
3692 if (!mxf->current_partition->first_essence_klv.offset)
3693 mxf->current_partition->first_essence_klv = klv;
3694
3695 if (!essence_offset)
3696 essence_offset = klv.offset;
3697
3698 /* seek to footer, previous partition or stop */
3699 if (mxf_parse_handle_essence(mxf) <= 0)
3700 break;
3701 continue;
3702 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3703 /* next partition pack - keep going, seek to previous partition or stop */
3704 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3705 break;
3706 else if (mxf->parsing_backward)
3707 continue;
3708 /* we're still parsing forward. proceed to parsing this partition pack */
3709 }
3710
3711 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3712 if (IS_KLV_KEY(klv.key, metadata->key)) {
3713 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3714 return ret;
3715 break;
3716 }
3717 }
3718 if (!metadata->read) {
3719 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3720 UID_ARG(klv.key));
3721 avio_skip(s->pb, klv.length);
3722 }
3723 }
3724 /* FIXME avoid seek */
3725 if (!essence_offset) {
3726 av_log(s, AV_LOG_ERROR, "no essence\n");
3727 return AVERROR_INVALIDDATA;
3728 }
3729 avio_seek(s->pb, essence_offset, SEEK_SET);
3730
3731 /* we need to do this before computing the index tables
3732 * to be able to fill in zero IndexDurations with st->duration */
3733 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3734 return ret;
3735
3736 for (int i = 0; i < s->nb_streams; i++)
3737 mxf_handle_missing_index_segment(mxf, s->streams[i]);
3738
3739 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3740 return ret;
3741
3742 if (mxf->nb_index_tables > 1) {
3743 /* TODO: look up which IndexSID to use via EssenceContainerData */
3744 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3745 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3746 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3747 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3748 return AVERROR_INVALIDDATA;
3749 }
3750
3751 mxf_compute_essence_containers(s);
3752
3753 for (int i = 0; i < s->nb_streams; i++)
3754 mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3755
3756 return 0;
3757 }
3758
3759 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
mxf_get_next_track_edit_unit(MXFContext * mxf,MXFTrack * track,int64_t current_offset,int64_t * edit_unit_out)3760 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3761 {
3762 int64_t a, b, m, offset;
3763 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3764
3765 if (!t || track->original_duration <= 0)
3766 return -1;
3767
3768 a = -1;
3769 b = track->original_duration;
3770
3771 while (b - a > 1) {
3772 m = (a + b) >> 1;
3773 if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3774 return -1;
3775 if (offset < current_offset)
3776 a = m;
3777 else
3778 b = m;
3779 }
3780
3781 *edit_unit_out = b;
3782
3783 return 0;
3784 }
3785
mxf_compute_sample_count(MXFContext * mxf,AVStream * st,int64_t edit_unit)3786 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3787 int64_t edit_unit)
3788 {
3789 MXFTrack *track = st->priv_data;
3790 AVRational time_base = av_inv_q(track->edit_rate);
3791 AVRational sample_rate = av_inv_q(st->time_base);
3792
3793 // For non-audio sample_count equals current edit unit
3794 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3795 return edit_unit;
3796
3797 if ((sample_rate.num / sample_rate.den) == 48000) {
3798 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3799 } else {
3800 int64_t remainder = (sample_rate.num * (int64_t) time_base.num) %
3801 ( time_base.den * (int64_t)sample_rate.den);
3802 if (remainder)
3803 av_log(mxf->fc, AV_LOG_WARNING,
3804 "seeking detected on stream #%d with time base (%d/%d) and "
3805 "sample rate (%d/%d), audio pts won't be accurate.\n",
3806 st->index, time_base.num, time_base.den,
3807 sample_rate.num, sample_rate.den);
3808 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3809 }
3810 }
3811
3812 /**
3813 * Make sure track->sample_count is correct based on what offset we're currently at.
3814 * Also determine the next edit unit (or packet) offset.
3815 * @return next_ofs if OK, <0 on error
3816 */
mxf_set_current_edit_unit(MXFContext * mxf,AVStream * st,int64_t current_offset,int resync)3817 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3818 {
3819 int64_t next_ofs = -1;
3820 MXFTrack *track = st->priv_data;
3821 int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3822 int64_t new_edit_unit;
3823 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3824
3825 if (!t || track->wrapping == UnknownWrapped)
3826 return -1;
3827
3828 if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3829 (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3830 av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3831 return -1;
3832 }
3833
3834 /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3835 if (next_ofs > current_offset)
3836 return next_ofs;
3837
3838 if (!resync) {
3839 av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3840 return -1;
3841 }
3842
3843 if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3844 av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3845 return -1;
3846 }
3847
3848 new_edit_unit--;
3849 track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3850 av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
3851
3852 return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3853 }
3854
mxf_set_audio_pts(MXFContext * mxf,AVCodecParameters * par,AVPacket * pkt)3855 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3856 AVPacket *pkt)
3857 {
3858 AVStream *st = mxf->fc->streams[pkt->stream_index];
3859 MXFTrack *track = st->priv_data;
3860 int64_t bits_per_sample = par->bits_per_coded_sample;
3861
3862 if (!bits_per_sample)
3863 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3864
3865 pkt->pts = track->sample_count;
3866
3867 if (par->ch_layout.nb_channels <= 0 ||
3868 bits_per_sample <= 0 ||
3869 par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
3870 track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
3871 else
3872 track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
3873
3874 return 0;
3875 }
3876
mxf_set_pts(MXFContext * mxf,AVStream * st,AVPacket * pkt)3877 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3878 {
3879 AVCodecParameters *par = st->codecpar;
3880 MXFTrack *track = st->priv_data;
3881
3882 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3883 /* see if we have an index table to derive timestamps from */
3884 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3885
3886 if (t && track->sample_count < t->nb_ptses) {
3887 pkt->dts = track->sample_count + t->first_dts;
3888 pkt->pts = t->ptses[track->sample_count];
3889 } else if (track->intra_only) {
3890 /* intra-only -> PTS = EditUnit.
3891 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3892 pkt->pts = track->sample_count;
3893 }
3894 track->sample_count++;
3895 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3896 int ret = mxf_set_audio_pts(mxf, par, pkt);
3897 if (ret < 0)
3898 return ret;
3899 } else if (track) {
3900 pkt->dts = pkt->pts = track->sample_count;
3901 pkt->duration = 1;
3902 track->sample_count++;
3903 }
3904 return 0;
3905 }
3906
mxf_read_packet(AVFormatContext * s,AVPacket * pkt)3907 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3908 {
3909 KLVPacket klv;
3910 MXFContext *mxf = s->priv_data;
3911 int ret;
3912
3913 while (1) {
3914 int64_t max_data_size;
3915 int64_t pos = avio_tell(s->pb);
3916
3917 if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3918 mxf->current_klv_data = (KLVPacket){{0}};
3919 ret = klv_read_packet(mxf, &klv, s->pb);
3920 if (ret < 0)
3921 break;
3922 max_data_size = klv.length;
3923 pos = klv.next_klv - klv.length;
3924 PRINT_KEY(s, "read packet", klv.key);
3925 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3926 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3927 ret = mxf_decrypt_triplet(s, pkt, &klv);
3928 if (ret < 0) {
3929 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3930 return ret;
3931 }
3932 return 0;
3933 }
3934 } else {
3935 klv = mxf->current_klv_data;
3936 max_data_size = klv.next_klv - pos;
3937 }
3938 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3939 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3940 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3941 int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3942 int index = mxf_get_stream_index(s, &klv, body_sid);
3943 int64_t next_ofs;
3944 AVStream *st;
3945 MXFTrack *track;
3946
3947 if (index < 0) {
3948 av_log(s, AV_LOG_ERROR,
3949 "error getting stream index %"PRIu32"\n",
3950 AV_RB32(klv.key + 12));
3951 goto skip;
3952 }
3953
3954 st = s->streams[index];
3955 track = st->priv_data;
3956
3957 if (s->streams[index]->discard == AVDISCARD_ALL)
3958 goto skip;
3959
3960 next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3961
3962 if (track->wrapping != FrameWrapped) {
3963 int64_t size;
3964
3965 if (next_ofs <= 0) {
3966 // If we have no way to packetize the data, then return it in chunks...
3967 if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3968 ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
3969 avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3970 }
3971 size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3972 } else {
3973 if ((size = next_ofs - pos) <= 0) {
3974 av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3975 mxf->current_klv_data = (KLVPacket){{0}};
3976 return AVERROR_INVALIDDATA;
3977 }
3978 // We must not overread, because the next edit unit might be in another KLV
3979 if (size > max_data_size)
3980 size = max_data_size;
3981 }
3982
3983 mxf->current_klv_data = klv;
3984 klv.offset = pos;
3985 klv.length = size;
3986 klv.next_klv = klv.offset + klv.length;
3987 }
3988
3989 /* check for 8 channels AES3 element */
3990 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3991 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3992 pkt, klv.length);
3993 if (ret < 0) {
3994 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3995 mxf->current_klv_data = (KLVPacket){{0}};
3996 return ret;
3997 }
3998 } else if (mxf->eia608_extract &&
3999 s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4000 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4001 if (ret < 0) {
4002 mxf->current_klv_data = (KLVPacket){{0}};
4003 return ret;
4004 }
4005 } else {
4006 ret = av_get_packet(s->pb, pkt, klv.length);
4007 if (ret < 0) {
4008 mxf->current_klv_data = (KLVPacket){{0}};
4009 return ret;
4010 }
4011 }
4012 pkt->stream_index = index;
4013 pkt->pos = klv.offset;
4014
4015 ret = mxf_set_pts(mxf, st, pkt);
4016 if (ret < 0) {
4017 mxf->current_klv_data = (KLVPacket){{0}};
4018 return ret;
4019 }
4020
4021 /* seek for truncated packets */
4022 avio_seek(s->pb, klv.next_klv, SEEK_SET);
4023
4024 return 0;
4025 } else {
4026 skip:
4027 avio_skip(s->pb, max_data_size);
4028 mxf->current_klv_data = (KLVPacket){{0}};
4029 }
4030 }
4031 return avio_feof(s->pb) ? AVERROR_EOF : ret;
4032 }
4033
mxf_read_close(AVFormatContext * s)4034 static int mxf_read_close(AVFormatContext *s)
4035 {
4036 MXFContext *mxf = s->priv_data;
4037 int i;
4038
4039 av_freep(&mxf->packages_refs);
4040 av_freep(&mxf->essence_container_data_refs);
4041
4042 for (i = 0; i < s->nb_streams; i++)
4043 s->streams[i]->priv_data = NULL;
4044
4045 for (i = 0; i < mxf->metadata_sets_count; i++) {
4046 mxf_free_metadataset(mxf->metadata_sets + i, 1);
4047 }
4048 mxf->metadata_sets_count = 0;
4049 av_freep(&mxf->partitions);
4050 av_freep(&mxf->metadata_sets);
4051 av_freep(&mxf->aesc);
4052 av_freep(&mxf->local_tags);
4053
4054 if (mxf->index_tables) {
4055 for (i = 0; i < mxf->nb_index_tables; i++) {
4056 av_freep(&mxf->index_tables[i].segments);
4057 av_freep(&mxf->index_tables[i].ptses);
4058 av_freep(&mxf->index_tables[i].fake_index);
4059 av_freep(&mxf->index_tables[i].offsets);
4060 }
4061 }
4062 av_freep(&mxf->index_tables);
4063
4064 return 0;
4065 }
4066
mxf_probe(const AVProbeData * p)4067 static int mxf_probe(const AVProbeData *p) {
4068 const uint8_t *bufp = p->buf;
4069 const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4070
4071 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4072 return 0;
4073
4074 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4075 end -= sizeof(mxf_header_partition_pack_key);
4076
4077 for (; bufp < end;) {
4078 if (!((bufp[13] - 1) & 0xF2)){
4079 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4080 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4081 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4082 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
4083 return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4084 bufp ++;
4085 } else
4086 bufp += 10;
4087 }
4088
4089 return 0;
4090 }
4091
4092 /* rudimentary byte seek */
4093 /* XXX: use MXF Index */
mxf_read_seek(AVFormatContext * s,int stream_index,int64_t sample_time,int flags)4094 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4095 {
4096 AVStream *st = s->streams[stream_index];
4097 int64_t seconds;
4098 MXFContext* mxf = s->priv_data;
4099 int64_t seekpos;
4100 int i, ret;
4101 MXFIndexTable *t;
4102 MXFTrack *source_track = st->priv_data;
4103
4104 if (!source_track)
4105 return 0;
4106
4107 /* if audio then truncate sample_time to EditRate */
4108 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4109 sample_time = av_rescale_q(sample_time, st->time_base,
4110 av_inv_q(source_track->edit_rate));
4111
4112 if (mxf->nb_index_tables <= 0) {
4113 if (!s->bit_rate)
4114 return AVERROR_INVALIDDATA;
4115 if (sample_time < 0)
4116 sample_time = 0;
4117 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4118
4119 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4120 if (seekpos < 0)
4121 return seekpos;
4122
4123 avpriv_update_cur_dts(s, st, sample_time);
4124 mxf->current_klv_data = (KLVPacket){{0}};
4125 } else {
4126 MXFPartition *partition;
4127
4128 t = &mxf->index_tables[0];
4129 if (t->index_sid != source_track->index_sid) {
4130 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
4131 for (i = 0; i < s->nb_streams; i++) {
4132 MXFTrack *new_source_track = s->streams[i]->priv_data;
4133 if (new_source_track && new_source_track->index_sid == t->index_sid) {
4134 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
4135 source_track = new_source_track;
4136 st = s->streams[i];
4137 break;
4138 }
4139 }
4140 if (i == s->nb_streams)
4141 return AVERROR_INVALIDDATA;
4142 }
4143
4144 /* clamp above zero, else ff_index_search_timestamp() returns negative
4145 * this also means we allow seeking before the start */
4146 sample_time = FFMAX(sample_time, 0);
4147
4148 if (t->fake_index) {
4149 /* The first frames may not be keyframes in presentation order, so
4150 * we have to advance the target to be able to find the first
4151 * keyframe backwards... */
4152 if (!(flags & AVSEEK_FLAG_ANY) &&
4153 (flags & AVSEEK_FLAG_BACKWARD) &&
4154 t->ptses[0] != AV_NOPTS_VALUE &&
4155 sample_time < t->ptses[0] &&
4156 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
4157 sample_time = t->ptses[0];
4158
4159 /* behave as if we have a proper index */
4160 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
4161 return sample_time;
4162 /* get the stored order index from the display order index */
4163 sample_time += t->offsets[sample_time];
4164 } else {
4165 /* no IndexEntryArray (one or more CBR segments)
4166 * make sure we don't seek past the end */
4167 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
4168 }
4169
4170 if (source_track->wrapping == UnknownWrapped)
4171 av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
4172
4173 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
4174 return ret;
4175
4176 avpriv_update_cur_dts(s, st, sample_time);
4177 if (source_track->wrapping == ClipWrapped) {
4178 KLVPacket klv = partition->first_essence_klv;
4179 if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
4180 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
4181 return AVERROR_INVALIDDATA;
4182 }
4183 mxf->current_klv_data = klv;
4184 } else {
4185 mxf->current_klv_data = (KLVPacket){{0}};
4186 }
4187 avio_seek(s->pb, seekpos, SEEK_SET);
4188 }
4189
4190 // Update all tracks sample count
4191 for (i = 0; i < s->nb_streams; i++) {
4192 AVStream *cur_st = s->streams[i];
4193 MXFTrack *cur_track = cur_st->priv_data;
4194 if (cur_track) {
4195 int64_t track_edit_unit = sample_time;
4196 if (st != cur_st)
4197 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
4198 cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
4199 }
4200 }
4201 return 0;
4202 }
4203
4204 static const AVOption options[] = {
4205 { "eia608_extract", "extract eia 608 captions from s436m track",
4206 offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
4207 AV_OPT_FLAG_DECODING_PARAM },
4208 { NULL },
4209 };
4210
4211 static const AVClass demuxer_class = {
4212 .class_name = "mxf",
4213 .item_name = av_default_item_name,
4214 .option = options,
4215 .version = LIBAVUTIL_VERSION_INT,
4216 .category = AV_CLASS_CATEGORY_DEMUXER,
4217 };
4218
4219 const AVInputFormat ff_mxf_demuxer = {
4220 .name = "mxf",
4221 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
4222 .flags = AVFMT_SEEK_TO_PTS,
4223 .priv_data_size = sizeof(MXFContext),
4224 .flags_internal = FF_FMT_INIT_CLEANUP,
4225 .read_probe = mxf_probe,
4226 .read_header = mxf_read_header,
4227 .read_packet = mxf_read_packet,
4228 .read_close = mxf_read_close,
4229 .read_seek = mxf_read_seek,
4230 .priv_class = &demuxer_class,
4231 };
4232