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