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 if (s->edit_unit_byte_count && (s->index_duration > INT64_MAX / s->edit_unit_byte_count ||
1889 s->edit_unit_byte_count * s->index_duration > INT64_MAX - offset_temp)
1890 )
1891 return AVERROR_INVALIDDATA;
1892 offset_temp += s->edit_unit_byte_count * s->index_duration;
1893 }
1894 }
1895
1896 if (nag)
1897 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);
1898
1899 return AVERROR_INVALIDDATA;
1900 }
1901
mxf_compute_ptses_fake_index(MXFContext * mxf,MXFIndexTable * index_table)1902 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1903 {
1904 int i, j, x;
1905 int8_t max_temporal_offset = -128;
1906 uint8_t *flags;
1907
1908 /* first compute how many entries we have */
1909 for (i = 0; i < index_table->nb_segments; i++) {
1910 MXFIndexTableSegment *s = index_table->segments[i];
1911
1912 if (!s->nb_index_entries) {
1913 index_table->nb_ptses = 0;
1914 return 0; /* no TemporalOffsets */
1915 }
1916
1917 if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1918 index_table->nb_ptses = 0;
1919 av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1920 return 0;
1921 }
1922
1923 index_table->nb_ptses += s->index_duration;
1924 }
1925
1926 /* paranoid check */
1927 if (index_table->nb_ptses <= 0)
1928 return 0;
1929
1930 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1931 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1932 !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1933 !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1934 av_freep(&index_table->ptses);
1935 av_freep(&index_table->fake_index);
1936 av_freep(&index_table->offsets);
1937 return AVERROR(ENOMEM);
1938 }
1939
1940 /* we may have a few bad TemporalOffsets
1941 * make sure the corresponding PTSes don't have the bogus value 0 */
1942 for (x = 0; x < index_table->nb_ptses; x++)
1943 index_table->ptses[x] = AV_NOPTS_VALUE;
1944
1945 /**
1946 * We have this:
1947 *
1948 * x TemporalOffset
1949 * 0: 0
1950 * 1: 1
1951 * 2: 1
1952 * 3: -2
1953 * 4: 1
1954 * 5: 1
1955 * 6: -2
1956 *
1957 * We want to transform it into this:
1958 *
1959 * x DTS PTS
1960 * 0: -1 0
1961 * 1: 0 3
1962 * 2: 1 1
1963 * 3: 2 2
1964 * 4: 3 6
1965 * 5: 4 4
1966 * 6: 5 5
1967 *
1968 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1969 * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
1970 * The latter makes DTS <= PTS.
1971 */
1972 for (i = x = 0; i < index_table->nb_segments; i++) {
1973 MXFIndexTableSegment *s = index_table->segments[i];
1974 int index_delta = 1;
1975 int n = s->nb_index_entries;
1976
1977 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1978 index_delta = 2; /* Avid index */
1979 /* ignore the last entry - it's the size of the essence container */
1980 n--;
1981 }
1982
1983 for (j = 0; j < n; j += index_delta, x++) {
1984 int offset = s->temporal_offset_entries[j] / index_delta;
1985 int index = x + offset;
1986
1987 if (x >= index_table->nb_ptses) {
1988 av_log(mxf->fc, AV_LOG_ERROR,
1989 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1990 s->nb_index_entries, s->index_duration);
1991 break;
1992 }
1993
1994 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1995
1996 if (index < 0 || index >= index_table->nb_ptses) {
1997 av_log(mxf->fc, AV_LOG_ERROR,
1998 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1999 x, offset, index);
2000 continue;
2001 }
2002
2003 index_table->offsets[x] = offset;
2004 index_table->ptses[index] = x;
2005 max_temporal_offset = FFMAX(max_temporal_offset, offset);
2006 }
2007 }
2008
2009 /* calculate the fake index table in display order */
2010 for (x = 0; x < index_table->nb_ptses; x++) {
2011 index_table->fake_index[x].timestamp = x;
2012 if (index_table->ptses[x] != AV_NOPTS_VALUE)
2013 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2014 }
2015 av_freep(&flags);
2016
2017 index_table->first_dts = -max_temporal_offset;
2018
2019 return 0;
2020 }
2021
2022 /**
2023 * Sorts and collects index table segments into index tables.
2024 * Also computes PTSes if possible.
2025 */
mxf_compute_index_tables(MXFContext * mxf)2026 static int mxf_compute_index_tables(MXFContext *mxf)
2027 {
2028 int i, j, k, ret, nb_sorted_segments;
2029 MXFIndexTableSegment **sorted_segments = NULL;
2030
2031 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2032 nb_sorted_segments <= 0) {
2033 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2034 return 0;
2035 }
2036
2037 /* sanity check and count unique BodySIDs/IndexSIDs */
2038 for (i = 0; i < nb_sorted_segments; i++) {
2039 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2040 mxf->nb_index_tables++;
2041 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2042 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2043 ret = AVERROR_INVALIDDATA;
2044 goto finish_decoding_index;
2045 }
2046 }
2047
2048 mxf->index_tables = av_calloc(mxf->nb_index_tables,
2049 sizeof(*mxf->index_tables));
2050 if (!mxf->index_tables) {
2051 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2052 ret = AVERROR(ENOMEM);
2053 goto finish_decoding_index;
2054 }
2055
2056 /* distribute sorted segments to index tables */
2057 for (i = j = 0; i < nb_sorted_segments; i++) {
2058 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2059 /* next IndexSID */
2060 j++;
2061 }
2062
2063 mxf->index_tables[j].nb_segments++;
2064 }
2065
2066 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2067 MXFIndexTable *t = &mxf->index_tables[j];
2068 MXFTrack *mxf_track = NULL;
2069
2070 t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2071 if (!t->segments) {
2072 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2073 " pointer array\n");
2074 ret = AVERROR(ENOMEM);
2075 goto finish_decoding_index;
2076 }
2077
2078 if (sorted_segments[i]->index_start_position)
2079 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2080 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2081
2082 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2083 t->index_sid = sorted_segments[i]->index_sid;
2084 t->body_sid = sorted_segments[i]->body_sid;
2085
2086 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2087 goto finish_decoding_index;
2088
2089 for (k = 0; k < mxf->fc->nb_streams; k++) {
2090 MXFTrack *track = mxf->fc->streams[k]->priv_data;
2091 if (track && track->index_sid == t->index_sid) {
2092 mxf_track = track;
2093 break;
2094 }
2095 }
2096
2097 /* fix zero IndexDurations */
2098 for (k = 0; k < t->nb_segments; k++) {
2099 if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2100 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2101 t->index_sid, k);
2102 if (mxf_track)
2103 t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2104 }
2105
2106 if (t->segments[k]->index_duration)
2107 continue;
2108
2109 if (t->nb_segments > 1)
2110 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2111 t->index_sid, k);
2112
2113 if (!mxf_track) {
2114 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2115 break;
2116 }
2117
2118 /* assume the first stream's duration is reasonable
2119 * leave index_duration = 0 on further segments in case we have any (unlikely)
2120 */
2121 t->segments[k]->index_duration = mxf_track->original_duration;
2122 break;
2123 }
2124 }
2125
2126 ret = 0;
2127 finish_decoding_index:
2128 av_free(sorted_segments);
2129 return ret;
2130 }
2131
mxf_is_intra_only(MXFDescriptor * descriptor)2132 static int mxf_is_intra_only(MXFDescriptor *descriptor)
2133 {
2134 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
2135 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
2136 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
2137 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
2138 }
2139
mxf_umid_to_str(const UID ul,const UID uid,char str[2+sizeof (UID)* 4+1])2140 static void mxf_umid_to_str(const UID ul, const UID uid,
2141 char str[2 + sizeof(UID) * 4 + 1])
2142 {
2143 snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2144 ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2145 ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2146 }
2147
mxf_version_to_str(uint16_t major,uint16_t minor,uint16_t tertiary,uint16_t patch,uint16_t release,char ** str)2148 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2149 uint16_t patch, uint16_t release, char **str)
2150 {
2151 *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2152 if (!*str)
2153 return AVERROR(ENOMEM);
2154 return 0;
2155 }
2156
mxf_add_umid_metadata(AVDictionary ** pm,const char * key,MXFPackage * package)2157 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2158 {
2159 char str[2 + 4 * sizeof(UID) + 1];
2160 if (!package)
2161 return 0;
2162 mxf_umid_to_str(package->package_ul, package->package_uid, str);
2163 av_dict_set(pm, key, str, 0);
2164 return 0;
2165 }
2166
mxf_add_timecode_metadata(AVDictionary ** pm,const char * key,AVTimecode * tc)2167 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2168 {
2169 char buf[AV_TIMECODE_STR_SIZE];
2170 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2171
2172 return 0;
2173 }
2174
mxf_resolve_timecode_component(MXFContext * mxf,UID * strong_ref)2175 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2176 {
2177 MXFStructuralComponent *component = NULL;
2178 MXFPulldownComponent *pulldown = NULL;
2179
2180 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2181 if (!component)
2182 return NULL;
2183
2184 switch (component->meta.type) {
2185 case TimecodeComponent:
2186 return (MXFTimecodeComponent*)component;
2187 case PulldownComponent: /* timcode component may be located on a pulldown component */
2188 pulldown = (MXFPulldownComponent*)component;
2189 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2190 default:
2191 break;
2192 }
2193 return NULL;
2194 }
2195
mxf_resolve_source_package(MXFContext * mxf,UID package_ul,UID package_uid)2196 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2197 {
2198 MXFPackage *package = NULL;
2199 int i;
2200
2201 for (i = 0; i < mxf->packages_count; i++) {
2202 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2203 if (!package)
2204 continue;
2205
2206 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2207 return package;
2208 }
2209 return NULL;
2210 }
2211
mxf_resolve_multidescriptor(MXFContext * mxf,MXFDescriptor * descriptor,int track_id)2212 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
2213 {
2214 MXFDescriptor *file_descriptor = NULL;
2215 int i;
2216
2217 if (!descriptor)
2218 return NULL;
2219
2220 if (descriptor->meta.type == MultipleDescriptor) {
2221 for (i = 0; i < descriptor->file_descriptors_count; i++) {
2222 file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2223
2224 if (!file_descriptor) {
2225 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2226 continue;
2227 }
2228 if (file_descriptor->linked_track_id == track_id) {
2229 return file_descriptor;
2230 }
2231 }
2232 } else if (descriptor->meta.type == Descriptor)
2233 return descriptor;
2234
2235 return NULL;
2236 }
2237
mxf_resolve_essence_group_choice(MXFContext * mxf,MXFEssenceGroup * essence_group)2238 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
2239 {
2240 MXFStructuralComponent *component = NULL;
2241 MXFPackage *package = NULL;
2242 MXFDescriptor *descriptor = NULL;
2243 int i;
2244
2245 if (!essence_group || !essence_group->structural_components_count)
2246 return NULL;
2247
2248 /* essence groups contains multiple representations of the same media,
2249 this return the first components with a valid Descriptor typically index 0 */
2250 for (i =0; i < essence_group->structural_components_count; i++){
2251 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2252 if (!component)
2253 continue;
2254
2255 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2256 continue;
2257
2258 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2259 if (descriptor)
2260 return component;
2261 }
2262 return NULL;
2263 }
2264
mxf_resolve_sourceclip(MXFContext * mxf,UID * strong_ref)2265 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2266 {
2267 MXFStructuralComponent *component = NULL;
2268
2269 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2270 if (!component)
2271 return NULL;
2272 switch (component->meta.type) {
2273 case SourceClip:
2274 return component;
2275 case EssenceGroup:
2276 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2277 default:
2278 break;
2279 }
2280 return NULL;
2281 }
2282
mxf_parse_package_comments(MXFContext * mxf,AVDictionary ** pm,MXFPackage * package)2283 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2284 {
2285 MXFTaggedValue *tag;
2286 int i;
2287 char *key = NULL;
2288
2289 for (i = 0; i < package->comment_count; i++) {
2290 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2291 if (!tag || !tag->name || !tag->value)
2292 continue;
2293
2294 key = av_asprintf("comment_%s", tag->name);
2295 if (!key)
2296 return AVERROR(ENOMEM);
2297
2298 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2299 }
2300 return 0;
2301 }
2302
mxf_parse_physical_source_package(MXFContext * mxf,MXFTrack * source_track,AVStream * st)2303 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2304 {
2305 MXFPackage *physical_package = NULL;
2306 MXFTrack *physical_track = NULL;
2307 MXFStructuralComponent *sourceclip = NULL;
2308 MXFTimecodeComponent *mxf_tc = NULL;
2309 int i, j, k;
2310 AVTimecode tc;
2311 int flags;
2312 int64_t start_position;
2313
2314 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2315 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2316 if (!sourceclip)
2317 continue;
2318
2319 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2320 break;
2321
2322 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2323
2324 /* the name of physical source package is name of the reel or tape */
2325 if (physical_package->name && physical_package->name[0])
2326 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2327
2328 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2329 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2330 */
2331 for (j = 0; j < physical_package->tracks_count; j++) {
2332 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2333 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2334 continue;
2335 }
2336
2337 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2338 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2339 continue;
2340 }
2341
2342 if (physical_track->edit_rate.num <= 0 ||
2343 physical_track->edit_rate.den <= 0) {
2344 av_log(mxf->fc, AV_LOG_WARNING,
2345 "Invalid edit rate (%d/%d) found on structural"
2346 " component #%d, defaulting to 25/1\n",
2347 physical_track->edit_rate.num,
2348 physical_track->edit_rate.den, i);
2349 physical_track->edit_rate = (AVRational){25, 1};
2350 }
2351
2352 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2353 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2354 continue;
2355
2356 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2357 /* scale sourceclip start_position to match physical track edit rate */
2358 start_position = av_rescale_q(sourceclip->start_position,
2359 physical_track->edit_rate,
2360 source_track->edit_rate);
2361 if (av_sat_add64(start_position, mxf_tc->start_frame) != start_position + (uint64_t)mxf_tc->start_frame)
2362 return AVERROR_INVALIDDATA;
2363
2364 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2365 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2366 return 0;
2367 }
2368 }
2369 }
2370 }
2371
2372 return 0;
2373 }
2374
mxf_add_metadata_stream(MXFContext * mxf,MXFTrack * track)2375 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2376 {
2377 MXFStructuralComponent *component = NULL;
2378 const MXFCodecUL *codec_ul = NULL;
2379 MXFPackage tmp_package;
2380 AVStream *st;
2381 int j;
2382
2383 for (j = 0; j < track->sequence->structural_components_count; j++) {
2384 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2385 if (!component)
2386 continue;
2387 break;
2388 }
2389 if (!component)
2390 return 0;
2391
2392 st = avformat_new_stream(mxf->fc, NULL);
2393 if (!st) {
2394 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2395 return AVERROR(ENOMEM);
2396 }
2397
2398 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2399 st->codecpar->codec_id = AV_CODEC_ID_NONE;
2400 st->id = track->track_id;
2401
2402 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2403 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2404 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2405 if (track->name && track->name[0])
2406 av_dict_set(&st->metadata, "track_name", track->name, 0);
2407
2408 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2409 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2410 return 0;
2411 }
2412
mxf_get_color_range(MXFContext * mxf,MXFDescriptor * descriptor)2413 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2414 {
2415 if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2416 /* CDCI range metadata */
2417 if (!descriptor->component_depth)
2418 return AVCOL_RANGE_UNSPECIFIED;
2419 if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2420 descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2421 (descriptor->color_range == (1<<descriptor->component_depth) ||
2422 descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2423 return AVCOL_RANGE_JPEG;
2424 if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2425 descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2426 descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2427 descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2428 return AVCOL_RANGE_MPEG;
2429 avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2430 descriptor->color_range, descriptor->black_ref_level,
2431 descriptor->white_ref_level, descriptor->component_depth);
2432 }
2433
2434 return AVCOL_RANGE_UNSPECIFIED;
2435 }
2436
is_pcm(enum AVCodecID codec_id)2437 static int is_pcm(enum AVCodecID codec_id)
2438 {
2439 /* we only care about "normal" PCM codecs until we get samples */
2440 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2441 }
2442
set_language(AVFormatContext * s,const char * rfc5646,AVDictionary ** met)2443 static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2444 {
2445 // language abbr should contain at least 2 chars
2446 if (rfc5646 && strlen(rfc5646) > 1) {
2447 char primary_tag[4] =
2448 {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2449
2450 const char *iso6392 = ff_convert_lang_to(primary_tag,
2451 AV_LANG_ISO639_2_BIBL);
2452 if (iso6392)
2453 return(av_dict_set(met, "language", iso6392, 0));
2454 }
2455 return 0;
2456 }
2457
find_mca_link_id(MXFContext * mxf,enum MXFMetadataSetType type,UID * mca_link_id)2458 static MXFMCASubDescriptor *find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
2459 {
2460 for (int k = 0; k < mxf->metadata_sets_count; k++) {
2461 MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mxf->metadata_sets[k];
2462 if (group->meta.type == type && !memcmp(&group->mca_link_id, mca_link_id, 16))
2463 return group;
2464 }
2465 return NULL;
2466 }
2467
parse_mca_labels(MXFContext * mxf,MXFTrack * source_track,MXFDescriptor * descriptor,AVStream * st)2468 static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2469 {
2470 uint64_t routing[FF_SANE_NB_CHANNELS] = {0};
2471 char *language = NULL;
2472 int ambigous_language = 0;
2473 enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2474 int ambigous_service_type = 0;
2475 int has_channel_label = 0;
2476
2477 for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2478 char *channel_language;
2479
2480 MXFMCASubDescriptor *label = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], AudioChannelLabelSubDescriptor);
2481 if (label == NULL)
2482 continue;
2483
2484 has_channel_label = 1;
2485 for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2486 if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2487 int target_channel = label->mca_channel_id;
2488 if (target_channel == 0 && descriptor->channels == 1)
2489 target_channel = 1;
2490 if (target_channel <= 0 || target_channel > descriptor->channels) {
2491 av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2492 return AVERROR_INVALIDDATA;
2493 }
2494 routing[target_channel - 1] = channel_ordering->layout_mask;
2495 if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2496 service_type = channel_ordering->service_type;
2497 else if (service_type != channel_ordering->service_type)
2498 ambigous_service_type = 1;
2499 break;
2500 }
2501 }
2502
2503 channel_language = label->language;
2504 if (!channel_language) {
2505 MXFMCASubDescriptor *group = find_mca_link_id(mxf, SoundfieldGroupLabelSubDescriptor, &label->soundfield_group_link_id);
2506 if (group) {
2507 channel_language = group->language;
2508 if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2509 MXFMCASubDescriptor *supergroup = find_mca_link_id(mxf, GroupOfSoundfieldGroupsLabelSubDescriptor,
2510 group->group_of_soundfield_groups_link_id_refs);
2511 if (supergroup)
2512 channel_language = supergroup->language;
2513 }
2514 }
2515 }
2516 if (channel_language) {
2517 if (language && strcmp(language, channel_language))
2518 ambigous_language = 1;
2519 else
2520 language = channel_language;
2521 }
2522 }
2523
2524 if (language && !ambigous_language) {
2525 int ret = set_language(mxf->fc, language, &st->metadata);
2526 if (ret < 0)
2527 return ret;
2528 }
2529
2530 if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2531 enum AVAudioServiceType *ast;
2532 uint8_t* side_data = av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE, sizeof(*ast));
2533 if (!side_data)
2534 return AVERROR(ENOMEM);
2535 ast = (enum AVAudioServiceType*)side_data;
2536 *ast = service_type;
2537 }
2538
2539 if (has_channel_label) {
2540 uint64_t channel_layout = 0;
2541 int ret;
2542
2543 for (int i = 0; i < descriptor->channels; i++) {
2544 if (!routing[i]) {
2545 av_log(mxf->fc, AV_LOG_WARNING, "Designation of audio channel %d in stream #%d is unknown or unsupported, "
2546 "falling back to unknown channel layout\n", st->index, i);
2547 return 0;
2548 }
2549 if (channel_layout & routing[i]) {
2550 char buf[32];
2551 av_channel_name(buf, sizeof(buf), routing[i]);
2552 av_log(mxf->fc, AV_LOG_WARNING, "%s audio channel is used multiple times in stream #%d, "
2553 "falling back to unknown channel layout\n",
2554 buf, st->index);
2555 return 0;
2556 }
2557 if (routing[i] < channel_layout) {
2558 av_log(mxf->fc, AV_LOG_WARNING, "stream #%d is not in in native channel order, "
2559 "falling back to unknown channel layout\n", st->index);
2560 return 0;
2561 }
2562 channel_layout |= routing[i];
2563 }
2564
2565 av_assert0(descriptor->channels == av_popcount64(channel_layout));
2566
2567 ret = av_channel_layout_from_mask(&st->codecpar->ch_layout, channel_layout);
2568 if (ret < 0)
2569 return ret;
2570 }
2571
2572 return 0;
2573 }
2574
mxf_parse_structural_metadata(MXFContext * mxf)2575 static int mxf_parse_structural_metadata(MXFContext *mxf)
2576 {
2577 MXFPackage *material_package = NULL;
2578 int i, j, k, ret;
2579
2580 av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2581 /* TODO: handle multiple material packages (OP3x) */
2582 for (i = 0; i < mxf->packages_count; i++) {
2583 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2584 if (material_package) break;
2585 }
2586 if (!material_package) {
2587 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2588 return AVERROR_INVALIDDATA;
2589 }
2590
2591 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2592 if (material_package->name && material_package->name[0])
2593 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2594 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2595
2596 for (i = 0; i < material_package->tracks_count; i++) {
2597 MXFPackage *source_package = NULL;
2598 MXFTrack *material_track = NULL;
2599 MXFTrack *source_track = NULL;
2600 MXFTrack *temp_track = NULL;
2601 MXFDescriptor *descriptor = NULL;
2602 MXFStructuralComponent *component = NULL;
2603 MXFTimecodeComponent *mxf_tc = NULL;
2604 UID *essence_container_ul = NULL;
2605 const MXFCodecUL *codec_ul = NULL;
2606 const MXFCodecUL *container_ul = NULL;
2607 const MXFCodecUL *pix_fmt_ul = NULL;
2608 AVStream *st;
2609 FFStream *sti;
2610 AVTimecode tc;
2611 int flags;
2612
2613 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2614 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2615 continue;
2616 }
2617
2618 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2619 mxf_tc = (MXFTimecodeComponent*)component;
2620 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2621 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2622 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2623 }
2624 }
2625
2626 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2627 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2628 continue;
2629 }
2630
2631 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2632 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2633 if (!component)
2634 continue;
2635
2636 mxf_tc = (MXFTimecodeComponent*)component;
2637 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2638 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2639 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2640 break;
2641 }
2642 }
2643
2644 /* TODO: handle multiple source clips, only finds first valid source clip */
2645 if(material_track->sequence->structural_components_count > 1)
2646 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2647 material_track->track_id, material_track->sequence->structural_components_count);
2648
2649 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2650 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2651 if (!component)
2652 continue;
2653
2654 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2655 if (!source_package) {
2656 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2657 continue;
2658 }
2659 for (k = 0; k < source_package->tracks_count; k++) {
2660 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2661 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2662 ret = AVERROR_INVALIDDATA;
2663 goto fail_and_free;
2664 }
2665 if (temp_track->track_id == component->source_track_id) {
2666 source_track = temp_track;
2667 break;
2668 }
2669 }
2670 if (!source_track) {
2671 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2672 break;
2673 }
2674
2675 for (k = 0; k < mxf->essence_container_data_count; k++) {
2676 MXFEssenceContainerData *essence_data;
2677
2678 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2679 av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2680 continue;
2681 }
2682 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2683 source_track->body_sid = essence_data->body_sid;
2684 source_track->index_sid = essence_data->index_sid;
2685 break;
2686 }
2687 }
2688
2689 if(source_track && component)
2690 break;
2691 }
2692 if (!source_track || !component || !source_package) {
2693 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2694 goto fail_and_free;
2695 continue;
2696 }
2697
2698 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2699 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2700 ret = AVERROR_INVALIDDATA;
2701 goto fail_and_free;
2702 }
2703
2704 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2705 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2706 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2707 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2708 continue;
2709 }
2710
2711 st = avformat_new_stream(mxf->fc, NULL);
2712 if (!st) {
2713 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2714 ret = AVERROR(ENOMEM);
2715 goto fail_and_free;
2716 }
2717 sti = ffstream(st);
2718 st->id = material_track->track_id;
2719 st->priv_data = source_track;
2720
2721 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2722 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2723
2724 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2725 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2726 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2727 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2728 else
2729 source_track->original_duration = st->duration = component->duration;
2730
2731 if (st->duration == -1)
2732 st->duration = AV_NOPTS_VALUE;
2733 st->start_time = component->start_position;
2734 if (material_track->edit_rate.num <= 0 ||
2735 material_track->edit_rate.den <= 0) {
2736 av_log(mxf->fc, AV_LOG_WARNING,
2737 "Invalid edit rate (%d/%d) found on stream #%d, "
2738 "defaulting to 25/1\n",
2739 material_track->edit_rate.num,
2740 material_track->edit_rate.den, st->index);
2741 material_track->edit_rate = (AVRational){25, 1};
2742 }
2743 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2744
2745 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2746 * the former is accessible via st->priv_data */
2747 source_track->edit_rate = material_track->edit_rate;
2748
2749 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2750 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2751 st->codecpar->codec_type = codec_ul->id;
2752
2753 if (!descriptor) {
2754 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2755 continue;
2756 }
2757 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2758 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2759 essence_container_ul = &descriptor->essence_container_ul;
2760 source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2761 if (source_track->wrapping == UnknownWrapped)
2762 av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2763 /* HACK: replacing the original key with mxf_encrypted_essence_container
2764 * is not allowed according to s429-6, try to find correct information anyway */
2765 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2766 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2767 for (k = 0; k < mxf->metadata_sets_count; k++) {
2768 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2769 if (metadata->type == CryptoContext) {
2770 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2771 break;
2772 }
2773 }
2774 }
2775
2776 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2777 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2778 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2779 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2780 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2781 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2782 }
2783
2784 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2785 avcodec_get_name(st->codecpar->codec_id));
2786 for (k = 0; k < 16; k++) {
2787 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2788 descriptor->essence_codec_ul[k]);
2789 if (!(k+1 & 19) || k == 5)
2790 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2791 }
2792 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2793
2794 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2795 if (source_package->name && source_package->name[0])
2796 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2797 if (material_track->name && material_track->name[0])
2798 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2799
2800 mxf_parse_physical_source_package(mxf, source_track, st);
2801
2802 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2803 source_track->intra_only = mxf_is_intra_only(descriptor);
2804 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2805 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2806 st->codecpar->codec_id = container_ul->id;
2807 st->codecpar->width = descriptor->width;
2808 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2809 switch (descriptor->frame_layout) {
2810 case FullFrame:
2811 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2812 break;
2813 case OneField:
2814 /* Every other line is stored and needs to be duplicated. */
2815 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2816 break; /* The correct thing to do here is fall through, but by breaking we might be
2817 able to decode some streams at half the vertical resolution, rather than not al all.
2818 It's also for compatibility with the old behavior. */
2819 case MixedFields:
2820 break;
2821 case SegmentedFrame:
2822 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2823 case SeparateFields:
2824 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2825 descriptor->video_line_map[0], descriptor->video_line_map[1],
2826 descriptor->field_dominance);
2827 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2828 /* Detect coded field order from VideoLineMap:
2829 * (even, even) => bottom field coded first
2830 * (even, odd) => top field coded first
2831 * (odd, even) => top field coded first
2832 * (odd, odd) => bottom field coded first
2833 */
2834 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2835 switch (descriptor->field_dominance) {
2836 case MXF_FIELD_DOMINANCE_DEFAULT:
2837 case MXF_FIELD_DOMINANCE_FF:
2838 st->codecpar->field_order = AV_FIELD_TT;
2839 break;
2840 case MXF_FIELD_DOMINANCE_FL:
2841 st->codecpar->field_order = AV_FIELD_TB;
2842 break;
2843 default:
2844 avpriv_request_sample(mxf->fc,
2845 "Field dominance %d support",
2846 descriptor->field_dominance);
2847 }
2848 } else {
2849 switch (descriptor->field_dominance) {
2850 case MXF_FIELD_DOMINANCE_DEFAULT:
2851 case MXF_FIELD_DOMINANCE_FF:
2852 st->codecpar->field_order = AV_FIELD_BB;
2853 break;
2854 case MXF_FIELD_DOMINANCE_FL:
2855 st->codecpar->field_order = AV_FIELD_BT;
2856 break;
2857 default:
2858 avpriv_request_sample(mxf->fc,
2859 "Field dominance %d support",
2860 descriptor->field_dominance);
2861 }
2862 }
2863 }
2864 /* Turn field height into frame height. */
2865 st->codecpar->height *= 2;
2866 break;
2867 default:
2868 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2869 }
2870
2871 if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2872 switch (descriptor->essence_codec_ul[14]) {
2873 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2874 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2875 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2876 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2877 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2878 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2879 }
2880 }
2881
2882 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2883 st->codecpar->format = descriptor->pix_fmt;
2884 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2885 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2886 &descriptor->essence_codec_ul);
2887 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2888 if (st->codecpar->format== AV_PIX_FMT_NONE) {
2889 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2890 &descriptor->essence_codec_ul)->id;
2891 if (!st->codecpar->codec_tag) {
2892 /* support files created before RP224v10 by defaulting to UYVY422
2893 if subsampling is 4:2:2 and component depth is 8-bit */
2894 if (descriptor->horiz_subsampling == 2 &&
2895 descriptor->vert_subsampling == 1 &&
2896 descriptor->component_depth == 8) {
2897 st->codecpar->format = AV_PIX_FMT_UYVY422;
2898 }
2899 }
2900 }
2901 }
2902 }
2903 sti->need_parsing = AVSTREAM_PARSE_HEADERS;
2904 if (material_track->sequence->origin) {
2905 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2906 }
2907 if (source_track->sequence->origin) {
2908 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2909 }
2910 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2911 sti->display_aspect_ratio = descriptor->aspect_ratio;
2912 st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2913 st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2914 st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2915 st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2916 if (descriptor->mastering) {
2917 ret = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2918 (uint8_t *)descriptor->mastering,
2919 sizeof(*descriptor->mastering));
2920 if (ret < 0)
2921 goto fail_and_free;
2922 descriptor->mastering = NULL;
2923 }
2924 if (descriptor->coll) {
2925 ret = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2926 (uint8_t *)descriptor->coll,
2927 descriptor->coll_size);
2928 if (ret < 0)
2929 goto fail_and_free;
2930 descriptor->coll = NULL;
2931 }
2932 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2933 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2934 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2935 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))
2936 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2937 st->codecpar->ch_layout.nb_channels = descriptor->channels;
2938
2939 if (descriptor->sample_rate.den > 0) {
2940 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2941 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2942 } else {
2943 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2944 "found for stream #%d, time base forced to 1/48000\n",
2945 descriptor->sample_rate.num, descriptor->sample_rate.den,
2946 st->index);
2947 avpriv_set_pts_info(st, 64, 1, 48000);
2948 }
2949
2950 /* if duration is set, rescale it from EditRate to SampleRate */
2951 if (st->duration != AV_NOPTS_VALUE)
2952 st->duration = av_rescale_q(st->duration,
2953 av_inv_q(material_track->edit_rate),
2954 st->time_base);
2955
2956 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2957 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2958 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2959 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2960 else if (descriptor->bits_per_sample == 32)
2961 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2962 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2963 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2964 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2965 else if (descriptor->bits_per_sample == 32)
2966 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2967 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2968 sti->need_parsing = AVSTREAM_PARSE_FULL;
2969 }
2970 st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2971
2972 if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
2973 av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
2974 return AVERROR_INVALIDDATA;
2975 }
2976
2977 ret = parse_mca_labels(mxf, source_track, descriptor, st);
2978 if (ret < 0)
2979 return ret;
2980 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2981 enum AVMediaType type;
2982 container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2983 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2984 st->codecpar->codec_id = container_ul->id;
2985 type = avcodec_get_type(st->codecpar->codec_id);
2986 if (type == AVMEDIA_TYPE_SUBTITLE)
2987 st->codecpar->codec_type = type;
2988 if (container_ul->desc)
2989 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2990 if (mxf->eia608_extract &&
2991 !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2992 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2993 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
2994 }
2995 }
2996 if (descriptor->extradata) {
2997 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2998 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2999 }
3000 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3001 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
3002 &descriptor->essence_codec_ul)->id;
3003 if (coded_width)
3004 st->codecpar->width = coded_width;
3005 ret = ff_generate_avci_extradata(st);
3006 if (ret < 0)
3007 return ret;
3008 }
3009 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
3010 /* TODO: decode timestamps */
3011 sti->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
3012 }
3013 }
3014
3015 for (int i = 0; i < mxf->fc->nb_streams; i++) {
3016 MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
3017 if (track1 && track1->body_sid) {
3018 for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
3019 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
3020 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
3021 if (track1->wrapping == UnknownWrapped)
3022 track1->wrapping = track2->wrapping;
3023 else if (track2->wrapping == UnknownWrapped)
3024 track2->wrapping = track1->wrapping;
3025 else
3026 av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
3027 "with different wrapping\n", i, j, track1->body_sid);
3028 }
3029 }
3030 }
3031 }
3032
3033 ret = 0;
3034 fail_and_free:
3035 return ret;
3036 }
3037
mxf_timestamp_to_int64(uint64_t timestamp)3038 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
3039 {
3040 struct tm time = { 0 };
3041 int msecs;
3042 time.tm_year = (timestamp >> 48) - 1900;
3043 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
3044 time.tm_mday = (timestamp >> 32 & 0xFF);
3045 time.tm_hour = (timestamp >> 24 & 0xFF);
3046 time.tm_min = (timestamp >> 16 & 0xFF);
3047 time.tm_sec = (timestamp >> 8 & 0xFF);
3048 msecs = (timestamp & 0xFF) * 4;
3049
3050 /* Clip values for legacy reasons. Maybe we should return error instead? */
3051 time.tm_mon = av_clip(time.tm_mon, 0, 11);
3052 time.tm_mday = av_clip(time.tm_mday, 1, 31);
3053 time.tm_hour = av_clip(time.tm_hour, 0, 23);
3054 time.tm_min = av_clip(time.tm_min, 0, 59);
3055 time.tm_sec = av_clip(time.tm_sec, 0, 59);
3056 msecs = av_clip(msecs, 0, 999);
3057
3058 return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
3059 }
3060
3061 #define SET_STR_METADATA(pb, name, str) do { \
3062 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
3063 return ret; \
3064 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3065 } while (0)
3066
3067 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
3068 major = avio_rb16(pb); \
3069 minor = avio_rb16(pb); \
3070 tertiary = avio_rb16(pb); \
3071 patch = avio_rb16(pb); \
3072 release = avio_rb16(pb); \
3073 if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
3074 return ret; \
3075 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3076 } while (0)
3077
3078 #define SET_UID_METADATA(pb, name, var, str) do { \
3079 char uuid_str[2 * AV_UUID_LEN + 4 + 1]; \
3080 avio_read(pb, var, 16); \
3081 av_uuid_unparse(uid, uuid_str); \
3082 av_dict_set(&s->metadata, name, uuid_str, 0); \
3083 } while (0)
3084
3085 #define SET_TS_METADATA(pb, name, var, str) do { \
3086 var = avio_rb64(pb); \
3087 if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
3088 return ret; \
3089 } while (0)
3090
mxf_read_identification_metadata(void * arg,AVIOContext * pb,int tag,int size,UID _uid,int64_t klv_offset)3091 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
3092 {
3093 MXFContext *mxf = arg;
3094 AVFormatContext *s = mxf->fc;
3095 int ret;
3096 UID uid = { 0 };
3097 char *str = NULL;
3098 uint64_t ts;
3099 uint16_t major, minor, tertiary, patch, release;
3100 switch (tag) {
3101 case 0x3C01:
3102 SET_STR_METADATA(pb, "company_name", str);
3103 break;
3104 case 0x3C02:
3105 SET_STR_METADATA(pb, "product_name", str);
3106 break;
3107 case 0x3C03:
3108 SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
3109 break;
3110 case 0x3C04:
3111 SET_STR_METADATA(pb, "product_version", str);
3112 break;
3113 case 0x3C05:
3114 SET_UID_METADATA(pb, "product_uid", uid, str);
3115 break;
3116 case 0x3C06:
3117 SET_TS_METADATA(pb, "modification_date", ts, str);
3118 break;
3119 case 0x3C07:
3120 SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
3121 break;
3122 case 0x3C08:
3123 SET_STR_METADATA(pb, "application_platform", str);
3124 break;
3125 case 0x3C09:
3126 SET_UID_METADATA(pb, "generation_uid", uid, str);
3127 break;
3128 case 0x3C0A:
3129 SET_UID_METADATA(pb, "uid", uid, str);
3130 break;
3131 }
3132 return 0;
3133 }
3134
mxf_read_preface_metadata(void * arg,AVIOContext * pb,int tag,int size,UID uid,int64_t klv_offset)3135 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
3136 {
3137 MXFContext *mxf = arg;
3138 AVFormatContext *s = mxf->fc;
3139 int ret;
3140 char *str = NULL;
3141
3142 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
3143 SET_STR_METADATA(pb, "project_name", str);
3144 }
3145 return 0;
3146 }
3147
3148 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
3149 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
3150 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
3151 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
3152 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
3153 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
3154 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
3155 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
3156 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
3157 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
3158 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
3159 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
3160 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
3161 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
3162 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
3163 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
3164 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
3165 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
3166 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
3167 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
3168 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
3169 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
3170 { { 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 */
3171 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
3172 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
3173 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
3174 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
3175 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
3176 { { 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 */
3177 { { 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 */
3178 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
3179 { { 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 */
3180 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6b,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), AudioChannelLabelSubDescriptor },
3181 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6c,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), SoundfieldGroupLabelSubDescriptor },
3182 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6d,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor },
3183 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
3184 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
3185 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
3186 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
3187 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
3188 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
3189 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
3190 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
3191 };
3192
mxf_metadataset_init(MXFMetadataSet * ctx,enum MXFMetadataSetType type,MXFPartition * partition)3193 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
3194 {
3195 ctx->type = type;
3196 ctx->partition_score = partition_score(partition);
3197 switch (type){
3198 case MultipleDescriptor:
3199 case Descriptor:
3200 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
3201 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
3202 break;
3203 default:
3204 break;
3205 }
3206 return 0;
3207 }
3208
mxf_read_local_tags(MXFContext * mxf,KLVPacket * klv,MXFMetadataReadFunc * read_child,int ctx_size,enum MXFMetadataSetType type)3209 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
3210 {
3211 AVIOContext *pb = mxf->fc->pb;
3212 uint64_t klv_end = avio_tell(pb) + klv->length;
3213 MXFMetadataSet *meta;
3214 void *ctx;
3215
3216 if (ctx_size) {
3217 meta = av_mallocz(ctx_size);
3218 if (!meta)
3219 return AVERROR(ENOMEM);
3220 ctx = meta;
3221 mxf_metadataset_init(meta, type, mxf->current_partition);
3222 } else {
3223 meta = NULL;
3224 ctx = mxf;
3225 }
3226 while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
3227 int ret;
3228 int tag = avio_rb16(pb);
3229 int size = avio_rb16(pb); /* KLV specified by 0x53 */
3230 int64_t next = avio_tell(pb);
3231 UID uid = {0};
3232 if (next < 0 || next > INT64_MAX - size) {
3233 if (meta) {
3234 mxf_free_metadataset(&meta, 1);
3235 }
3236 return next < 0 ? next : AVERROR_INVALIDDATA;
3237 }
3238 next += size;
3239
3240 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
3241 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
3242 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
3243 continue;
3244 }
3245 if (tag > 0x7FFF) { /* dynamic tag */
3246 int i;
3247 for (i = 0; i < mxf->local_tags_count; i++) {
3248 int local_tag = AV_RB16(mxf->local_tags+i*18);
3249 if (local_tag == tag) {
3250 memcpy(uid, mxf->local_tags+i*18+2, 16);
3251 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
3252 PRINT_KEY(mxf->fc, "uid", uid);
3253 }
3254 }
3255 }
3256 if (meta && tag == 0x3C0A) {
3257 avio_read(pb, meta->uid, 16);
3258 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
3259 if (meta) {
3260 mxf_free_metadataset(&meta, 1);
3261 }
3262 return ret;
3263 }
3264
3265 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
3266 * it extending past the end of the KLV though (zzuf5.mxf). */
3267 if (avio_tell(pb) > klv_end) {
3268 if (meta) {
3269 mxf_free_metadataset(&meta, 1);
3270 }
3271
3272 av_log(mxf->fc, AV_LOG_ERROR,
3273 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
3274 tag, klv->offset);
3275 return AVERROR_INVALIDDATA;
3276 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
3277 avio_seek(pb, next, SEEK_SET);
3278 }
3279 return meta ? mxf_add_metadata_set(mxf, &meta) : 0;
3280 }
3281
3282 /**
3283 * Matches any partition pack key, in other words:
3284 * - HeaderPartition
3285 * - BodyPartition
3286 * - FooterPartition
3287 * @return non-zero if the key is a partition pack key, zero otherwise
3288 */
mxf_is_partition_pack_key(UID key)3289 static int mxf_is_partition_pack_key(UID key)
3290 {
3291 //NOTE: this is a little lax since it doesn't constraint key[14]
3292 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
3293 key[13] >= 2 && key[13] <= 4;
3294 }
3295
3296 /**
3297 * Parses a metadata KLV
3298 * @return <0 on error, 0 otherwise
3299 */
mxf_parse_klv(MXFContext * mxf,KLVPacket klv,MXFMetadataReadFunc * read,int ctx_size,enum MXFMetadataSetType type)3300 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
3301 int ctx_size, enum MXFMetadataSetType type)
3302 {
3303 AVFormatContext *s = mxf->fc;
3304 int res;
3305 if (klv.key[5] == 0x53) {
3306 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
3307 } else {
3308 uint64_t next = avio_tell(s->pb) + klv.length;
3309 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
3310
3311 /* only seek forward, else this can loop for a long time */
3312 if (avio_tell(s->pb) > next) {
3313 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
3314 klv.offset);
3315 return AVERROR_INVALIDDATA;
3316 }
3317
3318 avio_seek(s->pb, next, SEEK_SET);
3319 }
3320 if (res < 0) {
3321 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3322 return res;
3323 }
3324 return 0;
3325 }
3326
3327 /**
3328 * Seeks to the previous partition and parses it, if possible
3329 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3330 */
mxf_seek_to_previous_partition(MXFContext * mxf)3331 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3332 {
3333 AVIOContext *pb = mxf->fc->pb;
3334 KLVPacket klv;
3335 int64_t current_partition_ofs;
3336 int ret;
3337
3338 if (!mxf->current_partition ||
3339 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3340 return 0; /* we've parsed all partitions */
3341
3342 /* seek to previous partition */
3343 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3344 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3345 mxf->current_partition = NULL;
3346
3347 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3348
3349 /* Make sure this is actually a PartitionPack, and if so parse it.
3350 * See deadlock2.mxf
3351 */
3352 if ((ret = klv_read_packet(mxf, &klv, pb)) < 0) {
3353 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3354 return ret;
3355 }
3356
3357 if (!mxf_is_partition_pack_key(klv.key)) {
3358 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3359 return AVERROR_INVALIDDATA;
3360 }
3361
3362 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3363 * can point to just before the current partition, causing klv_read_packet()
3364 * to sync back up to it. See deadlock3.mxf
3365 */
3366 if (klv.offset >= current_partition_ofs) {
3367 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3368 PRIx64 " indirectly points to itself\n", current_partition_ofs);
3369 return AVERROR_INVALIDDATA;
3370 }
3371
3372 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3373 return ret;
3374
3375 return 1;
3376 }
3377
3378 /**
3379 * Called when essence is encountered
3380 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3381 */
mxf_parse_handle_essence(MXFContext * mxf)3382 static int mxf_parse_handle_essence(MXFContext *mxf)
3383 {
3384 AVIOContext *pb = mxf->fc->pb;
3385 int64_t ret;
3386
3387 if (mxf->parsing_backward) {
3388 return mxf_seek_to_previous_partition(mxf);
3389 } else {
3390 if (!mxf->footer_partition) {
3391 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3392 return 0;
3393 }
3394
3395 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3396
3397 /* remember where we were so we don't end up seeking further back than this */
3398 mxf->last_forward_tell = avio_tell(pb);
3399
3400 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3401 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3402 return -1;
3403 }
3404
3405 /* seek to FooterPartition and parse backward */
3406 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3407 av_log(mxf->fc, AV_LOG_ERROR,
3408 "failed to seek to FooterPartition @ 0x%" PRIx64
3409 " (%"PRId64") - partial file?\n",
3410 mxf->run_in + mxf->footer_partition, ret);
3411 return ret;
3412 }
3413
3414 mxf->current_partition = NULL;
3415 mxf->parsing_backward = 1;
3416 }
3417
3418 return 1;
3419 }
3420
3421 /**
3422 * Called when the next partition or EOF is encountered
3423 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3424 */
mxf_parse_handle_partition_or_eof(MXFContext * mxf)3425 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3426 {
3427 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3428 }
3429
mxf_get_wrapping_by_body_sid(AVFormatContext * s,int body_sid)3430 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3431 {
3432 for (int i = 0; i < s->nb_streams; i++) {
3433 MXFTrack *track = s->streams[i]->priv_data;
3434 if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3435 return track->wrapping;
3436 }
3437 return UnknownWrapped;
3438 }
3439
3440 /**
3441 * Figures out the proper offset and length of the essence container in each partition
3442 */
mxf_compute_essence_containers(AVFormatContext * s)3443 static void mxf_compute_essence_containers(AVFormatContext *s)
3444 {
3445 MXFContext *mxf = s->priv_data;
3446 int x;
3447
3448 for (x = 0; x < mxf->partitions_count; x++) {
3449 MXFPartition *p = &mxf->partitions[x];
3450 MXFWrappingScheme wrapping;
3451
3452 if (!p->body_sid)
3453 continue; /* BodySID == 0 -> no essence */
3454
3455 /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3456 * otherwise we point essence_offset at the key of the first essence KLV.
3457 */
3458
3459 wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3460
3461 if (wrapping == ClipWrapped) {
3462 p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3463 p->essence_length = p->first_essence_klv.length;
3464 } else {
3465 p->essence_offset = p->first_essence_klv.offset;
3466
3467 /* essence container spans to the next partition */
3468 if (x < mxf->partitions_count - 1)
3469 p->essence_length = mxf->partitions[x+1].pack_ofs - mxf->run_in - p->essence_offset;
3470
3471 if (p->essence_length < 0) {
3472 /* next ThisPartition < essence_offset */
3473 p->essence_length = 0;
3474 av_log(mxf->fc, AV_LOG_ERROR,
3475 "partition %i: bad ThisPartition = %"PRIX64"\n",
3476 x+1, mxf->partitions[x+1].pack_ofs - mxf->run_in);
3477 }
3478 }
3479 }
3480 }
3481
mxf_find_index_table(MXFContext * mxf,int index_sid)3482 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3483 {
3484 int i;
3485 for (i = 0; i < mxf->nb_index_tables; i++)
3486 if (mxf->index_tables[i].index_sid == index_sid)
3487 return &mxf->index_tables[i];
3488 return NULL;
3489 }
3490
3491 /**
3492 * Deal with the case where for some audio atoms EditUnitByteCount is
3493 * very small (2, 4..). In those cases we should read more than one
3494 * sample per call to mxf_read_packet().
3495 */
mxf_compute_edit_units_per_packet(MXFContext * mxf,AVStream * st)3496 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3497 {
3498 MXFTrack *track = st->priv_data;
3499 MXFIndexTable *t;
3500
3501 if (!track)
3502 return;
3503 track->edit_units_per_packet = 1;
3504 if (track->wrapping != ClipWrapped)
3505 return;
3506
3507 t = mxf_find_index_table(mxf, track->index_sid);
3508
3509 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3510 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3511 !is_pcm(st->codecpar->codec_id) ||
3512 !t ||
3513 t->nb_segments != 1 ||
3514 t->segments[0]->edit_unit_byte_count >= 32)
3515 return;
3516
3517 /* arbitrarily default to 48 kHz PAL audio frame size */
3518 /* TODO: We could compute this from the ratio between the audio
3519 * and video edit rates for 48 kHz NTSC we could use the
3520 * 1802-1802-1802-1802-1801 pattern. */
3521 track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3522 }
3523
3524 /**
3525 * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3526 */
mxf_handle_missing_index_segment(MXFContext * mxf,AVStream * st)3527 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3528 {
3529 MXFTrack *track = st->priv_data;
3530 MXFIndexTableSegment *segment = NULL;
3531 MXFPartition *p = NULL;
3532 int essence_partition_count = 0;
3533 int edit_unit_byte_count = 0;
3534 int i, ret;
3535
3536 if (!track || track->wrapping != ClipWrapped)
3537 return 0;
3538
3539 /* check if track already has an IndexTableSegment */
3540 for (i = 0; i < mxf->metadata_sets_count; i++) {
3541 if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3542 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3543 if (s->body_sid == track->body_sid)
3544 return 0;
3545 }
3546 }
3547
3548 /* find the essence partition */
3549 for (i = 0; i < mxf->partitions_count; i++) {
3550 /* BodySID == 0 -> no essence */
3551 if (mxf->partitions[i].body_sid != track->body_sid)
3552 continue;
3553
3554 p = &mxf->partitions[i];
3555 essence_partition_count++;
3556 }
3557
3558 /* only handle files with a single essence partition */
3559 if (essence_partition_count != 1)
3560 return 0;
3561
3562 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3563 edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) *
3564 st->codecpar->ch_layout.nb_channels) >> 3;
3565 } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3566 edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3567 }
3568
3569 if (edit_unit_byte_count <= 0)
3570 return 0;
3571
3572 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);
3573
3574 if (!(segment = av_mallocz(sizeof(*segment))))
3575 return AVERROR(ENOMEM);
3576
3577 if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3578 return ret;
3579
3580 /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3581 * using the same SID for index is forbidden in MXF. */
3582 if (!track->index_sid)
3583 track->index_sid = track->body_sid;
3584
3585 segment->meta.type = IndexTableSegment;
3586 /* stream will be treated as small EditUnitByteCount */
3587 segment->edit_unit_byte_count = edit_unit_byte_count;
3588 segment->index_start_position = 0;
3589 segment->index_duration = st->duration;
3590 segment->index_edit_rate = av_inv_q(st->time_base);
3591 segment->index_sid = track->index_sid;
3592 segment->body_sid = p->body_sid;
3593 return 0;
3594 }
3595
mxf_read_random_index_pack(AVFormatContext * s)3596 static void mxf_read_random_index_pack(AVFormatContext *s)
3597 {
3598 MXFContext *mxf = s->priv_data;
3599 uint32_t length;
3600 int64_t file_size, max_rip_length, min_rip_length;
3601 KLVPacket klv;
3602
3603 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3604 return;
3605
3606 file_size = avio_size(s->pb);
3607
3608 /* S377m says to check the RIP length for "silly" values, without defining "silly".
3609 * The limit below assumes a file with nothing but partition packs and a RIP.
3610 * Before changing this, consider that a muxer may place each sample in its own partition.
3611 *
3612 * 105 is the size of the smallest possible PartitionPack
3613 * 12 is the size of each RIP entry
3614 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3615 */
3616 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3617 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3618
3619 /* We're only interested in RIPs with at least two entries.. */
3620 min_rip_length = 16+1+24+4;
3621
3622 /* See S377m section 11 */
3623 avio_seek(s->pb, file_size - 4, SEEK_SET);
3624 length = avio_rb32(s->pb);
3625
3626 if (length < min_rip_length || length > max_rip_length)
3627 goto end;
3628 avio_seek(s->pb, file_size - length, SEEK_SET);
3629 if (klv_read_packet(mxf, &klv, s->pb) < 0 ||
3630 !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3631 goto end;
3632 if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3633 av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3634 goto end;
3635 }
3636
3637 avio_skip(s->pb, klv.length - 12);
3638 mxf->footer_partition = avio_rb64(s->pb);
3639
3640 /* sanity check */
3641 if (mxf->run_in + mxf->footer_partition >= file_size) {
3642 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3643 mxf->footer_partition = 0;
3644 }
3645
3646 end:
3647 avio_seek(s->pb, mxf->run_in, SEEK_SET);
3648 }
3649
mxf_read_header(AVFormatContext * s)3650 static int mxf_read_header(AVFormatContext *s)
3651 {
3652 MXFContext *mxf = s->priv_data;
3653 KLVPacket klv;
3654 int64_t essence_offset = 0;
3655 int ret;
3656 int64_t run_in;
3657
3658 mxf->last_forward_tell = INT64_MAX;
3659
3660 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3661 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3662 return AVERROR_INVALIDDATA;
3663 }
3664 avio_seek(s->pb, -14, SEEK_CUR);
3665 mxf->fc = s;
3666 run_in = avio_tell(s->pb);
3667 if (run_in < 0 || run_in > RUN_IN_MAX)
3668 return AVERROR_INVALIDDATA;
3669 mxf->run_in = run_in;
3670
3671 mxf_read_random_index_pack(s);
3672
3673 while (!avio_feof(s->pb)) {
3674 const MXFMetadataReadTableEntry *metadata;
3675
3676 if (klv_read_packet(mxf, &klv, s->pb) < 0) {
3677 /* EOF - seek to previous partition or stop */
3678 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3679 break;
3680 else
3681 continue;
3682 }
3683
3684 PRINT_KEY(s, "read header", klv.key);
3685 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3686 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3687 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3688 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3689 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3690 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3691 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3692
3693 if (!mxf->current_partition) {
3694 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3695 return AVERROR_INVALIDDATA;
3696 }
3697
3698 if (!mxf->current_partition->first_essence_klv.offset)
3699 mxf->current_partition->first_essence_klv = klv;
3700
3701 if (!essence_offset)
3702 essence_offset = klv.offset;
3703
3704 /* seek to footer, previous partition or stop */
3705 if (mxf_parse_handle_essence(mxf) <= 0)
3706 break;
3707 continue;
3708 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3709 /* next partition pack - keep going, seek to previous partition or stop */
3710 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3711 break;
3712 else if (mxf->parsing_backward)
3713 continue;
3714 /* we're still parsing forward. proceed to parsing this partition pack */
3715 }
3716
3717 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3718 if (IS_KLV_KEY(klv.key, metadata->key)) {
3719 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3720 return ret;
3721 break;
3722 }
3723 }
3724 if (!metadata->read) {
3725 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3726 UID_ARG(klv.key));
3727 avio_skip(s->pb, klv.length);
3728 }
3729 }
3730 /* FIXME avoid seek */
3731 if (!essence_offset) {
3732 av_log(s, AV_LOG_ERROR, "no essence\n");
3733 return AVERROR_INVALIDDATA;
3734 }
3735 avio_seek(s->pb, essence_offset, SEEK_SET);
3736
3737 /* we need to do this before computing the index tables
3738 * to be able to fill in zero IndexDurations with st->duration */
3739 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3740 return ret;
3741
3742 for (int i = 0; i < s->nb_streams; i++)
3743 mxf_handle_missing_index_segment(mxf, s->streams[i]);
3744
3745 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3746 return ret;
3747
3748 if (mxf->nb_index_tables > 1) {
3749 /* TODO: look up which IndexSID to use via EssenceContainerData */
3750 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3751 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3752 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3753 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3754 return AVERROR_INVALIDDATA;
3755 }
3756
3757 mxf_compute_essence_containers(s);
3758
3759 for (int i = 0; i < s->nb_streams; i++)
3760 mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3761
3762 return 0;
3763 }
3764
3765 /* 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)3766 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3767 {
3768 int64_t a, b, m, offset;
3769 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3770
3771 if (!t || track->original_duration <= 0)
3772 return -1;
3773
3774 a = -1;
3775 b = track->original_duration;
3776
3777 while (b - a > 1) {
3778 m = (a + (uint64_t)b) >> 1;
3779 if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3780 return -1;
3781 if (offset < current_offset)
3782 a = m;
3783 else
3784 b = m;
3785 }
3786
3787 *edit_unit_out = b;
3788
3789 return 0;
3790 }
3791
mxf_compute_sample_count(MXFContext * mxf,AVStream * st,int64_t edit_unit)3792 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3793 int64_t edit_unit)
3794 {
3795 MXFTrack *track = st->priv_data;
3796 AVRational time_base = av_inv_q(track->edit_rate);
3797 AVRational sample_rate = av_inv_q(st->time_base);
3798
3799 // For non-audio sample_count equals current edit unit
3800 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3801 return edit_unit;
3802
3803 if ((sample_rate.num / sample_rate.den) == 48000) {
3804 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3805 } else {
3806 int64_t remainder = (sample_rate.num * (int64_t) time_base.num) %
3807 ( time_base.den * (int64_t)sample_rate.den);
3808 if (remainder)
3809 av_log(mxf->fc, AV_LOG_WARNING,
3810 "seeking detected on stream #%d with time base (%d/%d) and "
3811 "sample rate (%d/%d), audio pts won't be accurate.\n",
3812 st->index, time_base.num, time_base.den,
3813 sample_rate.num, sample_rate.den);
3814 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3815 }
3816 }
3817
3818 /**
3819 * Make sure track->sample_count is correct based on what offset we're currently at.
3820 * Also determine the next edit unit (or packet) offset.
3821 * @return next_ofs if OK, <0 on error
3822 */
mxf_set_current_edit_unit(MXFContext * mxf,AVStream * st,int64_t current_offset,int resync)3823 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3824 {
3825 int64_t next_ofs = -1;
3826 MXFTrack *track = st->priv_data;
3827 int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3828 int64_t new_edit_unit;
3829 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3830
3831 if (!t || track->wrapping == UnknownWrapped || edit_unit > INT64_MAX - track->edit_units_per_packet)
3832 return -1;
3833
3834 if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3835 (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3836 av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3837 return -1;
3838 }
3839
3840 /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3841 if (next_ofs > current_offset)
3842 return next_ofs;
3843
3844 if (!resync) {
3845 av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3846 return -1;
3847 }
3848
3849 if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3850 av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3851 return -1;
3852 }
3853
3854 new_edit_unit--;
3855 track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3856 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);
3857
3858 return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3859 }
3860
mxf_set_audio_pts(MXFContext * mxf,AVCodecParameters * par,AVPacket * pkt)3861 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3862 AVPacket *pkt)
3863 {
3864 AVStream *st = mxf->fc->streams[pkt->stream_index];
3865 MXFTrack *track = st->priv_data;
3866 int64_t bits_per_sample = par->bits_per_coded_sample;
3867
3868 if (!bits_per_sample)
3869 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3870
3871 pkt->pts = track->sample_count;
3872
3873 if (par->ch_layout.nb_channels <= 0 ||
3874 bits_per_sample <= 0 ||
3875 par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
3876 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);
3877 else
3878 track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
3879
3880 return 0;
3881 }
3882
mxf_set_pts(MXFContext * mxf,AVStream * st,AVPacket * pkt)3883 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3884 {
3885 AVCodecParameters *par = st->codecpar;
3886 MXFTrack *track = st->priv_data;
3887
3888 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3889 /* see if we have an index table to derive timestamps from */
3890 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3891
3892 if (t && track->sample_count < t->nb_ptses) {
3893 pkt->dts = track->sample_count + t->first_dts;
3894 pkt->pts = t->ptses[track->sample_count];
3895 } else if (track->intra_only) {
3896 /* intra-only -> PTS = EditUnit.
3897 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3898 pkt->pts = track->sample_count;
3899 }
3900 track->sample_count++;
3901 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3902 int ret = mxf_set_audio_pts(mxf, par, pkt);
3903 if (ret < 0)
3904 return ret;
3905 } else if (track) {
3906 pkt->dts = pkt->pts = track->sample_count;
3907 pkt->duration = 1;
3908 track->sample_count++;
3909 }
3910 return 0;
3911 }
3912
mxf_read_packet(AVFormatContext * s,AVPacket * pkt)3913 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3914 {
3915 KLVPacket klv;
3916 MXFContext *mxf = s->priv_data;
3917 int ret;
3918
3919 while (1) {
3920 int64_t max_data_size;
3921 int64_t pos = avio_tell(s->pb);
3922
3923 if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3924 mxf->current_klv_data = (KLVPacket){{0}};
3925 ret = klv_read_packet(mxf, &klv, s->pb);
3926 if (ret < 0)
3927 break;
3928 max_data_size = klv.length;
3929 pos = klv.next_klv - klv.length;
3930 PRINT_KEY(s, "read packet", klv.key);
3931 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3932 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3933 ret = mxf_decrypt_triplet(s, pkt, &klv);
3934 if (ret < 0) {
3935 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3936 return ret;
3937 }
3938 return 0;
3939 }
3940 } else {
3941 klv = mxf->current_klv_data;
3942 max_data_size = klv.next_klv - pos;
3943 }
3944 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3945 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3946 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3947 int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3948 int index = mxf_get_stream_index(s, &klv, body_sid);
3949 int64_t next_ofs;
3950 AVStream *st;
3951 MXFTrack *track;
3952
3953 if (index < 0) {
3954 av_log(s, AV_LOG_ERROR,
3955 "error getting stream index %"PRIu32"\n",
3956 AV_RB32(klv.key + 12));
3957 goto skip;
3958 }
3959
3960 st = s->streams[index];
3961 track = st->priv_data;
3962
3963 if (s->streams[index]->discard == AVDISCARD_ALL)
3964 goto skip;
3965
3966 next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3967
3968 if (track->wrapping != FrameWrapped) {
3969 int64_t size;
3970
3971 if (next_ofs <= 0) {
3972 // If we have no way to packetize the data, then return it in chunks...
3973 if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3974 ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
3975 avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3976 }
3977 size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3978 } else {
3979 if ((size = next_ofs - pos) <= 0) {
3980 av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3981 mxf->current_klv_data = (KLVPacket){{0}};
3982 return AVERROR_INVALIDDATA;
3983 }
3984 // We must not overread, because the next edit unit might be in another KLV
3985 if (size > max_data_size)
3986 size = max_data_size;
3987 }
3988
3989 mxf->current_klv_data = klv;
3990 klv.offset = pos;
3991 klv.length = size;
3992 klv.next_klv = klv.offset + klv.length;
3993 }
3994
3995 /* check for 8 channels AES3 element */
3996 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3997 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3998 pkt, klv.length);
3999 if (ret < 0) {
4000 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
4001 mxf->current_klv_data = (KLVPacket){{0}};
4002 return ret;
4003 }
4004 } else if (mxf->eia608_extract &&
4005 s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4006 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4007 if (ret < 0) {
4008 mxf->current_klv_data = (KLVPacket){{0}};
4009 return ret;
4010 }
4011 } else {
4012 ret = av_get_packet(s->pb, pkt, klv.length);
4013 if (ret < 0) {
4014 mxf->current_klv_data = (KLVPacket){{0}};
4015 return ret;
4016 }
4017 }
4018 pkt->stream_index = index;
4019 pkt->pos = klv.offset;
4020
4021 ret = mxf_set_pts(mxf, st, pkt);
4022 if (ret < 0) {
4023 mxf->current_klv_data = (KLVPacket){{0}};
4024 return ret;
4025 }
4026
4027 /* seek for truncated packets */
4028 avio_seek(s->pb, klv.next_klv, SEEK_SET);
4029
4030 return 0;
4031 } else {
4032 skip:
4033 avio_skip(s->pb, max_data_size);
4034 mxf->current_klv_data = (KLVPacket){{0}};
4035 }
4036 }
4037 return avio_feof(s->pb) ? AVERROR_EOF : ret;
4038 }
4039
mxf_read_close(AVFormatContext * s)4040 static int mxf_read_close(AVFormatContext *s)
4041 {
4042 MXFContext *mxf = s->priv_data;
4043 int i;
4044
4045 av_freep(&mxf->packages_refs);
4046 av_freep(&mxf->essence_container_data_refs);
4047
4048 for (i = 0; i < s->nb_streams; i++)
4049 s->streams[i]->priv_data = NULL;
4050
4051 for (i = 0; i < mxf->metadata_sets_count; i++) {
4052 mxf_free_metadataset(mxf->metadata_sets + i, 1);
4053 }
4054 mxf->metadata_sets_count = 0;
4055 av_freep(&mxf->partitions);
4056 av_freep(&mxf->metadata_sets);
4057 av_freep(&mxf->aesc);
4058 av_freep(&mxf->local_tags);
4059
4060 if (mxf->index_tables) {
4061 for (i = 0; i < mxf->nb_index_tables; i++) {
4062 av_freep(&mxf->index_tables[i].segments);
4063 av_freep(&mxf->index_tables[i].ptses);
4064 av_freep(&mxf->index_tables[i].fake_index);
4065 av_freep(&mxf->index_tables[i].offsets);
4066 }
4067 }
4068 av_freep(&mxf->index_tables);
4069
4070 return 0;
4071 }
4072
mxf_probe(const AVProbeData * p)4073 static int mxf_probe(const AVProbeData *p) {
4074 const uint8_t *bufp = p->buf;
4075 const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4076
4077 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4078 return 0;
4079
4080 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4081 end -= sizeof(mxf_header_partition_pack_key);
4082
4083 for (; bufp < end;) {
4084 if (!((bufp[13] - 1) & 0xF2)){
4085 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4086 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4087 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4088 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
4089 return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4090 bufp ++;
4091 } else
4092 bufp += 10;
4093 }
4094
4095 return 0;
4096 }
4097
4098 /* rudimentary byte seek */
4099 /* XXX: use MXF Index */
mxf_read_seek(AVFormatContext * s,int stream_index,int64_t sample_time,int flags)4100 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4101 {
4102 AVStream *st = s->streams[stream_index];
4103 int64_t seconds;
4104 MXFContext* mxf = s->priv_data;
4105 int64_t seekpos;
4106 int i, ret;
4107 MXFIndexTable *t;
4108 MXFTrack *source_track = st->priv_data;
4109
4110 if (!source_track)
4111 return 0;
4112
4113 /* if audio then truncate sample_time to EditRate */
4114 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4115 sample_time = av_rescale_q(sample_time, st->time_base,
4116 av_inv_q(source_track->edit_rate));
4117
4118 if (mxf->nb_index_tables <= 0) {
4119 if (!s->bit_rate)
4120 return AVERROR_INVALIDDATA;
4121 if (sample_time < 0)
4122 sample_time = 0;
4123 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4124
4125 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4126 if (seekpos < 0)
4127 return seekpos;
4128
4129 avpriv_update_cur_dts(s, st, sample_time);
4130 mxf->current_klv_data = (KLVPacket){{0}};
4131 } else {
4132 MXFPartition *partition;
4133
4134 t = &mxf->index_tables[0];
4135 if (t->index_sid != source_track->index_sid) {
4136 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
4137 for (i = 0; i < s->nb_streams; i++) {
4138 MXFTrack *new_source_track = s->streams[i]->priv_data;
4139 if (new_source_track && new_source_track->index_sid == t->index_sid) {
4140 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
4141 source_track = new_source_track;
4142 st = s->streams[i];
4143 break;
4144 }
4145 }
4146 if (i == s->nb_streams)
4147 return AVERROR_INVALIDDATA;
4148 }
4149
4150 /* clamp above zero, else ff_index_search_timestamp() returns negative
4151 * this also means we allow seeking before the start */
4152 sample_time = FFMAX(sample_time, 0);
4153
4154 if (t->fake_index) {
4155 /* The first frames may not be keyframes in presentation order, so
4156 * we have to advance the target to be able to find the first
4157 * keyframe backwards... */
4158 if (!(flags & AVSEEK_FLAG_ANY) &&
4159 (flags & AVSEEK_FLAG_BACKWARD) &&
4160 t->ptses[0] != AV_NOPTS_VALUE &&
4161 sample_time < t->ptses[0] &&
4162 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
4163 sample_time = t->ptses[0];
4164
4165 /* behave as if we have a proper index */
4166 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
4167 return sample_time;
4168 /* get the stored order index from the display order index */
4169 sample_time += t->offsets[sample_time];
4170 } else {
4171 /* no IndexEntryArray (one or more CBR segments)
4172 * make sure we don't seek past the end */
4173 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
4174 }
4175
4176 if (source_track->wrapping == UnknownWrapped)
4177 av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
4178
4179 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
4180 return ret;
4181
4182 avpriv_update_cur_dts(s, st, sample_time);
4183 if (source_track->wrapping == ClipWrapped) {
4184 KLVPacket klv = partition->first_essence_klv;
4185 if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
4186 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
4187 return AVERROR_INVALIDDATA;
4188 }
4189 mxf->current_klv_data = klv;
4190 } else {
4191 mxf->current_klv_data = (KLVPacket){{0}};
4192 }
4193 avio_seek(s->pb, seekpos, SEEK_SET);
4194 }
4195
4196 // Update all tracks sample count
4197 for (i = 0; i < s->nb_streams; i++) {
4198 AVStream *cur_st = s->streams[i];
4199 MXFTrack *cur_track = cur_st->priv_data;
4200 if (cur_track) {
4201 int64_t track_edit_unit = sample_time;
4202 if (st != cur_st)
4203 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
4204 cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
4205 }
4206 }
4207 return 0;
4208 }
4209
4210 static const AVOption options[] = {
4211 { "eia608_extract", "extract eia 608 captions from s436m track",
4212 offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
4213 AV_OPT_FLAG_DECODING_PARAM },
4214 { NULL },
4215 };
4216
4217 static const AVClass demuxer_class = {
4218 .class_name = "mxf",
4219 .item_name = av_default_item_name,
4220 .option = options,
4221 .version = LIBAVUTIL_VERSION_INT,
4222 .category = AV_CLASS_CATEGORY_DEMUXER,
4223 };
4224
4225 const AVInputFormat ff_mxf_demuxer = {
4226 .name = "mxf",
4227 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
4228 .flags = AVFMT_SEEK_TO_PTS,
4229 .priv_data_size = sizeof(MXFContext),
4230 .flags_internal = FF_FMT_INIT_CLEANUP,
4231 .read_probe = mxf_probe,
4232 .read_header = mxf_read_header,
4233 .read_packet = mxf_read_packet,
4234 .read_close = mxf_read_close,
4235 .read_seek = mxf_read_seek,
4236 .priv_class = &demuxer_class,
4237 };
4238