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