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