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