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