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