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