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