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 
1202  if (segment->temporal_offset_entries)
1203  return AVERROR_INVALIDDATA;
1204 
1205  segment->nb_index_entries = avio_rb32(pb);
1206 
1207  length = avio_rb32(pb);
1208  if(segment->nb_index_entries && length < 11)
1209  return AVERROR_INVALIDDATA;
1210 
1211  if (!FF_ALLOC_TYPED_ARRAY(segment->temporal_offset_entries, segment->nb_index_entries) ||
1212  !FF_ALLOC_TYPED_ARRAY(segment->flag_entries , segment->nb_index_entries) ||
1213  !FF_ALLOC_TYPED_ARRAY(segment->stream_offset_entries , segment->nb_index_entries)) {
1214  av_freep(&segment->temporal_offset_entries);
1215  av_freep(&segment->flag_entries);
1216  return AVERROR(ENOMEM);
1217  }
1218 
1219  for (i = 0; i < segment->nb_index_entries; i++) {
1220  if(avio_feof(pb))
1221  return AVERROR_INVALIDDATA;
1222  segment->temporal_offset_entries[i] = avio_r8(pb);
1223  avio_r8(pb); /* KeyFrameOffset */
1224  segment->flag_entries[i] = avio_r8(pb);
1225  segment->stream_offset_entries[i] = avio_rb64(pb);
1226  avio_skip(pb, length - 11);
1227  }
1228  return 0;
1229 }
1230 
1231 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1232 {
1233  MXFIndexTableSegment *segment = arg;
1234  switch(tag) {
1235  case 0x3F05:
1236  segment->edit_unit_byte_count = avio_rb32(pb);
1237  av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1238  break;
1239  case 0x3F06:
1240  segment->index_sid = avio_rb32(pb);
1241  av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1242  break;
1243  case 0x3F07:
1244  segment->body_sid = avio_rb32(pb);
1245  av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1246  break;
1247  case 0x3F0A:
1248  av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1249  return mxf_read_index_entry_array(pb, segment);
1250  case 0x3F0B:
1251  segment->index_edit_rate.num = avio_rb32(pb);
1252  segment->index_edit_rate.den = avio_rb32(pb);
1253  av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1254  segment->index_edit_rate.den);
1255  break;
1256  case 0x3F0C:
1257  segment->index_start_position = avio_rb64(pb);
1258  av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1259  break;
1260  case 0x3F0D:
1261  segment->index_duration = avio_rb64(pb);
1262  av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1263  break;
1264  }
1265  return 0;
1266 }
1267 
1268 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1269 {
1270  int code, value, ofs = 0;
1271  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1272 
1273  do {
1274  code = avio_r8(pb);
1275  value = avio_r8(pb);
1276  av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1277 
1278  if (ofs <= 14) {
1279  layout[ofs++] = code;
1280  layout[ofs++] = value;
1281  } else
1282  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1283  } while (code != 0); /* SMPTE 377M E.2.46 */
1284 
1285  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1286 }
1287 
1288 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1289 {
1290  MXFDescriptor *descriptor = arg;
1291  int entry_count, entry_size;
1292 
1293  switch(tag) {
1294  case 0x3F01:
1295  return mxf_read_strong_ref_array(pb, &descriptor->file_descriptors_refs,
1296  &descriptor->file_descriptors_count);
1297  case 0x3002: /* ContainerDuration */
1298  descriptor->duration = avio_rb64(pb);
1299  break;
1300  case 0x3004:
1301  avio_read(pb, descriptor->essence_container_ul, 16);
1302  break;
1303  case 0x3005:
1304  avio_read(pb, descriptor->codec_ul, 16);
1305  break;
1306  case 0x3006:
1307  descriptor->linked_track_id = avio_rb32(pb);
1308  break;
1309  case 0x3201: /* PictureEssenceCoding */
1310  avio_read(pb, descriptor->essence_codec_ul, 16);
1311  break;
1312  case 0x3203:
1313  descriptor->width = avio_rb32(pb);
1314  break;
1315  case 0x3202:
1316  descriptor->height = avio_rb32(pb);
1317  break;
1318  case 0x320C:
1319  descriptor->frame_layout = avio_r8(pb);
1320  break;
1321  case 0x320D:
1322  entry_count = avio_rb32(pb);
1323  entry_size = avio_rb32(pb);
1324  if (entry_size == 4) {
1325  if (entry_count > 0)
1326  descriptor->video_line_map[0] = avio_rb32(pb);
1327  else
1328  descriptor->video_line_map[0] = 0;
1329  if (entry_count > 1)
1330  descriptor->video_line_map[1] = avio_rb32(pb);
1331  else
1332  descriptor->video_line_map[1] = 0;
1333  } else
1334  av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1335  break;
1336  case 0x320E:
1337  descriptor->aspect_ratio.num = avio_rb32(pb);
1338  descriptor->aspect_ratio.den = avio_rb32(pb);
1339  break;
1340  case 0x3210:
1341  avio_read(pb, descriptor->color_trc_ul, 16);
1342  break;
1343  case 0x3212:
1344  descriptor->field_dominance = avio_r8(pb);
1345  break;
1346  case 0x3219:
1347  avio_read(pb, descriptor->color_primaries_ul, 16);
1348  break;
1349  case 0x321A:
1350  avio_read(pb, descriptor->color_space_ul, 16);
1351  break;
1352  case 0x3301:
1353  descriptor->component_depth = avio_rb32(pb);
1354  break;
1355  case 0x3302:
1356  descriptor->horiz_subsampling = avio_rb32(pb);
1357  break;
1358  case 0x3304:
1359  descriptor->black_ref_level = avio_rb32(pb);
1360  break;
1361  case 0x3305:
1362  descriptor->white_ref_level = avio_rb32(pb);
1363  break;
1364  case 0x3306:
1365  descriptor->color_range = avio_rb32(pb);
1366  break;
1367  case 0x3308:
1368  descriptor->vert_subsampling = avio_rb32(pb);
1369  break;
1370  case 0x3D03:
1371  descriptor->sample_rate.num = avio_rb32(pb);
1372  descriptor->sample_rate.den = avio_rb32(pb);
1373  break;
1374  case 0x3D06: /* SoundEssenceCompression */
1375  avio_read(pb, descriptor->essence_codec_ul, 16);
1376  break;
1377  case 0x3D07:
1378  descriptor->channels = avio_rb32(pb);
1379  break;
1380  case 0x3D01:
1381  descriptor->bits_per_sample = avio_rb32(pb);
1382  break;
1383  case 0x3401:
1384  mxf_read_pixel_layout(pb, descriptor);
1385  break;
1386  default:
1387  /* Private uid used by SONY C0023S01.mxf */
1388  if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1389  if (descriptor->extradata)
1390  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1391  av_free(descriptor->extradata);
1392  descriptor->extradata_size = 0;
1393  descriptor->extradata = av_malloc(size);
1394  if (!descriptor->extradata)
1395  return AVERROR(ENOMEM);
1396  descriptor->extradata_size = size;
1397  avio_read(pb, descriptor->extradata, size);
1398  }
1399  if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1400  uint32_t rsiz = avio_rb16(pb);
1401  if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1402  rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1403  descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1404  }
1405  if (IS_KLV_KEY(uid, mxf_mastering_display_prefix)) {
1406  if (!descriptor->mastering) {
1407  descriptor->mastering = av_mastering_display_metadata_alloc();
1408  if (!descriptor->mastering)
1409  return AVERROR(ENOMEM);
1410  }
1411  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[0])) {
1412  for (int i = 0; i < 3; i++) {
1413  /* Order: large x, large y, other (i.e. RGB) */
1414  descriptor->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1415  descriptor->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1416  }
1417  /* Check we have seen mxf_mastering_display_white_point_chromaticity */
1418  if (descriptor->mastering->white_point[0].den != 0)
1419  descriptor->mastering->has_primaries = 1;
1420  }
1421  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[1])) {
1422  descriptor->mastering->white_point[0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1423  descriptor->mastering->white_point[1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1424  /* Check we have seen mxf_mastering_display_primaries */
1425  if (descriptor->mastering->display_primaries[0][0].den != 0)
1426  descriptor->mastering->has_primaries = 1;
1427  }
1428  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[2])) {
1429  descriptor->mastering->max_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1430  /* Check we have seen mxf_mastering_display_minimum_luminance */
1431  if (descriptor->mastering->min_luminance.den != 0)
1432  descriptor->mastering->has_luminance = 1;
1433  }
1434  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[3])) {
1435  descriptor->mastering->min_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1436  /* Check we have seen mxf_mastering_display_maximum_luminance */
1437  if (descriptor->mastering->max_luminance.den != 0)
1438  descriptor->mastering->has_luminance = 1;
1439  }
1440  }
1441  if (IS_KLV_KEY(uid, mxf_apple_coll_prefix)) {
1442  if (!descriptor->coll) {
1443  descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1444  if (!descriptor->coll)
1445  return AVERROR(ENOMEM);
1446  }
1447  if (IS_KLV_KEY(uid, mxf_apple_coll_max_cll)) {
1448  descriptor->coll->MaxCLL = avio_rb16(pb);
1449  }
1450  if (IS_KLV_KEY(uid, mxf_apple_coll_max_fall)) {
1451  descriptor->coll->MaxFALL = avio_rb16(pb);
1452  }
1453  }
1454 
1455  if (IS_KLV_KEY(uid, mxf_sub_descriptor))
1456  return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs, &descriptor->sub_descriptors_count);
1457 
1458  break;
1459  }
1460  return 0;
1461 }
1462 
1463 static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1464 {
1465  MXFMCASubDescriptor *mca_sub_descriptor = arg;
1466 
1467  if (IS_KLV_KEY(uid, mxf_mca_label_dictionary_id))
1468  avio_read(pb, mca_sub_descriptor->mca_label_dictionary_id, 16);
1469 
1470  if (IS_KLV_KEY(uid, mxf_mca_link_id))
1471  avio_read(pb, mca_sub_descriptor->mca_link_id, 16);
1472 
1473  if (IS_KLV_KEY(uid, mxf_soundfield_group_link_id))
1474  avio_read(pb, mca_sub_descriptor->soundfield_group_link_id, 16);
1475 
1476  if (IS_KLV_KEY(uid, mxf_group_of_soundfield_groups_link_id))
1477  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);
1478 
1479  if (IS_KLV_KEY(uid, mxf_mca_channel_id))
1480  mca_sub_descriptor->mca_channel_id = avio_rb32(pb);
1481 
1482  if (IS_KLV_KEY(uid, mxf_mca_rfc5646_spoken_language))
1483  return mxf_read_us_ascii_string(pb, size, &mca_sub_descriptor->language);
1484 
1485  return 0;
1486 }
1487 
1488 static int mxf_read_ffv1_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1489 {
1490  MXFFFV1SubDescriptor *ffv1_sub_descriptor = arg;
1491 
1492  if (IS_KLV_KEY(uid, mxf_ffv1_extradata) && size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ) {
1493  if (ffv1_sub_descriptor->extradata)
1494  av_log(NULL, AV_LOG_WARNING, "Duplicate ffv1_extradata\n");
1495  av_free(ffv1_sub_descriptor->extradata);
1496  ffv1_sub_descriptor->extradata_size = 0;
1497  ffv1_sub_descriptor->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
1498  if (!ffv1_sub_descriptor->extradata)
1499  return AVERROR(ENOMEM);
1500  ffv1_sub_descriptor->extradata_size = size;
1501  avio_read(pb, ffv1_sub_descriptor->extradata, size);
1502  }
1503 
1504  return 0;
1505 }
1506 
1507 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1508 {
1509  MXFTaggedValue *tagged_value = arg;
1510  uint8_t key[17];
1511 
1512  if (size <= 17)
1513  return 0;
1514 
1515  avio_read(pb, key, 17);
1516  /* TODO: handle other types of of indirect values */
1517  if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1518  return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1519  } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1520  return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1521  }
1522  return 0;
1523 }
1524 
1525 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1526 {
1527  MXFTaggedValue *tagged_value = arg;
1528  switch (tag){
1529  case 0x5001:
1530  return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1531  case 0x5003:
1532  return mxf_read_indirect_value(tagged_value, pb, size);
1533  }
1534  return 0;
1535 }
1536 
1537 /*
1538  * Match an uid independently of the version byte and up to len common bytes
1539  * Returns: boolean
1540  */
1541 static int mxf_match_uid(const UID key, const UID uid, int len)
1542 {
1543  int i;
1544  for (i = 0; i < len; i++) {
1545  if (i != 7 && key[i] != uid[i])
1546  return 0;
1547  }
1548  return 1;
1549 }
1550 
1551 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1552 {
1553  while (uls->uid[0]) {
1554  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1555  break;
1556  uls++;
1557  }
1558  return uls;
1559 }
1560 
1561 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1562 {
1563  int i;
1564 
1565  if (!strong_ref)
1566  return NULL;
1567  for (i = mxf->metadata_sets_count - 1; i >= 0; i--) {
1568  if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1569  (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1570  return mxf->metadata_sets[i];
1571  }
1572  }
1573  return NULL;
1574 }
1575 
1576 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1577  // video essence container uls
1578  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14, J2KWrap },
1579  { { 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 */
1580  { { 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 */
1581  { { 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 */
1582  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1583  { { 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 */
1584  { { 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 */
1585  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1586  { { 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 */
1587  { { 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 */
1588  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x23,0x01,0x00 }, 14, AV_CODEC_ID_FFV1, NULL, 14 },
1589  { { 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 */
1590  { { 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 */
1591  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1592  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1593  { { 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 */
1594  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1595  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1596 };
1597 
1598 /* EC ULs for intra-only formats */
1599 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1600  { { 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 */
1601  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1602 };
1603 
1604 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1605 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1606  { { 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 */
1607  { { 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 */
1608  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1609 };
1610 
1611 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1612 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1613  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1614  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1615  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1616  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1617  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1618 };
1619 
1620 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1621  // sound essence container uls
1622  { { 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 */
1623  { { 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 */
1624  { { 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 */
1625  { { 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 */
1626  { { 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) */
1627  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1628 };
1629 
1630 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1631  { { 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 },
1632  { { 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 },
1633  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1634  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1635 };
1636 
1637 typedef struct MXFChannelOrderingUL {
1638  UID uid;
1639  uint64_t layout_mask;
1640  enum AVAudioServiceType service_type;
1641 } MXFChannelOrderingUL;
1642 
1643 static const MXFChannelOrderingUL mxf_channel_ordering[] = {
1644  { { 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
1645  { { 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
1646  { { 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
1647  { { 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
1648  { { 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
1649  { { 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
1650  { { 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
1651  { { 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
1652  { { 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
1653  { { 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
1654  { { 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
1655  { { 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
1656  { { 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
1657  { { 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
1658  { { 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
1659  { { 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
1660  { { 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
1661  { { 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
1662  { { 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
1663  { { 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
1664  { { 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
1665  { { 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
1666  { { 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
1667  { { 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
1668  { { 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
1669  { { 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
1670  { { 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
1671  { { 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
1672  { { 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
1673  { { 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
1674  { { 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
1675  { { 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
1676  { { 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
1677  { { 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
1678  { { 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
1679  { { 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
1680  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_AUDIO_SERVICE_TYPE_NB },
1681 };
1682 
1683 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1684 {
1685  int val;
1686  const MXFCodecUL *codec_ul;
1687 
1688  codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1689  if (!codec_ul->uid[0])
1690  codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1691  if (!codec_ul->uid[0])
1692  codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1693  if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1694  return UnknownWrapped;
1695 
1696  val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1697  switch (codec_ul->wrapping_indicator_type) {
1698  case RawVWrap:
1699  val = val % 4;
1700  break;
1701  case RawAWrap:
1702  if (val == 0x03 || val == 0x04)
1703  val -= 0x02;
1704  break;
1705  case D10D11Wrap:
1706  if (val == 0x02)
1707  val = 0x01;
1708  break;
1709  case J2KWrap:
1710  if (val != 0x02)
1711  val = 0x01;
1712  break;
1713  }
1714  if (val == 0x01)
1715  return FrameWrapped;
1716  if (val == 0x02)
1717  return ClipWrapped;
1718  return UnknownWrapped;
1719 }
1720 
1721 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1722 {
1723  int i, j, nb_segments = 0;
1724  MXFIndexTableSegment **unsorted_segments;
1725  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1726 
1727  /* count number of segments, allocate arrays and copy unsorted segments */
1728  for (i = 0; i < mxf->metadata_sets_count; i++)
1729  if (mxf->metadata_sets[i]->type == IndexTableSegment)
1730  nb_segments++;
1731 
1732  if (!nb_segments)
1733  return AVERROR_INVALIDDATA;
1734 
1735  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1736  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1737  av_freep(sorted_segments);
1738  av_free(unsorted_segments);
1739  return AVERROR(ENOMEM);
1740  }
1741 
1742  for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1743  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1744  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1745  if (s->edit_unit_byte_count || s->nb_index_entries)
1746  unsorted_segments[nb_segments++] = s;
1747  else
1748  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1749  s->index_sid, s->index_start_position);
1750  }
1751  }
1752 
1753  if (!nb_segments) {
1754  av_freep(sorted_segments);
1755  av_free(unsorted_segments);
1756  return AVERROR_INVALIDDATA;
1757  }
1758 
1759  *nb_sorted_segments = 0;
1760 
1761  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1762  for (i = 0; i < nb_segments; i++) {
1763  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1764  uint64_t best_index_duration = 0;
1765 
1766  for (j = 0; j < nb_segments; j++) {
1767  MXFIndexTableSegment *s = unsorted_segments[j];
1768 
1769  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1770  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1771  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1772  */
1773  if ((i == 0 ||
1774  s->body_sid > last_body_sid ||
1775  s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1776  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1777  (best == -1 ||
1778  s->body_sid < best_body_sid ||
1779  s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1780  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1781  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)) {
1782  best = j;
1783  best_body_sid = s->body_sid;
1784  best_index_sid = s->index_sid;
1785  best_index_start = s->index_start_position;
1786  best_index_duration = s->index_duration;
1787  }
1788  }
1789 
1790  /* no suitable entry found -> we're done */
1791  if (best == -1)
1792  break;
1793 
1794  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1795  last_body_sid = best_body_sid;
1796  last_index_sid = best_index_sid;
1797  last_index_start = best_index_start;
1798  }
1799 
1800  av_free(unsorted_segments);
1801 
1802  return 0;
1803 }
1804 
1805 /**
1806  * Computes the absolute file offset of the given essence container offset
1807  */
1808 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1809 {
1810  MXFPartition *last_p = NULL;
1811  int a, b, m, m0;
1812 
1813  if (offset < 0)
1814  return AVERROR(EINVAL);
1815 
1816  a = -1;
1817  b = mxf->partitions_count;
1818 
1819  while (b - a > 1) {
1820  m0 = m = (a + b) >> 1;
1821 
1822  while (m < b && mxf->partitions[m].body_sid != body_sid)
1823  m++;
1824 
1825  if (m < b && mxf->partitions[m].body_offset <= offset)
1826  a = m;
1827  else
1828  b = m0;
1829  }
1830 
1831  if (a >= 0)
1832  last_p = &mxf->partitions[a];
1833 
1834  if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1835  *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1836  if (partition_out)
1837  *partition_out = last_p;
1838  return 0;
1839  }
1840 
1841  av_log(mxf->fc, AV_LOG_ERROR,
1842  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1843  offset, body_sid);
1844 
1845  return AVERROR_INVALIDDATA;
1846 }
1847 
1848 /**
1849  * Returns the end position of the essence container with given BodySID, or zero if unknown
1850  */
1851 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1852 {
1853  for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1854  MXFPartition *p = &mxf->partitions[x];
1855 
1856  if (p->body_sid != body_sid)
1857  continue;
1858 
1859  if (!p->essence_length)
1860  return 0;
1861 
1862  return p->essence_offset + p->essence_length;
1863  }
1864 
1865  return 0;
1866 }
1867 
1868 /* EditUnit -> absolute offset */
1869 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)
1870 {
1871  int i;
1872  int64_t offset_temp = 0;
1873 
1874  edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1875 
1876  for (i = 0; i < index_table->nb_segments; i++) {
1877  MXFIndexTableSegment *s = index_table->segments[i];
1878 
1879  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1880 
1881  if (edit_unit < s->index_start_position + s->index_duration) {
1882  int64_t index = edit_unit - s->index_start_position;
1883 
1884  if (s->edit_unit_byte_count)
1885  offset_temp += s->edit_unit_byte_count * index;
1886  else {
1887  if (s->nb_index_entries == 2 * s->index_duration + 1)
1888  index *= 2; /* Avid index */
1889 
1890  if (index < 0 || index >= s->nb_index_entries) {
1891  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1892  index_table->index_sid, s->index_start_position);
1893  return AVERROR_INVALIDDATA;
1894  }
1895 
1896  offset_temp = s->stream_offset_entries[index];
1897  }
1898 
1899  if (edit_unit_out)
1900  *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1901 
1902  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1903  } else {
1904  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1905  offset_temp += s->edit_unit_byte_count * s->index_duration;
1906  }
1907  }
1908 
1909  if (nag)
1910  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);
1911 
1912  return AVERROR_INVALIDDATA;
1913 }
1914 
1915 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1916 {
1917  int i, j, x;
1918  int8_t max_temporal_offset = -128;
1919  uint8_t *flags;
1920 
1921  /* first compute how many entries we have */
1922  for (i = 0; i < index_table->nb_segments; i++) {
1923  MXFIndexTableSegment *s = index_table->segments[i];
1924 
1925  if (!s->nb_index_entries) {
1926  index_table->nb_ptses = 0;
1927  return 0; /* no TemporalOffsets */
1928  }
1929 
1930  if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1931  index_table->nb_ptses = 0;
1932  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1933  return 0;
1934  }
1935 
1936  index_table->nb_ptses += s->index_duration;
1937  }
1938 
1939  /* paranoid check */
1940  if (index_table->nb_ptses <= 0)
1941  return 0;
1942 
1943  if (!(index_table->ptses = av_malloc_array(index_table->nb_ptses, sizeof(int64_t))) ||
1944  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1945  !(index_table->offsets = av_malloc_array(index_table->nb_ptses, sizeof(int8_t))) ||
1946  !(flags = av_malloc_array(index_table->nb_ptses, sizeof(uint8_t)))) {
1947  av_freep(&index_table->ptses);
1948  av_freep(&index_table->fake_index);
1949  av_freep(&index_table->offsets);
1950  return AVERROR(ENOMEM);
1951  }
1952 
1953  /* we may have a few bad TemporalOffsets
1954  * make sure the corresponding PTSes don't have the bogus value 0 */
1955  for (x = 0; x < index_table->nb_ptses; x++)
1956  index_table->ptses[x] = AV_NOPTS_VALUE;
1957 
1958  /**
1959  * We have this:
1960  *
1961  * x TemporalOffset
1962  * 0: 0
1963  * 1: 1
1964  * 2: 1
1965  * 3: -2
1966  * 4: 1
1967  * 5: 1
1968  * 6: -2
1969  *
1970  * We want to transform it into this:
1971  *
1972  * x DTS PTS
1973  * 0: -1 0
1974  * 1: 0 3
1975  * 2: 1 1
1976  * 3: 2 2
1977  * 4: 3 6
1978  * 5: 4 4
1979  * 6: 5 5
1980  *
1981  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1982  * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
1983  * The latter makes DTS <= PTS.
1984  */
1985  for (i = x = 0; i < index_table->nb_segments; i++) {
1986  MXFIndexTableSegment *s = index_table->segments[i];
1987  int index_delta = 1;
1988  int n = s->nb_index_entries;
1989 
1990  if (s->nb_index_entries == 2 * s->index_duration + 1) {
1991  index_delta = 2; /* Avid index */
1992  /* ignore the last entry - it's the size of the essence container */
1993  n--;
1994  }
1995 
1996  for (j = 0; j < n; j += index_delta, x++) {
1997  int offset = s->temporal_offset_entries[j] / index_delta;
1998  int index = x + offset;
1999 
2000  if (x >= index_table->nb_ptses) {
2001  av_log(mxf->fc, AV_LOG_ERROR,
2002  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
2003  s->nb_index_entries, s->index_duration);
2004  break;
2005  }
2006 
2007  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
2008 
2009  if (index < 0 || index >= index_table->nb_ptses) {
2010  av_log(mxf->fc, AV_LOG_ERROR,
2011  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
2012  x, offset, index);
2013  continue;
2014  }
2015 
2016  index_table->offsets[x] = offset;
2017  index_table->ptses[index] = x;
2018  max_temporal_offset = FFMAX(max_temporal_offset, offset);
2019  }
2020  }
2021 
2022  /* calculate the fake index table in display order */
2023  for (x = 0; x < index_table->nb_ptses; x++) {
2024  index_table->fake_index[x].timestamp = x;
2025  if (index_table->ptses[x] != AV_NOPTS_VALUE)
2026  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2027  }
2028  av_freep(&flags);
2029 
2030  index_table->first_dts = -max_temporal_offset;
2031 
2032  return 0;
2033 }
2034 
2035 /**
2036  * Sorts and collects index table segments into index tables.
2037  * Also computes PTSes if possible.
2038  */
2039 static int mxf_compute_index_tables(MXFContext *mxf)
2040 {
2041  int i, j, k, ret, nb_sorted_segments;
2042  MXFIndexTableSegment **sorted_segments = NULL;
2043 
2044  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2045  nb_sorted_segments <= 0) {
2046  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2047  return 0;
2048  }
2049 
2050  /* sanity check and count unique BodySIDs/IndexSIDs */
2051  for (i = 0; i < nb_sorted_segments; i++) {
2052  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2053  mxf->nb_index_tables++;
2054  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2055  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2056  ret = AVERROR_INVALIDDATA;
2057  goto finish_decoding_index;
2058  }
2059  }
2060 
2061  mxf->index_tables = av_calloc(mxf->nb_index_tables,
2062  sizeof(*mxf->index_tables));
2063  if (!mxf->index_tables) {
2064  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2065  ret = AVERROR(ENOMEM);
2066  goto finish_decoding_index;
2067  }
2068 
2069  /* distribute sorted segments to index tables */
2070  for (i = j = 0; i < nb_sorted_segments; i++) {
2071  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2072  /* next IndexSID */
2073  j++;
2074  }
2075 
2076  mxf->index_tables[j].nb_segments++;
2077  }
2078 
2079  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2080  MXFIndexTable *t = &mxf->index_tables[j];
2081  MXFTrack *mxf_track = NULL;
2082 
2083  t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2084  if (!t->segments) {
2085  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2086  " pointer array\n");
2087  ret = AVERROR(ENOMEM);
2088  goto finish_decoding_index;
2089  }
2090 
2091  if (sorted_segments[i]->index_start_position)
2092  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2093  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2094 
2095  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2096  t->index_sid = sorted_segments[i]->index_sid;
2097  t->body_sid = sorted_segments[i]->body_sid;
2098 
2099  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2100  goto finish_decoding_index;
2101 
2102  for (k = 0; k < mxf->fc->nb_streams; k++) {
2103  MXFTrack *track = mxf->fc->streams[k]->priv_data;
2104  if (track && track->index_sid == t->index_sid) {
2105  mxf_track = track;
2106  break;
2107  }
2108  }
2109 
2110  /* fix zero IndexDurations */
2111  for (k = 0; k < t->nb_segments; k++) {
2112  if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2113  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2114  t->index_sid, k);
2115  if (mxf_track)
2116  t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2117  }
2118 
2119  if (t->segments[k]->index_duration)
2120  continue;
2121 
2122  if (t->nb_segments > 1)
2123  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2124  t->index_sid, k);
2125 
2126  if (!mxf_track) {
2127  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2128  break;
2129  }
2130 
2131  /* assume the first stream's duration is reasonable
2132  * leave index_duration = 0 on further segments in case we have any (unlikely)
2133  */
2134  t->segments[k]->index_duration = mxf_track->original_duration;
2135  break;
2136  }
2137  }
2138 
2139  ret = 0;
2140 finish_decoding_index:
2141  av_free(sorted_segments);
2142  return ret;
2143 }
2144 
2145 static int mxf_is_st_422(const UID *essence_container_ul) {
2146  static const uint8_t st_422_essence_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c };
2147 
2148  return essence_container_ul && mxf_match_uid(*essence_container_ul, st_422_essence_container_ul,
2149  sizeof(st_422_essence_container_ul));
2150 }
2151 
2152 static int mxf_is_intra_only(MXFDescriptor *descriptor)
2153 {
2154  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
2155  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
2156  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
2157  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
2158 }
2159 
2160 static void mxf_umid_to_str(const UID ul, const UID uid,
2161  char str[2 + sizeof(UID) * 4 + 1])
2162 {
2163  snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2164  ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2165  ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2166 }
2167 
2168 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2169  uint16_t patch, uint16_t release, char **str)
2170 {
2171  *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2172  if (!*str)
2173  return AVERROR(ENOMEM);
2174  return 0;
2175 }
2176 
2177 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2178 {
2179  char str[2 + 4 * sizeof(UID) + 1];
2180  if (!package)
2181  return 0;
2182  mxf_umid_to_str(package->package_ul, package->package_uid, str);
2183  av_dict_set(pm, key, str, 0);
2184  return 0;
2185 }
2186 
2187 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2188 {
2189  char buf[AV_TIMECODE_STR_SIZE];
2190  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2191 
2192  return 0;
2193 }
2194 
2195 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2196 {
2197  MXFStructuralComponent *component = NULL;
2198  MXFPulldownComponent *pulldown = NULL;
2199 
2200  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2201  if (!component)
2202  return NULL;
2203 
2204  switch (component->meta.type) {
2205  case TimecodeComponent:
2206  return (MXFTimecodeComponent*)component;
2207  case PulldownComponent: /* timcode component may be located on a pulldown component */
2208  pulldown = (MXFPulldownComponent*)component;
2209  return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2210  default:
2211  break;
2212  }
2213  return NULL;
2214 }
2215 
2216 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2217 {
2218  MXFPackage *package = NULL;
2219  int i;
2220 
2221  for (i = 0; i < mxf->packages_count; i++) {
2222  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2223  if (!package)
2224  continue;
2225 
2226  if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2227  return package;
2228  }
2229  return NULL;
2230 }
2231 
2232 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
2233 {
2234  MXFDescriptor *file_descriptor = NULL;
2235  int i;
2236 
2237  if (!descriptor)
2238  return NULL;
2239 
2240  if (descriptor->meta.type == MultipleDescriptor) {
2241  for (i = 0; i < descriptor->file_descriptors_count; i++) {
2242  file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2243 
2244  if (!file_descriptor) {
2245  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2246  continue;
2247  }
2248  if (file_descriptor->linked_track_id == track_id) {
2249  return file_descriptor;
2250  }
2251  }
2252  } else if (descriptor->meta.type == Descriptor)
2253  return descriptor;
2254 
2255  return NULL;
2256 }
2257 
2258 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
2259 {
2260  MXFStructuralComponent *component = NULL;
2261  MXFPackage *package = NULL;
2262  MXFDescriptor *descriptor = NULL;
2263  int i;
2264 
2265  if (!essence_group || !essence_group->structural_components_count)
2266  return NULL;
2267 
2268  /* essence groups contains multiple representations of the same media,
2269  this return the first components with a valid Descriptor typically index 0 */
2270  for (i =0; i < essence_group->structural_components_count; i++){
2271  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2272  if (!component)
2273  continue;
2274 
2275  if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2276  continue;
2277 
2278  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2279  if (descriptor)
2280  return component;
2281  }
2282  return NULL;
2283 }
2284 
2285 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2286 {
2287  MXFStructuralComponent *component = NULL;
2288 
2289  component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2290  if (!component)
2291  return NULL;
2292  switch (component->meta.type) {
2293  case SourceClip:
2294  return component;
2295  case EssenceGroup:
2296  return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2297  default:
2298  break;
2299  }
2300  return NULL;
2301 }
2302 
2303 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2304 {
2305  MXFTaggedValue *tag;
2306  int i;
2307  char *key = NULL;
2308 
2309  for (i = 0; i < package->comment_count; i++) {
2310  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2311  if (!tag || !tag->name || !tag->value)
2312  continue;
2313 
2314  key = av_asprintf("comment_%s", tag->name);
2315  if (!key)
2316  return AVERROR(ENOMEM);
2317 
2318  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2319  }
2320  return 0;
2321 }
2322 
2323 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2324 {
2325  MXFPackage *physical_package = NULL;
2326  MXFTrack *physical_track = NULL;
2327  MXFStructuralComponent *sourceclip = NULL;
2328  MXFTimecodeComponent *mxf_tc = NULL;
2329  int i, j, k;
2330  AVTimecode tc;
2331  int flags;
2332  int64_t start_position;
2333 
2334  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2335  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2336  if (!sourceclip)
2337  continue;
2338 
2339  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2340  break;
2341 
2342  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2343 
2344  /* the name of physical source package is name of the reel or tape */
2345  if (physical_package->name && physical_package->name[0])
2346  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2347 
2348  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2349  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2350  */
2351  for (j = 0; j < physical_package->tracks_count; j++) {
2352  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2353  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2354  continue;
2355  }
2356 
2357  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2358  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2359  continue;
2360  }
2361 
2362  if (physical_track->edit_rate.num <= 0 ||
2363  physical_track->edit_rate.den <= 0) {
2364  av_log(mxf->fc, AV_LOG_WARNING,
2365  "Invalid edit rate (%d/%d) found on structural"
2366  " component #%d, defaulting to 25/1\n",
2367  physical_track->edit_rate.num,
2368  physical_track->edit_rate.den, i);
2369  physical_track->edit_rate = (AVRational){25, 1};
2370  }
2371 
2372  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2373  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2374  continue;
2375 
2376  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2377  /* scale sourceclip start_position to match physical track edit rate */
2378  start_position = av_rescale_q(sourceclip->start_position,
2379  physical_track->edit_rate,
2380  source_track->edit_rate);
2381 
2382  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2383  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2384  return 0;
2385  }
2386  }
2387  }
2388  }
2389 
2390  return 0;
2391 }
2392 
2393 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2394 {
2395  MXFStructuralComponent *component = NULL;
2396  const MXFCodecUL *codec_ul = NULL;
2397  MXFPackage tmp_package;
2398  AVStream *st;
2399  int j;
2400 
2401  for (j = 0; j < track->sequence->structural_components_count; j++) {
2402  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2403  if (!component)
2404  continue;
2405  break;
2406  }
2407  if (!component)
2408  return 0;
2409 
2410  st = avformat_new_stream(mxf->fc, NULL);
2411  if (!st) {
2412  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2413  return AVERROR(ENOMEM);
2414  }
2415 
2416  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2417  st->codecpar->codec_id = AV_CODEC_ID_NONE;
2418  st->id = track->track_id;
2419 
2420  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2421  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2422  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2423  if (track->name && track->name[0])
2424  av_dict_set(&st->metadata, "track_name", track->name, 0);
2425 
2426  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2427  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2428  return 0;
2429 }
2430 
2431 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2432 {
2433  if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2434  /* CDCI range metadata */
2435  if (!descriptor->component_depth)
2436  return AVCOL_RANGE_UNSPECIFIED;
2437  if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2438  descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2439  (descriptor->color_range == (1<<descriptor->component_depth) ||
2440  descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2441  return AVCOL_RANGE_JPEG;
2442  if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2443  descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2444  descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2445  descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2446  return AVCOL_RANGE_MPEG;
2447  avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2448  descriptor->color_range, descriptor->black_ref_level,
2449  descriptor->white_ref_level, descriptor->component_depth);
2450  }
2451 
2452  return AVCOL_RANGE_UNSPECIFIED;
2453 }
2454 
2455 static int is_pcm(enum AVCodecID codec_id)
2456 {
2457  /* we only care about "normal" PCM codecs until we get samples */
2458  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2459 }
2460 
2461 static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2462 {
2463  // language abbr should contain at least 2 chars
2464  if (rfc5646 && strlen(rfc5646) > 1) {
2465  char primary_tag[4] =
2466  {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2467 
2468  const char *iso6392 = ff_convert_lang_to(primary_tag,
2469  AV_LANG_ISO639_2_BIBL);
2470  if (iso6392)
2471  return(av_dict_set(met, "language", iso6392, 0));
2472  }
2473  return 0;
2474 }
2475 
2476 static MXFMCASubDescriptor *find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
2477 {
2478  for (int k = 0; k < mxf->metadata_sets_count; k++) {
2479  MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mxf->metadata_sets[k];
2480  if (group->meta.type == type && !memcmp(&group->mca_link_id, mca_link_id, 16))
2481  return group;
2482  }
2483  return NULL;
2484 }
2485 
2486 static void parse_ffv1_sub_descriptor(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2487 {
2488  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2489  MXFFFV1SubDescriptor *ffv1_sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], FFV1SubDescriptor);
2490  if (ffv1_sub_descriptor == NULL)
2491  continue;
2492 
2493  descriptor->extradata = ffv1_sub_descriptor->extradata;
2494  descriptor->extradata_size = ffv1_sub_descriptor->extradata_size;
2495  ffv1_sub_descriptor->extradata = NULL;
2496  ffv1_sub_descriptor->extradata_size = 0;
2497  break;
2498  }
2499 }
2500 
2501 static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2502 {
2503  uint64_t routing[FF_SANE_NB_CHANNELS] = {0};
2504  char *language = NULL;
2505  int ambigous_language = 0;
2506  enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2507  int ambigous_service_type = 0;
2508  int has_channel_label = 0;
2509 
2510  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2511  char *channel_language;
2512 
2513  MXFMCASubDescriptor *label = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], AudioChannelLabelSubDescriptor);
2514  if (label == NULL)
2515  continue;
2516 
2517  has_channel_label = 1;
2518  for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2519  if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2520  int target_channel = label->mca_channel_id;
2521  if (target_channel == 0 && descriptor->channels == 1)
2522  target_channel = 1;
2523  if (target_channel <= 0 || target_channel > descriptor->channels) {
2524  av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2525  return AVERROR_INVALIDDATA;
2526  }
2527  routing[target_channel - 1] = channel_ordering->layout_mask;
2528  if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2529  service_type = channel_ordering->service_type;
2530  else if (service_type != channel_ordering->service_type)
2531  ambigous_service_type = 1;
2532  break;
2533  }
2534  }
2535 
2536  channel_language = label->language;
2537  if (!channel_language) {
2538  MXFMCASubDescriptor *group = find_mca_link_id(mxf, SoundfieldGroupLabelSubDescriptor, &label->soundfield_group_link_id);
2539  if (group) {
2540  channel_language = group->language;
2541  if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2542  MXFMCASubDescriptor *supergroup = find_mca_link_id(mxf, GroupOfSoundfieldGroupsLabelSubDescriptor,
2543  group->group_of_soundfield_groups_link_id_refs);
2544  if (supergroup)
2545  channel_language = supergroup->language;
2546  }
2547  }
2548  }
2549  if (channel_language) {
2550  if (language && strcmp(language, channel_language))
2551  ambigous_language = 1;
2552  else
2553  language = channel_language;
2554  }
2555  }
2556 
2557  if (language && !ambigous_language) {
2558  int ret = set_language(mxf->fc, language, &st->metadata);
2559  if (ret < 0)
2560  return ret;
2561  }
2562 
2563  if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2564  enum AVAudioServiceType *ast;
2565  uint8_t* side_data = av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE, sizeof(*ast));
2566  if (!side_data)
2567  return AVERROR(ENOMEM);
2568  ast = (enum AVAudioServiceType*)side_data;
2569  *ast = service_type;
2570  }
2571 
2572  if (has_channel_label) {
2573  uint64_t channel_layout = 0;
2574  int ret;
2575 
2576  for (int i = 0; i < descriptor->channels; i++) {
2577  if (!routing[i]) {
2578  av_log(mxf->fc, AV_LOG_WARNING, "Designation of audio channel %d in stream #%d is unknown or unsupported, "
2579  "falling back to unknown channel layout\n", st->index, i);
2580  return 0;
2581  }
2582  if (channel_layout & routing[i]) {
2583  char buf[32];
2584  av_channel_name(buf, sizeof(buf), routing[i]);
2585  av_log(mxf->fc, AV_LOG_WARNING, "%s audio channel is used multiple times in stream #%d, "
2586  "falling back to unknown channel layout\n",
2587  buf, st->index);
2588  return 0;
2589  }
2590  if (routing[i] < channel_layout) {
2591  av_log(mxf->fc, AV_LOG_WARNING, "stream #%d is not in in native channel order, "
2592  "falling back to unknown channel layout\n", st->index);
2593  return 0;
2594  }
2595  channel_layout |= routing[i];
2596  }
2597 
2598  av_assert0(descriptor->channels == av_popcount64(channel_layout));
2599 
2600  ret = av_channel_layout_from_mask(&st->codecpar->ch_layout, channel_layout);
2601  if (ret < 0)
2602  return ret;
2603  }
2604 
2605  return 0;
2606 }
2607 
2608 static int mxf_parse_structural_metadata(MXFContext *mxf)
2609 {
2610  MXFPackage *material_package = NULL;
2611  int i, j, k, ret;
2612 
2613  av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2614  /* TODO: handle multiple material packages (OP3x) */
2615  for (i = 0; i < mxf->packages_count; i++) {
2616  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2617  if (material_package) break;
2618  }
2619  if (!material_package) {
2620  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2621  return AVERROR_INVALIDDATA;
2622  }
2623 
2624  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2625  if (material_package->name && material_package->name[0])
2626  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2627  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2628 
2629  for (i = 0; i < material_package->tracks_count; i++) {
2630  MXFPackage *source_package = NULL;
2631  MXFTrack *material_track = NULL;
2632  MXFTrack *source_track = NULL;
2633  MXFTrack *temp_track = NULL;
2634  MXFDescriptor *descriptor = NULL;
2635  MXFStructuralComponent *component = NULL;
2636  MXFTimecodeComponent *mxf_tc = NULL;
2637  UID *essence_container_ul = NULL;
2638  const MXFCodecUL *codec_ul = NULL;
2639  const MXFCodecUL *container_ul = NULL;
2640  const MXFCodecUL *pix_fmt_ul = NULL;
2641  AVStream *st;
2642  FFStream *sti;
2643  AVTimecode tc;
2644  int flags;
2645 
2646  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2647  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2648  continue;
2649  }
2650 
2651  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2652  mxf_tc = (MXFTimecodeComponent*)component;
2653  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2654  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2655  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2656  }
2657  }
2658 
2659  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2660  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2661  continue;
2662  }
2663 
2664  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2665  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2666  if (!component)
2667  continue;
2668 
2669  mxf_tc = (MXFTimecodeComponent*)component;
2670  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2671  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2672  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2673  break;
2674  }
2675  }
2676 
2677  /* TODO: handle multiple source clips, only finds first valid source clip */
2678  if(material_track->sequence->structural_components_count > 1)
2679  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2680  material_track->track_id, material_track->sequence->structural_components_count);
2681 
2682  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2683  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2684  if (!component)
2685  continue;
2686 
2687  source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2688  if (!source_package) {
2689  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2690  continue;
2691  }
2692  for (k = 0; k < source_package->tracks_count; k++) {
2693  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2694  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2695  ret = AVERROR_INVALIDDATA;
2696  goto fail_and_free;
2697  }
2698  if (temp_track->track_id == component->source_track_id) {
2699  source_track = temp_track;
2700  break;
2701  }
2702  }
2703  if (!source_track) {
2704  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2705  break;
2706  }
2707 
2708  for (k = 0; k < mxf->essence_container_data_count; k++) {
2709  MXFEssenceContainerData *essence_data;
2710 
2711  if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2712  av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2713  continue;
2714  }
2715  if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2716  source_track->body_sid = essence_data->body_sid;
2717  source_track->index_sid = essence_data->index_sid;
2718  break;
2719  }
2720  }
2721 
2722  if(source_track && component)
2723  break;
2724  }
2725  if (!source_track || !component || !source_package) {
2726  if((ret = mxf_add_metadata_stream(mxf, material_track)))
2727  goto fail_and_free;
2728  continue;
2729  }
2730 
2731  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2732  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2733  ret = AVERROR_INVALIDDATA;
2734  goto fail_and_free;
2735  }
2736 
2737  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2738  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2739  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2740  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2741  continue;
2742  }
2743 
2744  st = avformat_new_stream(mxf->fc, NULL);
2745  if (!st) {
2746  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2747  ret = AVERROR(ENOMEM);
2748  goto fail_and_free;
2749  }
2750  sti = ffstream(st);
2751  st->id = material_track->track_id;
2752  st->priv_data = source_track;
2753 
2754  source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2755  descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2756 
2757  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2758  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2759  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2760  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2761  else
2762  source_track->original_duration = st->duration = component->duration;
2763 
2764  if (st->duration == -1)
2765  st->duration = AV_NOPTS_VALUE;
2766  st->start_time = component->start_position;
2767  if (material_track->edit_rate.num <= 0 ||
2768  material_track->edit_rate.den <= 0) {
2769  av_log(mxf->fc, AV_LOG_WARNING,
2770  "Invalid edit rate (%d/%d) found on stream #%d, "
2771  "defaulting to 25/1\n",
2772  material_track->edit_rate.num,
2773  material_track->edit_rate.den, st->index);
2774  material_track->edit_rate = (AVRational){25, 1};
2775  }
2776  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2777 
2778  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2779  * the former is accessible via st->priv_data */
2780  source_track->edit_rate = material_track->edit_rate;
2781 
2782  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2783  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2784  st->codecpar->codec_type = codec_ul->id;
2785 
2786  if (!descriptor) {
2787  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2788  continue;
2789  }
2790  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2791  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2792  essence_container_ul = &descriptor->essence_container_ul;
2793  source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2794  if (source_track->wrapping == UnknownWrapped)
2795  av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2796  /* HACK: replacing the original key with mxf_encrypted_essence_container
2797  * is not allowed according to s429-6, try to find correct information anyway */
2798  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2799  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2800  for (k = 0; k < mxf->metadata_sets_count; k++) {
2801  MXFMetadataSet *metadata = mxf->metadata_sets[k];
2802  if (metadata->type == CryptoContext) {
2803  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2804  break;
2805  }
2806  }
2807  }
2808 
2809  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2810  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2811  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2812  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2813  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2814  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2815  }
2816 
2817  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2818  avcodec_get_name(st->codecpar->codec_id));
2819  for (k = 0; k < 16; k++) {
2820  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2821  descriptor->essence_codec_ul[k]);
2822  if (!(k+1 & 19) || k == 5)
2823  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2824  }
2825  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2826 
2827  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2828  if (source_package->name && source_package->name[0])
2829  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2830  if (material_track->name && material_track->name[0])
2831  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2832 
2833  mxf_parse_physical_source_package(mxf, source_track, st);
2834 
2835  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2836  source_track->intra_only = mxf_is_intra_only(descriptor);
2837  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2838  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2839  st->codecpar->codec_id = container_ul->id;
2840  st->codecpar->width = descriptor->width;
2841  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2842  switch (descriptor->frame_layout) {
2843  case FullFrame:
2844  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2845  break;
2846  case OneField:
2847  /* Every other line is stored and needs to be duplicated. */
2848  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2849  break; /* The correct thing to do here is fall through, but by breaking we might be
2850  able to decode some streams at half the vertical resolution, rather than not al all.
2851  It's also for compatibility with the old behavior. */
2852  case MixedFields:
2853  break;
2854  case SegmentedFrame:
2855  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2856  case SeparateFields:
2857  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2858  descriptor->video_line_map[0], descriptor->video_line_map[1],
2859  descriptor->field_dominance);
2860  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2861  /* Detect coded field order from VideoLineMap:
2862  * (even, even) => bottom field coded first
2863  * (even, odd) => top field coded first
2864  * (odd, even) => top field coded first
2865  * (odd, odd) => bottom field coded first
2866  */
2867  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2868  switch (descriptor->field_dominance) {
2869  case MXF_FIELD_DOMINANCE_DEFAULT:
2870  case MXF_FIELD_DOMINANCE_FF:
2871  st->codecpar->field_order = AV_FIELD_TT;
2872  break;
2873  case MXF_FIELD_DOMINANCE_FL:
2874  st->codecpar->field_order = AV_FIELD_TB;
2875  break;
2876  default:
2877  avpriv_request_sample(mxf->fc,
2878  "Field dominance %d support",
2879  descriptor->field_dominance);
2880  }
2881  } else {
2882  switch (descriptor->field_dominance) {
2883  case MXF_FIELD_DOMINANCE_DEFAULT:
2884  case MXF_FIELD_DOMINANCE_FF:
2885  st->codecpar->field_order = AV_FIELD_BB;
2886  break;
2887  case MXF_FIELD_DOMINANCE_FL:
2888  st->codecpar->field_order = AV_FIELD_BT;
2889  break;
2890  default:
2891  avpriv_request_sample(mxf->fc,
2892  "Field dominance %d support",
2893  descriptor->field_dominance);
2894  }
2895  }
2896  }
2897  /* Turn field height into frame height. */
2898  st->codecpar->height *= 2;
2899  break;
2900  default:
2901  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2902  }
2903 
2904  if (mxf_is_st_422(essence_container_ul)) {
2905  switch ((*essence_container_ul)[14]) {
2906  case 2: /* Cn: Clip- wrapped Picture Element */
2907  case 3: /* I1: Interlaced Frame, 1 field/KLV */
2908  case 4: /* I2: Interlaced Frame, 2 fields/KLV */
2909  case 6: /* P1: Frame- wrapped Picture Element */
2910  st->avg_frame_rate = source_track->edit_rate;
2911  st->r_frame_rate = st->avg_frame_rate;
2912  break;
2913  case 5: /* F1: Field-wrapped Picture Element */
2914  st->avg_frame_rate = av_mul_q(av_make_q(2, 1), source_track->edit_rate);
2915  st->r_frame_rate = st->avg_frame_rate;
2916  break;
2917  default:
2918  break;
2919  }
2920  }
2921 
2922  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2923  switch (descriptor->essence_codec_ul[14]) {
2924  case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2925  case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2926  case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2927  case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2928  case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2929  case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2930  }
2931  }
2932 
2933  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2934  st->codecpar->format = descriptor->pix_fmt;
2935  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2936  pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2937  &descriptor->essence_codec_ul);
2938  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2939  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2940  st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2941  &descriptor->essence_codec_ul)->id;
2942  if (!st->codecpar->codec_tag) {
2943  /* support files created before RP224v10 by defaulting to UYVY422
2944  if subsampling is 4:2:2 and component depth is 8-bit */
2945  if (descriptor->horiz_subsampling == 2 &&
2946  descriptor->vert_subsampling == 1 &&
2947  descriptor->component_depth == 8) {
2948  st->codecpar->format = AV_PIX_FMT_UYVY422;
2949  }
2950  }
2951  }
2952  }
2953  }
2954  sti->need_parsing = AVSTREAM_PARSE_HEADERS;
2955  if (material_track->sequence->origin) {
2956  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2957  }
2958  if (source_track->sequence->origin) {
2959  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2960  }
2961  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2962  sti->display_aspect_ratio = descriptor->aspect_ratio;
2963  st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2964  st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2965  st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2966  st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2967  if (descriptor->mastering) {
2968  ret = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2969  (uint8_t *)descriptor->mastering,
2970  sizeof(*descriptor->mastering));
2971  if (ret < 0)
2972  goto fail_and_free;
2973  descriptor->mastering = NULL;
2974  }
2975  if (descriptor->coll) {
2976  ret = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2977  (uint8_t *)descriptor->coll,
2978  descriptor->coll_size);
2979  if (ret < 0)
2980  goto fail_and_free;
2981  descriptor->coll = NULL;
2982  }
2983  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2984  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2985  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2986  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))
2987  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2988  st->codecpar->ch_layout.nb_channels = descriptor->channels;
2989 
2990  if (descriptor->sample_rate.den > 0) {
2991  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2992  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2993  } else {
2994  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2995  "found for stream #%d, time base forced to 1/48000\n",
2996  descriptor->sample_rate.num, descriptor->sample_rate.den,
2997  st->index);
2998  avpriv_set_pts_info(st, 64, 1, 48000);
2999  }
3000 
3001  /* if duration is set, rescale it from EditRate to SampleRate */
3002  if (st->duration != AV_NOPTS_VALUE)
3003  st->duration = av_rescale_q(st->duration,
3004  av_inv_q(material_track->edit_rate),
3005  st->time_base);
3006 
3007  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
3008  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
3009  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3010  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
3011  else if (descriptor->bits_per_sample == 32)
3012  st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
3013  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
3014  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3015  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
3016  else if (descriptor->bits_per_sample == 32)
3017  st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
3018  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
3019  sti->need_parsing = AVSTREAM_PARSE_FULL;
3020  }
3021  st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
3022 
3023  if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
3024  av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
3025  return AVERROR_INVALIDDATA;
3026  }
3027 
3028  ret = parse_mca_labels(mxf, source_track, descriptor, st);
3029  if (ret < 0)
3030  return ret;
3031  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
3032  enum AVMediaType type;
3033  container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
3034  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
3035  st->codecpar->codec_id = container_ul->id;
3036  type = avcodec_get_type(st->codecpar->codec_id);
3037  if (type == AVMEDIA_TYPE_SUBTITLE)
3038  st->codecpar->codec_type = type;
3039  if (container_ul->desc)
3040  av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
3041  if (mxf->eia608_extract &&
3042  !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
3043  st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
3044  st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
3045  }
3046  }
3047  if (!descriptor->extradata)
3048  parse_ffv1_sub_descriptor(mxf, source_track, descriptor, st);
3049  if (descriptor->extradata) {
3050  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
3051  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
3052  }
3053  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3054  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
3055  &descriptor->essence_codec_ul)->id;
3056  if (coded_width)
3057  st->codecpar->width = coded_width;
3058  ret = ff_generate_avci_extradata(st);
3059  if (ret < 0)
3060  return ret;
3061  }
3062  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
3063  /* TODO: decode timestamps */
3064  sti->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
3065  }
3066  }
3067 
3068  for (int i = 0; i < mxf->fc->nb_streams; i++) {
3069  MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
3070  if (track1 && track1->body_sid) {
3071  for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
3072  MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
3073  if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
3074  if (track1->wrapping == UnknownWrapped)
3075  track1->wrapping = track2->wrapping;
3076  else if (track2->wrapping == UnknownWrapped)
3077  track2->wrapping = track1->wrapping;
3078  else
3079  av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
3080  "with different wrapping\n", i, j, track1->body_sid);
3081  }
3082  }
3083  }
3084  }
3085 
3086  ret = 0;
3087 fail_and_free:
3088  return ret;
3089 }
3090 
3091 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
3092 {
3093  struct tm time = { 0 };
3094  int msecs;
3095  time.tm_year = (timestamp >> 48) - 1900;
3096  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
3097  time.tm_mday = (timestamp >> 32 & 0xFF);
3098  time.tm_hour = (timestamp >> 24 & 0xFF);
3099  time.tm_min = (timestamp >> 16 & 0xFF);
3100  time.tm_sec = (timestamp >> 8 & 0xFF);
3101  msecs = (timestamp & 0xFF) * 4;
3102 
3103  /* Clip values for legacy reasons. Maybe we should return error instead? */
3104  time.tm_mon = av_clip(time.tm_mon, 0, 11);
3105  time.tm_mday = av_clip(time.tm_mday, 1, 31);
3106  time.tm_hour = av_clip(time.tm_hour, 0, 23);
3107  time.tm_min = av_clip(time.tm_min, 0, 59);
3108  time.tm_sec = av_clip(time.tm_sec, 0, 59);
3109  msecs = av_clip(msecs, 0, 999);
3110 
3111  return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
3112 }
3113 
3114 #define SET_STR_METADATA(pb, name, str) do { \
3115  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
3116  return ret; \
3117  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3118 } while (0)
3119 
3120 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
3121  major = avio_rb16(pb); \
3122  minor = avio_rb16(pb); \
3123  tertiary = avio_rb16(pb); \
3124  patch = avio_rb16(pb); \
3125  release = avio_rb16(pb); \
3126  if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
3127  return ret; \
3128  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3129 } while (0)
3130 
3131 #define SET_UID_METADATA(pb, name, var, str) do { \
3132  char uuid_str[2 * AV_UUID_LEN + 4 + 1]; \
3133  avio_read(pb, var, 16); \
3134  av_uuid_unparse(uid, uuid_str); \
3135  av_dict_set(&s->metadata, name, uuid_str, 0); \
3136 } while (0)
3137 
3138 #define SET_TS_METADATA(pb, name, var, str) do { \
3139  var = avio_rb64(pb); \
3140  if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
3141  return ret; \
3142 } while (0)
3143 
3144 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
3145 {
3146  MXFContext *mxf = arg;
3147  AVFormatContext *s = mxf->fc;
3148  int ret;
3149  UID uid = { 0 };
3150  char *str = NULL;
3151  uint64_t ts;
3152  uint16_t major, minor, tertiary, patch, release;
3153  switch (tag) {
3154  case 0x3C01:
3155  SET_STR_METADATA(pb, "company_name", str);
3156  break;
3157  case 0x3C02:
3158  SET_STR_METADATA(pb, "product_name", str);
3159  break;
3160  case 0x3C03:
3161  SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
3162  break;
3163  case 0x3C04:
3164  SET_STR_METADATA(pb, "product_version", str);
3165  break;
3166  case 0x3C05:
3167  SET_UID_METADATA(pb, "product_uid", uid, str);
3168  break;
3169  case 0x3C06:
3170  SET_TS_METADATA(pb, "modification_date", ts, str);
3171  break;
3172  case 0x3C07:
3173  SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
3174  break;
3175  case 0x3C08:
3176  SET_STR_METADATA(pb, "application_platform", str);
3177  break;
3178  case 0x3C09:
3179  SET_UID_METADATA(pb, "generation_uid", uid, str);
3180  break;
3181  case 0x3C0A:
3182  SET_UID_METADATA(pb, "uid", uid, str);
3183  break;
3184  }
3185  return 0;
3186 }
3187 
3188 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
3189 {
3190  MXFContext *mxf = arg;
3191  AVFormatContext *s = mxf->fc;
3192  int ret;
3193  char *str = NULL;
3194 
3195  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
3196  SET_STR_METADATA(pb, "project_name", str);
3197  }
3198  return 0;
3199 }
3200 
3201 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
3202  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
3203  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
3204  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
3205  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
3206  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
3207  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
3208  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
3209  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
3210  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
3211  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
3212  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
3213  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
3214  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
3215  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
3216  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
3217  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
3218  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
3219  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
3220  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
3221  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
3222  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
3223  { { 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 */
3224  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
3225  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
3226  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
3227  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
3228  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
3229  { { 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 */
3230  { { 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 */
3231  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
3232  { { 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 */
3233  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6b,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), AudioChannelLabelSubDescriptor },
3234  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6c,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), SoundfieldGroupLabelSubDescriptor },
3235  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6d,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor },
3236  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x81,0x03 }, mxf_read_ffv1_sub_descriptor, sizeof(MXFFFV1SubDescriptor), FFV1SubDescriptor },
3237  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
3238  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
3239  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
3240  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
3241  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
3242  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
3243  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
3244  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
3245 };
3246 
3247 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
3248 {
3249  ctx->type = type;
3250  ctx->partition_score = partition_score(partition);
3251  switch (type){
3252  case MultipleDescriptor:
3253  case Descriptor:
3254  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
3255  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
3256  break;
3257  default:
3258  break;
3259  }
3260  return 0;
3261 }
3262 
3263 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
3264 {
3265  AVIOContext *pb = mxf->fc->pb;
3266  uint64_t klv_end = avio_tell(pb) + klv->length;
3267  MXFMetadataSet *meta;
3268  void *ctx;
3269 
3270  if (ctx_size) {
3271  meta = av_mallocz(ctx_size);
3272  if (!meta)
3273  return AVERROR(ENOMEM);
3274  ctx = meta;
3275  mxf_metadataset_init(meta, type, mxf->current_partition);
3276  } else {
3277  meta = NULL;
3278  ctx = mxf;
3279  }
3280  while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
3281  int ret;
3282  int tag = avio_rb16(pb);
3283  int size = avio_rb16(pb); /* KLV specified by 0x53 */
3284  int64_t next = avio_tell(pb);
3285  UID uid = {0};
3286  if (next < 0 || next > INT64_MAX - size) {
3287  if (meta) {
3288  mxf_free_metadataset(&meta, 1);
3289  }
3290  return next < 0 ? next : AVERROR_INVALIDDATA;
3291  }
3292  next += size;
3293 
3294  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
3295  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
3296  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
3297  continue;
3298  }
3299  if (tag > 0x7FFF) { /* dynamic tag */
3300  int i;
3301  for (i = 0; i < mxf->local_tags_count; i++) {
3302  int local_tag = AV_RB16(mxf->local_tags+i*18);
3303  if (local_tag == tag) {
3304  memcpy(uid, mxf->local_tags+i*18+2, 16);
3305  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
3306  PRINT_KEY(mxf->fc, "uid", uid);
3307  }
3308  }
3309  }
3310  if (meta && tag == 0x3C0A) {
3311  avio_read(pb, meta->uid, 16);
3312  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
3313  if (meta) {
3314  mxf_free_metadataset(&meta, 1);
3315  }
3316  return ret;
3317  }
3318 
3319  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
3320  * it extending past the end of the KLV though (zzuf5.mxf). */
3321  if (avio_tell(pb) > klv_end) {
3322  if (meta) {
3323  mxf_free_metadataset(&meta, 1);
3324  }
3325 
3326  av_log(mxf->fc, AV_LOG_ERROR,
3327  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
3328  tag, klv->offset);
3329  return AVERROR_INVALIDDATA;
3330  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
3331  avio_seek(pb, next, SEEK_SET);
3332  }
3333  return meta ? mxf_add_metadata_set(mxf, &meta) : 0;
3334 }
3335 
3336 /**
3337  * Matches any partition pack key, in other words:
3338  * - HeaderPartition
3339  * - BodyPartition
3340  * - FooterPartition
3341  * @return non-zero if the key is a partition pack key, zero otherwise
3342  */
3343 static int mxf_is_partition_pack_key(UID key)
3344 {
3345  //NOTE: this is a little lax since it doesn't constraint key[14]
3346  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
3347  key[13] >= 2 && key[13] <= 4;
3348 }
3349 
3350 /**
3351  * Parses a metadata KLV
3352  * @return <0 on error, 0 otherwise
3353  */
3354 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
3355  int ctx_size, enum MXFMetadataSetType type)
3356 {
3357  AVFormatContext *s = mxf->fc;
3358  int res;
3359  if (klv.key[5] == 0x53) {
3360  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
3361  } else {
3362  uint64_t next = avio_tell(s->pb) + klv.length;
3363  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
3364 
3365  /* only seek forward, else this can loop for a long time */
3366  if (avio_tell(s->pb) > next) {
3367  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
3368  klv.offset);
3369  return AVERROR_INVALIDDATA;
3370  }
3371 
3372  avio_seek(s->pb, next, SEEK_SET);
3373  }
3374  if (res < 0) {
3375  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3376  return res;
3377  }
3378  return 0;
3379 }
3380 
3381 /**
3382  * Seeks to the previous partition and parses it, if possible
3383  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3384  */
3385 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3386 {
3387  AVIOContext *pb = mxf->fc->pb;
3388  KLVPacket klv;
3389  int64_t current_partition_ofs;
3390  int ret;
3391 
3392  if (!mxf->current_partition ||
3393  mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3394  return 0; /* we've parsed all partitions */
3395 
3396  /* seek to previous partition */
3397  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3398  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3399  mxf->current_partition = NULL;
3400 
3401  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3402 
3403  /* Make sure this is actually a PartitionPack, and if so parse it.
3404  * See deadlock2.mxf
3405  */
3406  if ((ret = klv_read_packet(&klv, pb)) < 0) {
3407  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3408  return ret;
3409  }
3410 
3411  if (!mxf_is_partition_pack_key(klv.key)) {
3412  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3413  return AVERROR_INVALIDDATA;
3414  }
3415 
3416  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3417  * can point to just before the current partition, causing klv_read_packet()
3418  * to sync back up to it. See deadlock3.mxf
3419  */
3420  if (klv.offset >= current_partition_ofs) {
3421  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3422  PRIx64 " indirectly points to itself\n", current_partition_ofs);
3423  return AVERROR_INVALIDDATA;
3424  }
3425 
3426  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3427  return ret;
3428 
3429  return 1;
3430 }
3431 
3432 /**
3433  * Called when essence is encountered
3434  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3435  */
3436 static int mxf_parse_handle_essence(MXFContext *mxf)
3437 {
3438  AVIOContext *pb = mxf->fc->pb;
3439  int64_t ret;
3440 
3441  if (mxf->parsing_backward) {
3442  return mxf_seek_to_previous_partition(mxf);
3443  } else {
3444  if (!mxf->footer_partition) {
3445  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3446  return 0;
3447  }
3448 
3449  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3450 
3451  /* remember where we were so we don't end up seeking further back than this */
3452  mxf->last_forward_tell = avio_tell(pb);
3453 
3454  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3455  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3456  return -1;
3457  }
3458 
3459  /* seek to FooterPartition and parse backward */
3460  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3461  av_log(mxf->fc, AV_LOG_ERROR,
3462  "failed to seek to FooterPartition @ 0x%" PRIx64
3463  " (%"PRId64") - partial file?\n",
3464  mxf->run_in + mxf->footer_partition, ret);
3465  return ret;
3466  }
3467 
3468  mxf->current_partition = NULL;
3469  mxf->parsing_backward = 1;
3470  }
3471 
3472  return 1;
3473 }
3474 
3475 /**
3476  * Called when the next partition or EOF is encountered
3477  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3478  */
3479 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3480 {
3481  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3482 }
3483 
3484 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3485 {
3486  for (int i = 0; i < s->nb_streams; i++) {
3487  MXFTrack *track = s->streams[i]->priv_data;
3488  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3489  return track->wrapping;
3490  }
3491  return UnknownWrapped;
3492 }
3493 
3494 /**
3495  * Figures out the proper offset and length of the essence container in each partition
3496  */
3497 static void mxf_compute_essence_containers(AVFormatContext *s)
3498 {
3499  MXFContext *mxf = s->priv_data;
3500  int x;
3501 
3502  for (x = 0; x < mxf->partitions_count; x++) {
3503  MXFPartition *p = &mxf->partitions[x];
3504  MXFWrappingScheme wrapping;
3505 
3506  if (!p->body_sid)
3507  continue; /* BodySID == 0 -> no essence */
3508 
3509  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3510  * otherwise we point essence_offset at the key of the first essence KLV.
3511  */
3512 
3513  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3514 
3515  if (wrapping == ClipWrapped) {
3516  p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3517  p->essence_length = p->first_essence_klv.length;
3518  } else {
3519  p->essence_offset = p->first_essence_klv.offset;
3520 
3521  /* essence container spans to the next partition */
3522  if (x < mxf->partitions_count - 1)
3523  p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
3524 
3525  if (p->essence_length < 0) {
3526  /* next ThisPartition < essence_offset */
3527  p->essence_length = 0;
3528  av_log(mxf->fc, AV_LOG_ERROR,
3529  "partition %i: bad ThisPartition = %"PRIX64"\n",
3530  x+1, mxf->partitions[x+1].this_partition);
3531  }
3532  }
3533  }
3534 }
3535 
3536 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3537 {
3538  int i;
3539  for (i = 0; i < mxf->nb_index_tables; i++)
3540  if (mxf->index_tables[i].index_sid == index_sid)
3541  return &mxf->index_tables[i];
3542  return NULL;
3543 }
3544 
3545 /**
3546  * Deal with the case where for some audio atoms EditUnitByteCount is
3547  * very small (2, 4..). In those cases we should read more than one
3548  * sample per call to mxf_read_packet().
3549  */
3550 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3551 {
3552  MXFTrack *track = st->priv_data;
3553  MXFIndexTable *t;
3554 
3555  if (!track)
3556  return;
3557  track->edit_units_per_packet = 1;
3558  if (track->wrapping != ClipWrapped)
3559  return;
3560 
3561  t = mxf_find_index_table(mxf, track->index_sid);
3562 
3563  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3564  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3565  !is_pcm(st->codecpar->codec_id) ||
3566  !t ||
3567  t->nb_segments != 1 ||
3568  t->segments[0]->edit_unit_byte_count >= 32)
3569  return;
3570 
3571  /* arbitrarily default to 48 kHz PAL audio frame size */
3572  /* TODO: We could compute this from the ratio between the audio
3573  * and video edit rates for 48 kHz NTSC we could use the
3574  * 1802-1802-1802-1802-1801 pattern. */
3575  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3576 }
3577 
3578 /**
3579  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3580  */
3581 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3582 {
3583  MXFTrack *track = st->priv_data;
3584  MXFIndexTableSegment *segment = NULL;
3585  MXFPartition *p = NULL;
3586  int essence_partition_count = 0;
3587  int edit_unit_byte_count = 0;
3588  int i, ret;
3589 
3590  if (!track || track->wrapping != ClipWrapped)
3591  return 0;
3592 
3593  /* check if track already has an IndexTableSegment */
3594  for (i = 0; i < mxf->metadata_sets_count; i++) {
3595  if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3596  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3597  if (s->body_sid == track->body_sid)
3598  return 0;
3599  }
3600  }
3601 
3602  /* find the essence partition */
3603  for (i = 0; i < mxf->partitions_count; i++) {
3604  /* BodySID == 0 -> no essence */
3605  if (mxf->partitions[i].body_sid != track->body_sid)
3606  continue;
3607 
3608  p = &mxf->partitions[i];
3609  essence_partition_count++;
3610  }
3611 
3612  /* only handle files with a single essence partition */
3613  if (essence_partition_count != 1)
3614  return 0;
3615 
3616  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3617  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) *
3618  st->codecpar->ch_layout.nb_channels) >> 3;
3619  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3620  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3621  }
3622 
3623  if (edit_unit_byte_count <= 0)
3624  return 0;
3625 
3626  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);
3627 
3628  if (!(segment = av_mallocz(sizeof(*segment))))
3629  return AVERROR(ENOMEM);
3630 
3631  if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3632  return ret;
3633 
3634  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3635  * using the same SID for index is forbidden in MXF. */
3636  if (!track->index_sid)
3637  track->index_sid = track->body_sid;
3638 
3639  segment->meta.type = IndexTableSegment;
3640  /* stream will be treated as small EditUnitByteCount */
3641  segment->edit_unit_byte_count = edit_unit_byte_count;
3642  segment->index_start_position = 0;
3643  segment->index_duration = st->duration;
3644  segment->index_edit_rate = av_inv_q(st->time_base);
3645  segment->index_sid = track->index_sid;
3646  segment->body_sid = p->body_sid;
3647  return 0;
3648 }
3649 
3650 static void mxf_read_random_index_pack(AVFormatContext *s)
3651 {
3652  MXFContext *mxf = s->priv_data;
3653  uint32_t length;
3654  int64_t file_size, max_rip_length, min_rip_length;
3655  KLVPacket klv;
3656 
3657  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3658  return;
3659 
3660  file_size = avio_size(s->pb);
3661 
3662  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3663  * The limit below assumes a file with nothing but partition packs and a RIP.
3664  * Before changing this, consider that a muxer may place each sample in its own partition.
3665  *
3666  * 105 is the size of the smallest possible PartitionPack
3667  * 12 is the size of each RIP entry
3668  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3669  */
3670  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3671  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3672 
3673  /* We're only interested in RIPs with at least two entries.. */
3674  min_rip_length = 16+1+24+4;
3675 
3676  /* See S377m section 11 */
3677  avio_seek(s->pb, file_size - 4, SEEK_SET);
3678  length = avio_rb32(s->pb);
3679 
3680  if (length < min_rip_length || length > max_rip_length)
3681  goto end;
3682  avio_seek(s->pb, file_size - length, SEEK_SET);
3683  if (klv_read_packet(&klv, s->pb) < 0 ||
3684  !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3685  goto end;
3686  if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3687  av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3688  goto end;
3689  }
3690 
3691  avio_skip(s->pb, klv.length - 12);
3692  mxf->footer_partition = avio_rb64(s->pb);
3693 
3694  /* sanity check */
3695  if (mxf->run_in + mxf->footer_partition >= file_size) {
3696  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3697  mxf->footer_partition = 0;
3698  }
3699 
3700 end:
3701  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3702 }
3703 
3704 static int mxf_read_header(AVFormatContext *s)
3705 {
3706  MXFContext *mxf = s->priv_data;
3707  KLVPacket klv;
3708  int64_t essence_offset = 0;
3709  int ret;
3710  int64_t run_in;
3711 
3712  mxf->last_forward_tell = INT64_MAX;
3713 
3714  if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3715  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3716  return AVERROR_INVALIDDATA;
3717  }
3718  avio_seek(s->pb, -14, SEEK_CUR);
3719  mxf->fc = s;
3720  run_in = avio_tell(s->pb);
3721  if (run_in < 0 || run_in > RUN_IN_MAX)
3722  return AVERROR_INVALIDDATA;
3723  mxf->run_in = run_in;
3724 
3725  mxf_read_random_index_pack(s);
3726 
3727  while (!avio_feof(s->pb)) {
3728  const MXFMetadataReadTableEntry *metadata;
3729 
3730  if (klv_read_packet(&klv, s->pb) < 0) {
3731  /* EOF - seek to previous partition or stop */
3732  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3733  break;
3734  else
3735  continue;
3736  }
3737 
3738  PRINT_KEY(s, "read header", klv.key);
3739  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3740  if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key)) ||
3741  IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3742  IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3743  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3744  IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3745  IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3746 
3747  if (!mxf->current_partition) {
3748  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3749  return AVERROR_INVALIDDATA;
3750  }
3751 
3752  if (!mxf->current_partition->first_essence_klv.offset)
3753  mxf->current_partition->first_essence_klv = klv;
3754 
3755  if (!essence_offset)
3756  essence_offset = klv.offset;
3757 
3758  /* seek to footer, previous partition or stop */
3759  if (mxf_parse_handle_essence(mxf) <= 0)
3760  break;
3761  continue;
3762  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3763  /* next partition pack - keep going, seek to previous partition or stop */
3764  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3765  break;
3766  else if (mxf->parsing_backward)
3767  continue;
3768  /* we're still parsing forward. proceed to parsing this partition pack */
3769  }
3770 
3771  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3772  if (IS_KLV_KEY(klv.key, metadata->key)) {
3773  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3774  return ret;
3775  break;
3776  }
3777  }
3778  if (!metadata->read) {
3779  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3780  UID_ARG(klv.key));
3781  avio_skip(s->pb, klv.length);
3782  }
3783  }
3784  /* FIXME avoid seek */
3785  if (!essence_offset) {
3786  av_log(s, AV_LOG_ERROR, "no essence\n");
3787  return AVERROR_INVALIDDATA;
3788  }
3789  avio_seek(s->pb, essence_offset, SEEK_SET);
3790 
3791  /* we need to do this before computing the index tables
3792  * to be able to fill in zero IndexDurations with st->duration */
3793  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3794  return ret;
3795 
3796  for (int i = 0; i < s->nb_streams; i++)
3797  mxf_handle_missing_index_segment(mxf, s->streams[i]);
3798 
3799  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3800  return ret;
3801 
3802  if (mxf->nb_index_tables > 1) {
3803  /* TODO: look up which IndexSID to use via EssenceContainerData */
3804  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3805  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3806  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3807  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3808  return AVERROR_INVALIDDATA;
3809  }
3810 
3811  mxf_compute_essence_containers(s);
3812 
3813  for (int i = 0; i < s->nb_streams; i++)
3814  mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3815 
3816  return 0;
3817 }
3818 
3819 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3820 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3821 {
3822  int64_t a, b, m, offset;
3823  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3824 
3825  if (!t || track->original_duration <= 0)
3826  return -1;
3827 
3828  a = -1;
3829  b = track->original_duration;
3830 
3831  while (b - a > 1) {
3832  m = (a + b) >> 1;
3833  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3834  return -1;
3835  if (offset < current_offset)
3836  a = m;
3837  else
3838  b = m;
3839  }
3840 
3841  *edit_unit_out = b;
3842 
3843  return 0;
3844 }
3845 
3846 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3847  int64_t edit_unit)
3848 {
3849  MXFTrack *track = st->priv_data;
3850  AVRational time_base = av_inv_q(track->edit_rate);
3851  AVRational sample_rate = av_inv_q(st->time_base);
3852 
3853  // For non-audio sample_count equals current edit unit
3854  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3855  return edit_unit;
3856 
3857  if ((sample_rate.num / sample_rate.den) == 48000) {
3858  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3859  } else {
3860  int remainder = (sample_rate.num * time_base.num) %
3861  (time_base.den * sample_rate.den);
3862  if (remainder)
3863  av_log(mxf->fc, AV_LOG_WARNING,
3864  "seeking detected on stream #%d with time base (%d/%d) and "
3865  "sample rate (%d/%d), audio pts won't be accurate.\n",
3866  st->index, time_base.num, time_base.den,
3867  sample_rate.num, sample_rate.den);
3868  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3869  }
3870 }
3871 
3872 /**
3873  * Make sure track->sample_count is correct based on what offset we're currently at.
3874  * Also determine the next edit unit (or packet) offset.
3875  * @return next_ofs if OK, <0 on error
3876  */
3877 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3878 {
3879  int64_t next_ofs = -1;
3880  MXFTrack *track = st->priv_data;
3881  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3882  int64_t new_edit_unit;
3883  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3884 
3885  if (!t || track->wrapping == UnknownWrapped)
3886  return -1;
3887 
3888  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3889  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3890  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3891  return -1;
3892  }
3893 
3894  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3895  if (next_ofs > current_offset)
3896  return next_ofs;
3897 
3898  if (!resync) {
3899  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3900  return -1;
3901  }
3902 
3903  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3904  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3905  return -1;
3906  }
3907 
3908  new_edit_unit--;
3909  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3910  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);
3911 
3912  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3913 }
3914 
3915 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3916  AVPacket *pkt)
3917 {
3918  AVStream *st = mxf->fc->streams[pkt->stream_index];
3919  MXFTrack *track = st->priv_data;
3920  int64_t bits_per_sample = par->bits_per_coded_sample;
3921 
3922  if (!bits_per_sample)
3923  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3924 
3925  pkt->pts = track->sample_count;
3926 
3927  if (par->ch_layout.nb_channels <= 0 ||
3928  bits_per_sample <= 0 ||
3929  par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
3930  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);
3931  else
3932  track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
3933 
3934  return 0;
3935 }
3936 
3937 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3938 {
3939  AVCodecParameters *par = st->codecpar;
3940  MXFTrack *track = st->priv_data;
3941 
3942  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3943  /* see if we have an index table to derive timestamps from */
3944  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3945 
3946  if (t && track->sample_count < t->nb_ptses) {
3947  pkt->dts = track->sample_count + t->first_dts;
3948  pkt->pts = t->ptses[track->sample_count];
3949  } else if (track->intra_only) {
3950  /* intra-only -> PTS = EditUnit.
3951  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3952  pkt->pts = track->sample_count;
3953  }
3954  track->sample_count++;
3955  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3956  int ret = mxf_set_audio_pts(mxf, par, pkt);
3957  if (ret < 0)
3958  return ret;
3959  } else if (track) {
3960  pkt->dts = pkt->pts = track->sample_count;
3961  pkt->duration = 1;
3962  track->sample_count++;
3963  }
3964  return 0;
3965 }
3966 
3967 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3968 {
3969  KLVPacket klv;
3970  MXFContext *mxf = s->priv_data;
3971  int ret;
3972 
3973  while (1) {
3974  int64_t max_data_size;
3975  int64_t pos = avio_tell(s->pb);
3976 
3977  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3978  mxf->current_klv_data = (KLVPacket){{0}};
3979  ret = klv_read_packet(&klv, s->pb);
3980  if (ret < 0)
3981  break;
3982  max_data_size = klv.length;
3983  pos = klv.next_klv - klv.length;
3984  PRINT_KEY(s, "read packet", klv.key);
3985  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3986  if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key))) {
3987  ret = mxf_decrypt_triplet(s, pkt, &klv);
3988  if (ret < 0) {
3989  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3990  return ret;
3991  }
3992  return 0;
3993  }
3994  } else {
3995  klv = mxf->current_klv_data;
3996  max_data_size = klv.next_klv - pos;
3997  }
3998  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3999  IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
4000  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
4001  int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
4002  int index = mxf_get_stream_index(s, &klv, body_sid);
4003  int64_t next_ofs;
4004  AVStream *st;
4005  MXFTrack *track;
4006 
4007  if (index < 0) {
4008  av_log(s, AV_LOG_ERROR,
4009  "error getting stream index %"PRIu32"\n",
4010  AV_RB32(klv.key + 12));
4011  goto skip;
4012  }
4013 
4014  st = s->streams[index];
4015  track = st->priv_data;
4016 
4017  if (s->streams[index]->discard == AVDISCARD_ALL)
4018  goto skip;
4019 
4020  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
4021 
4022  if (track->wrapping != FrameWrapped) {
4023  int64_t size;
4024 
4025  if (next_ofs <= 0) {
4026  // If we have no way to packetize the data, then return it in chunks...
4027  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
4028  ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
4029  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
4030  }
4031  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
4032  } else {
4033  if ((size = next_ofs - pos) <= 0) {
4034  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
4035  mxf->current_klv_data = (KLVPacket){{0}};
4036  return AVERROR_INVALIDDATA;
4037  }
4038  // We must not overread, because the next edit unit might be in another KLV
4039  if (size > max_data_size)
4040  size = max_data_size;
4041  }
4042 
4043  mxf->current_klv_data = klv;
4044  klv.offset = pos;
4045  klv.length = size;
4046  klv.next_klv = klv.offset + klv.length;
4047  }
4048 
4049  /* check for 8 channels AES3 element */
4050  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
4051  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
4052  pkt, klv.length);
4053  if (ret < 0) {
4054  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
4055  mxf->current_klv_data = (KLVPacket){{0}};
4056  return ret;
4057  }
4058  } else if (mxf->eia608_extract &&
4059  s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4060  ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4061  if (ret < 0) {
4062  mxf->current_klv_data = (KLVPacket){{0}};
4063  return ret;
4064  }
4065  } else {
4066  ret = av_get_packet(s->pb, pkt, klv.length);
4067  if (ret < 0) {
4068  mxf->current_klv_data = (KLVPacket){{0}};
4069  return ret;
4070  }
4071  }
4072  pkt->stream_index = index;
4073  pkt->pos = klv.offset;
4074 
4075  ret = mxf_set_pts(mxf, st, pkt);
4076  if (ret < 0) {
4077  mxf->current_klv_data = (KLVPacket){{0}};
4078  return ret;
4079  }
4080 
4081  /* seek for truncated packets */
4082  avio_seek(s->pb, klv.next_klv, SEEK_SET);
4083 
4084  return 0;
4085  } else {
4086  skip:
4087  avio_skip(s->pb, max_data_size);
4088  mxf->current_klv_data = (KLVPacket){{0}};
4089  }
4090  }
4091  return avio_feof(s->pb) ? AVERROR_EOF : ret;
4092 }
4093 
4094 static int mxf_read_close(AVFormatContext *s)
4095 {
4096  MXFContext *mxf = s->priv_data;
4097  int i;
4098 
4099  av_freep(&mxf->packages_refs);
4100  av_freep(&mxf->essence_container_data_refs);
4101 
4102  for (i = 0; i < s->nb_streams; i++)
4103  s->streams[i]->priv_data = NULL;
4104 
4105  for (i = 0; i < mxf->metadata_sets_count; i++) {
4106  mxf_free_metadataset(mxf->metadata_sets + i, 1);
4107  }
4108  mxf->metadata_sets_count = 0;
4109  av_freep(&mxf->partitions);
4110  av_freep(&mxf->metadata_sets);
4111  av_freep(&mxf->aesc);
4112  av_freep(&mxf->local_tags);
4113 
4114  if (mxf->index_tables) {
4115  for (i = 0; i < mxf->nb_index_tables; i++) {
4116  av_freep(&mxf->index_tables[i].segments);
4117  av_freep(&mxf->index_tables[i].ptses);
4118  av_freep(&mxf->index_tables[i].fake_index);
4119  av_freep(&mxf->index_tables[i].offsets);
4120  }
4121  }
4122  av_freep(&mxf->index_tables);
4123 
4124  return 0;
4125 }
4126 
4127 static int mxf_probe(const AVProbeData *p) {
4128  const uint8_t *bufp = p->buf;
4129  const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4130 
4131  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4132  return 0;
4133 
4134  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4135  end -= sizeof(mxf_header_partition_pack_key);
4136 
4137  for (; bufp < end;) {
4138  if (!((bufp[13] - 1) & 0xF2)){
4139  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4140  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4141  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4142  AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
4143  return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4144  bufp ++;
4145  } else
4146  bufp += 10;
4147  }
4148 
4149  return 0;
4150 }
4151 
4152 /* rudimentary byte seek */
4153 /* XXX: use MXF Index */
4154 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4155 {
4156  AVStream *st = s->streams[stream_index];
4157  int64_t seconds;
4158  MXFContext* mxf = s->priv_data;
4159  int64_t seekpos;
4160  int i, ret;
4161  MXFIndexTable *t;
4162  MXFTrack *source_track = st->priv_data;
4163 
4164  if (!source_track)
4165  return 0;
4166 
4167  /* if audio then truncate sample_time to EditRate */
4168  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4169  sample_time = av_rescale_q(sample_time, st->time_base,
4170  av_inv_q(source_track->edit_rate));
4171 
4172  if (mxf->nb_index_tables <= 0) {
4173  if (!s->bit_rate)
4174  return AVERROR_INVALIDDATA;
4175  if (sample_time < 0)
4176  sample_time = 0;
4177  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4178 
4179  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4180  if (seekpos < 0)
4181  return seekpos;
4182 
4183  avpriv_update_cur_dts(s, st, sample_time);
4184  mxf->current_klv_data = (KLVPacket){{0}};
4185  } else {
4186  MXFPartition *partition;
4187 
4188  t = &mxf->index_tables[0];
4189  if (t->index_sid != source_track->index_sid) {
4190  /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
4191  for (i = 0; i < s->nb_streams; i++) {
4192  MXFTrack *new_source_track = s->streams[i]->priv_data;
4193  if (new_source_track && new_source_track->index_sid == t->index_sid) {
4194  sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
4195  source_track = new_source_track;
4196  st = s->streams[i];
4197  break;
4198  }
4199  }
4200  if (i == s->nb_streams)
4201  return AVERROR_INVALIDDATA;
4202  }
4203 
4204  /* clamp above zero, else ff_index_search_timestamp() returns negative
4205  * this also means we allow seeking before the start */