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