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