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