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