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 "libavcodec/bytestream.h"
55 #include "libavcodec/defs.h"
56 #include "libavcodec/internal.h"
57 #include "libavutil/channel_layout.h"
58 #include "libavutil/dict_internal.h"
59 #include "libavutil/intreadwrite.h"
60 #include "libavutil/parseutils.h"
61 #include "libavutil/timecode.h"
62 #include "libavutil/opt.h"
63 #include "avformat.h"
64 #include "avlanguage.h"
65 #include "demux.h"
66 #include "internal.h"
67 #include "mxf.h"
68 
69 #define MXF_MAX_CHUNK_SIZE (32 << 20)
70 #define RUN_IN_MAX (65535+1) // S377m-2004 section 5.5 and S377-1-2009 section 6.5, the +1 is to be slightly more tolerant
71 
72 typedef enum {
73  Header,
74  BodyPartition,
75  Footer
76 } MXFPartitionType;
77 
78 typedef enum {
79  OP1a = 1,
80  OP1b,
81  OP1c,
82  OP2a,
83  OP2b,
84  OP2c,
85  OP3a,
86  OP3b,
87  OP3c,
88  OPAtom,
89  OPSONYOpt, /* FATE sample, violates the spec in places */
90 } MXFOP;
91 
92 typedef enum {
93  UnknownWrapped = 0,
94  FrameWrapped,
95  ClipWrapped,
96 } MXFWrappingScheme;
97 
98 typedef struct MXFPartition {
99  int closed;
100  int complete;
101  MXFPartitionType type;
102  uint64_t previous_partition;
103  int index_sid;
104  int body_sid;
105  int64_t essence_offset; ///< absolute offset of essence
106  int64_t essence_length;
107  int32_t kag_size;
108  int64_t header_byte_count;
109  int64_t index_byte_count;
110  int pack_length;
111  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
112  int64_t body_offset;
113  KLVPacket first_essence_klv;
114 } MXFPartition;
115 
116 typedef struct MXFMetadataSet {
117  UID uid;
118  uint64_t partition_score;
119 } MXFMetadataSet;
120 
121 typedef struct MXFMetadataSetGroup {
122  MXFMetadataSet **metadata_sets;
123  int metadata_sets_count;
124 } MXFMetadataSetGroup;
125 
126 typedef struct MXFCryptoContext {
127  MXFMetadataSet meta;
128  UID source_container_ul;
129 } MXFCryptoContext;
130 
131 typedef struct MXFStructuralComponent {
132  MXFMetadataSet meta;
133  UID source_package_ul;
134  UID source_package_uid;
135  UID data_definition_ul;
136  int64_t duration;
137  int64_t start_position;
138  int source_track_id;
139 } MXFStructuralComponent;
140 
141 typedef struct MXFSequence {
142  MXFMetadataSet meta;
143  UID data_definition_ul;
144  UID *structural_components_refs;
145  int structural_components_count;
146  int64_t duration;
147  uint8_t origin;
148 } MXFSequence;
149 
150 typedef struct MXFTimecodeComponent {
151  MXFMetadataSet meta;
152  int drop_frame;
153  int start_frame;
154  struct AVRational rate;
155  AVTimecode tc;
156 } MXFTimecodeComponent;
157 
158 typedef struct {
159  MXFMetadataSet meta;
160  UID input_segment_ref;
161 } MXFPulldownComponent;
162 
163 typedef struct {
164  MXFMetadataSet meta;
165  UID *structural_components_refs;
166  int structural_components_count;
167  int64_t duration;
168 } MXFEssenceGroup;
169 
170 typedef struct {
171  MXFMetadataSet meta;
172  char *name;
173  char *value;
174 } MXFTaggedValue;
175 
176 typedef struct {
177  MXFMetadataSet meta;
178  MXFSequence *sequence; /* mandatory, and only one */
179  UID sequence_ref;
180  int track_id;
181  char *name;
182  uint8_t track_number[4];
183  AVRational edit_rate;
184  int intra_only;
185  uint64_t sample_count;
186  int64_t original_duration; /* st->duration in SampleRate/EditRate units */
187  int index_sid;
188  int body_sid;
189  MXFWrappingScheme wrapping;
190  int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
191 } MXFTrack;
192 
193 typedef struct MXFDescriptor {
194  MXFMetadataSet meta;
195  UID essence_container_ul;
196  UID essence_codec_ul;
197  UID codec_ul;
198  AVRational sample_rate;
199  AVRational aspect_ratio;
200  int width;
201  int height; /* Field height, not frame height */
202  int frame_layout; /* See MXFFrameLayout enum */
203  int video_line_map[2];
204 #define MXF_FIELD_DOMINANCE_DEFAULT 0
205 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
206 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
207  int field_dominance;
208  int channels;
209  int bits_per_sample;
210  int64_t duration; /* ContainerDuration optional property */
211  unsigned int component_depth;
212  unsigned int black_ref_level;
213  unsigned int white_ref_level;
214  unsigned int color_range;
215  unsigned int horiz_subsampling;
216  unsigned int vert_subsampling;
217  UID *file_descriptors_refs;
218  int file_descriptors_count;
219  UID *sub_descriptors_refs;
220  int sub_descriptors_count;
221  int linked_track_id;
222  uint8_t *extradata;
223  int extradata_size;
224  enum AVPixelFormat pix_fmt;
225  UID color_primaries_ul;
226  UID color_trc_ul;
227  UID color_space_ul;
228  AVMasteringDisplayMetadata *mastering;
229  AVContentLightMetadata *coll;
230  size_t coll_size;
231 } MXFDescriptor;
232 
233 typedef struct MXFMCASubDescriptor {
234  MXFMetadataSet meta;
235  UID uid;
236  UID mca_link_id;
237  UID soundfield_group_link_id;
238  UID *group_of_soundfield_groups_link_id_refs;
239  int group_of_soundfield_groups_link_id_count;
240  UID mca_label_dictionary_id;
241  int mca_channel_id;
242  char *language;
243 } MXFMCASubDescriptor;
244 
245 typedef struct MXFFFV1SubDescriptor {
246  MXFMetadataSet meta;
247  uint8_t *extradata;
248  int extradata_size;
249 } MXFFFV1SubDescriptor;
250 
251 typedef struct MXFIndexTableSegment {
252  MXFMetadataSet meta;
253  unsigned edit_unit_byte_count;
254  int index_sid;
255  int body_sid;
256  AVRational index_edit_rate;
257  uint64_t index_start_position;
258  uint64_t index_duration;
259  int8_t *temporal_offset_entries;
260  int *flag_entries;
261  uint64_t *stream_offset_entries;
262  int nb_index_entries;
263 } MXFIndexTableSegment;
264 
265 typedef struct MXFPackage {
266  MXFMetadataSet meta;
267  UID package_uid;
268  UID package_ul;
269  UID *tracks_refs;
270  int tracks_count;
271  UID descriptor_ref;
272  char *name;
273  UID *comment_refs;
274  int comment_count;
275 } MXFPackage;
276 
277 typedef struct MXFEssenceContainerData {
278  MXFMetadataSet meta;
279  UID package_uid;
280  UID package_ul;
281  int index_sid;
282  int body_sid;
283 } MXFEssenceContainerData;
284 
285 /* decoded index table */
286 typedef struct MXFIndexTable {
287  int index_sid;
288  int body_sid;
289  int nb_ptses; /* number of PTSes or total duration of index */
290  int64_t first_dts; /* DTS = EditUnit + first_dts */
291  int64_t *ptses; /* maps EditUnit -> PTS */
292  int nb_segments;
293  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
294  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
295  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
296 } MXFIndexTable;
297 
298 typedef struct MXFContext {
299  const AVClass *class; /**< Class for private options. */
300  MXFPartition *partitions;
301  unsigned partitions_count;
302  MXFOP op;
303  UID *packages_refs;
304  int packages_count;
305  UID *essence_container_data_refs;
306  int essence_container_data_count;
307  MXFMetadataSetGroup metadata_set_groups[MetadataSetTypeNB];
308  AVFormatContext *fc;
309  struct AVAES *aesc;
310  uint8_t *local_tags;
311  int local_tags_count;
312  uint64_t footer_partition;
313  KLVPacket current_klv_data;
314  int run_in;
315  MXFPartition *current_partition;
316  int parsing_backward;
317  int64_t last_forward_tell;
318  int last_forward_partition;
319  int nb_index_tables;
320  MXFIndexTable *index_tables;
321  int eia608_extract;
322 } MXFContext;
323 
324 /* NOTE: klv_offset is not set (-1) for local keys */
325 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
326 
327 typedef struct MXFMetadataReadTableEntry {
328  const UID key;
329  MXFMetadataReadFunc *read;
330  int ctx_size;
331  enum MXFMetadataSetType type;
332 } MXFMetadataReadTableEntry;
333 
334 /* partial keys to match */
335 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
336 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
337 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
338 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
339 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
340 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
341 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
342 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
343 
344 /* complete keys to match */
345 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 };
346 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
347 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
348 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
349 static const uint8_t mxf_ffv1_extradata[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x04,0x01,0x06,0x0c,0x01,0x00,0x00,0x00 }; // FFV1InitializationMetadata
350 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
351 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00 };
352 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 };
353 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 };
354 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 };
355 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 };
356 
357 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 };
358 static const uint8_t mxf_mca_tag_symbol[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x02,0x00,0x00,0x00 };
359 static const uint8_t mxf_mca_tag_name[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x03,0x00,0x00,0x00 };
360 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 };
361 static const uint8_t mxf_mca_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x05,0x00,0x00,0x00 };
362 static const uint8_t mxf_mca_channel_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x04,0x0a,0x00,0x00,0x00,0x00 };
363 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 };
364 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 };
365 
366 static const uint8_t mxf_sub_descriptor[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00 };
367 
368 static const uint8_t mxf_mastering_display_prefix[13] = { FF_MXF_MasteringDisplay_PREFIX };
369 static const uint8_t mxf_mastering_display_uls[4][16] = {
370  FF_MXF_MasteringDisplayPrimaries,
371  FF_MXF_MasteringDisplayWhitePointChromaticity,
372  FF_MXF_MasteringDisplayMaximumLuminance,
373  FF_MXF_MasteringDisplayMinimumLuminance,
374 };
375 
376 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
377 
378 static void mxf_free_metadataset(MXFMetadataSet **ctx, enum MXFMetadataSetType type)
379 {
380  MXFIndexTableSegment *seg;
381  switch (type) {
382  case Descriptor:
383  case MultipleDescriptor:
384  av_freep(&((MXFDescriptor *)*ctx)->extradata);
385  av_freep(&((MXFDescriptor *)*ctx)->mastering);
386  av_freep(&((MXFDescriptor *)*ctx)->coll);
387  av_freep(&((MXFDescriptor *)*ctx)->file_descriptors_refs);
388  av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
389  break;
390  case FFV1SubDescriptor:
391  av_freep(&((MXFFFV1SubDescriptor *)*ctx)->extradata);
392  break;
393  case AudioChannelLabelSubDescriptor:
394  case SoundfieldGroupLabelSubDescriptor:
395  case GroupOfSoundfieldGroupsLabelSubDescriptor:
396  av_freep(&((MXFMCASubDescriptor *)*ctx)->language);
397  av_freep(&((MXFMCASubDescriptor *)*ctx)->group_of_soundfield_groups_link_id_refs);
398  break;
399  case Sequence:
400  av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
401  break;
402  case EssenceGroup:
403  av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
404  break;
405  case SourcePackage:
406  case MaterialPackage:
407  av_freep(&((MXFPackage *)*ctx)->tracks_refs);
408  av_freep(&((MXFPackage *)*ctx)->name);
409  av_freep(&((MXFPackage *)*ctx)->comment_refs);
410  break;
411  case TaggedValue:
412  av_freep(&((MXFTaggedValue *)*ctx)->name);
413  av_freep(&((MXFTaggedValue *)*ctx)->value);
414  break;
415  case Track:
416  av_freep(&((MXFTrack *)*ctx)->name);
417  break;
418  case IndexTableSegment:
419  seg = (MXFIndexTableSegment *)*ctx;
420  av_freep(&seg->temporal_offset_entries);
421  av_freep(&seg->flag_entries);
422  av_freep(&seg->stream_offset_entries);
423  default:
424  break;
425  }
426  av_freep(ctx);
427 }
428 
429 static int64_t klv_decode_ber_length(AVIOContext *pb)
430 {
431  uint64_t size = avio_r8(pb);
432  if (size & 0x80) { /* long form */
433  int bytes_num = size & 0x7f;
434  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
435  if (bytes_num > 8)
436  return AVERROR_INVALIDDATA;
437  size = 0;
438  while (bytes_num--)
439  size = size << 8 | avio_r8(pb);
440  }
441  if (size > INT64_MAX)
442  return AVERROR_INVALIDDATA;
443  return size;
444 }
445 
446 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
447 {
448  int i, b;
449  for (i = 0; i < size && !avio_feof(pb); i++) {
450  b = avio_r8(pb);
451  if (b == key[0])
452  i = 0;
453  else if (b != key[i])
454  i = -1;
455  }
456  return i == size;
457 }
458 
459 static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
460 {
461  int64_t length, pos;
462  if (!mxf_read_sync(pb, mxf_klv_key, 4))
463  return AVERROR_INVALIDDATA;
464  klv->offset = avio_tell(pb) - 4;
465  if (klv->offset < mxf->run_in)
466  return AVERROR_INVALIDDATA;
467 
468  memcpy(klv->key, mxf_klv_key, 4);
469  avio_read(pb, klv->key + 4, 12);
470  length = klv_decode_ber_length(pb);
471  if (length < 0)
472  return length;
473  klv->length = length;
474  pos = avio_tell(pb);
475  if (pos > INT64_MAX - length)
476  return AVERROR_INVALIDDATA;
477  klv->next_klv = pos + length;
478  return 0;
479 }
480 
481 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
482 {
483  int i;
484 
485  for (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 i, 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 (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  int i;
599 
600  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
601  return AVERROR_INVALIDDATA;
602  length = av_get_packet(pb, pkt, length);
603  if (length < 0)
604  return length;
605  data_ptr = pkt->data;
606  end_ptr = pkt->data + length;
607  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
608 
609  if (st->codecpar->ch_layout.nb_channels > 8)
610  return AVERROR_INVALIDDATA;
611 
612  for (; end_ptr - buf_ptr >= st->codecpar->ch_layout.nb_channels * 4; ) {
613  for (i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {
614  uint32_t sample = bytestream_get_le32(&buf_ptr);
615  if (st->codecpar->bits_per_coded_sample == 24)
616  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
617  else
618  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
619  }
620  // always 8 channels stored SMPTE 331M
621  buf_ptr += 32 - st->codecpar->ch_layout.nb_channels * 4;
622  }
623  av_shrink_packet(pkt, data_ptr - pkt->data);
624  return 0;
625 }
626 
627 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
628 {
629  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
630  MXFContext *mxf = s->priv_data;
631  AVIOContext *pb = s->pb;
632  int64_t end = avio_tell(pb) + klv->length;
633  int64_t size;
634  uint64_t orig_size;
635  uint64_t plaintext_size;
636  uint8_t ivec[16];
637  uint8_t tmpbuf[16];
638  int index;
639  int body_sid;
640 
641  if (!mxf->aesc && s->key && s->keylen == 16) {
642  mxf->aesc = av_aes_alloc();
643  if (!mxf->aesc)
644  return AVERROR(ENOMEM);
645  av_aes_init(mxf->aesc, s->key, 128, 1);
646  }
647  // crypto context
648  size = klv_decode_ber_length(pb);
649  if (size < 0)
650  return size;
651  avio_skip(pb, size);
652  // plaintext offset
653  klv_decode_ber_length(pb);
654  plaintext_size = avio_rb64(pb);
655  // source klv key
656  klv_decode_ber_length(pb);
657  avio_read(pb, klv->key, 16);
658  if (!IS_KLV_KEY(klv, mxf_essence_element_key))
659  return AVERROR_INVALIDDATA;
660 
661  body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
662  index = mxf_get_stream_index(s, klv, body_sid);
663  if (index < 0)
664  return AVERROR_INVALIDDATA;
665  // source size
666  klv_decode_ber_length(pb);
667  orig_size = avio_rb64(pb);
668  if (orig_size < plaintext_size)
669  return AVERROR_INVALIDDATA;
670  // enc. code
671  size = klv_decode_ber_length(pb);
672  if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)
673  return AVERROR_INVALIDDATA;
674  avio_read(pb, ivec, 16);
675  avio_read(pb, tmpbuf, 16);
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 op = 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  op == OP1a ? "OP1a" : "OPAtom");
880 
881  mxf->op = op;
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();
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  avio_read(pb, key, 17);
1535  /* TODO: handle other types of of indirect values */
1536  if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1537  return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1538  } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1539  return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1540  }
1541  return 0;
1542 }
1543 
1544 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1545 {
1546  MXFTaggedValue *tagged_value = arg;
1547  switch (tag){
1548  case 0x5001:
1549  return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1550  case 0x5003:
1551  return mxf_read_indirect_value(tagged_value, pb, size);
1552  }
1553  return 0;
1554 }
1555 
1556 /*
1557  * Match an uid independently of the version byte and up to len common bytes
1558  * Returns: boolean
1559  */
1560 static int mxf_match_uid(const UID key, const uint8_t uid_prefix[], int len)
1561 {
1562  int i;
1563  for (i = 0; i < len; i++) {
1564  if (i != 7 && key[i] != uid_prefix[i])
1565  return 0;
1566  }
1567  return 1;
1568 }
1569 
1570 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1571 {
1572  while (uls->uid[0]) {
1573  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1574  break;
1575  uls++;
1576  }
1577  return uls;
1578 }
1579 
1580 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1581 {
1582  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
1583 
1584  if (!strong_ref)
1585  return NULL;
1586  for (int i = mg->metadata_sets_count - 1; i >= 0; i--)
1587  if (!memcmp(*strong_ref, mg->metadata_sets[i]->uid, 16))
1588  return mg->metadata_sets[i];
1589 
1590  return NULL;
1591 }
1592 
1593 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1594  // video essence container uls
1595  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14, J2KWrap },
1596  { { 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 */
1597  { { 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 */
1598  { { 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 */
1599  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1600  { { 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 */
1601  { { 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 */
1602  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1603  { { 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 */
1604  { { 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 */
1605  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x23,0x01,0x00 }, 14, AV_CODEC_ID_FFV1, NULL, 14 },
1606  { { 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 */
1607  { { 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 */
1608  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1609  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1610  { { 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 */
1611  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1612  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1613 };
1614 
1615 /* EC ULs for intra-only formats */
1616 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1617  { { 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 */
1618  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1619 };
1620 
1621 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1622 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1623  { { 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 */
1624  { { 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 */
1625  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1626 };
1627 
1628 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1629 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1630  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1631  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1632  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1633  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1634  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1635 };
1636 
1637 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1638  // sound essence container uls
1639  { { 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 */
1640  { { 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 */
1641  { { 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 */
1642  { { 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 */
1643  { { 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) */
1644  { { 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) */
1645  { { 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) */
1646  { { 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) */
1647  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1648 };
1649 
1650 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1651  { { 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 },
1652  { { 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 },
1653  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1654  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1655 };
1656 
1657 typedef struct MXFChannelOrderingUL {
1658  UID uid;
1659  enum AVChannel channel;
1660  enum AVAudioServiceType service_type;
1661 } MXFChannelOrderingUL;
1662 
1663 static const MXFChannelOrderingUL mxf_channel_ordering[] = {
1664  { { 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
1665  { { 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
1666  { { 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
1667  { { 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
1668  { { 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
1669  { { 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
1670  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x07,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround
1671  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x08,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround
1672  { { 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
1673  { { 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
1674  { { 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
1675  { { 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
1676  { { 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
1677  { { 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
1678  { { 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
1679  { { 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
1680  { { 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
1681  { { 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
1682  { { 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
1683  { { 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
1684  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x04,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround Height
1685  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x05,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround Height
1686  { { 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
1687  { { 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
1688  { { 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
1689  { { 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
1690  { { 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
1691  { { 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
1692  { { 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
1693  { { 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
1694  { { 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
1695  { { 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
1696  { { 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
1697  { { 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
1698  { { 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
1699  { { 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
1700  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_AUDIO_SERVICE_TYPE_NB },
1701 };
1702 
1703 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1704 {
1705  int val;
1706  const MXFCodecUL *codec_ul;
1707 
1708  codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1709  if (!codec_ul->uid[0])
1710  codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1711  if (!codec_ul->uid[0])
1712  codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1713  if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1714  return UnknownWrapped;
1715 
1716  val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1717  switch (codec_ul->wrapping_indicator_type) {
1718  case RawVWrap:
1719  val = val % 4;
1720  break;
1721  case RawAWrap:
1722  if (val == 0x03 || val == 0x04)
1723  val -= 0x02;
1724  break;
1725  case D10D11Wrap:
1726  if (val == 0x02)
1727  val = 0x01;
1728  break;
1729  case J2KWrap:
1730  if (val != 0x02)
1731  val = 0x01;
1732  break;
1733  }
1734  if (val == 0x01)
1735  return FrameWrapped;
1736  if (val == 0x02)
1737  return ClipWrapped;
1738  return UnknownWrapped;
1739 }
1740 
1741 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1742 {
1743  int i, j, nb_segments = 0;
1744  MXFIndexTableSegment **unsorted_segments;
1745  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1746  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[IndexTableSegment];
1747 
1748  /* count number of segments, allocate arrays and copy unsorted segments */
1749  nb_segments = mg->metadata_sets_count;
1750  if (!nb_segments)
1751  return AVERROR_INVALIDDATA;
1752 
1753  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1754  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1755  av_freep(sorted_segments);
1756  av_free(unsorted_segments);
1757  return AVERROR(ENOMEM);
1758  }
1759 
1760  for (i = nb_segments = 0; i < mg->metadata_sets_count; i++) {
1761  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
1762  if (s->edit_unit_byte_count || s->nb_index_entries)
1763  unsorted_segments[nb_segments++] = s;
1764  else
1765  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1766  s->index_sid, s->index_start_position);
1767  }
1768 
1769  if (!nb_segments) {
1770  av_freep(sorted_segments);
1771  av_free(unsorted_segments);
1772  return AVERROR_INVALIDDATA;
1773  }
1774 
1775  *nb_sorted_segments = 0;
1776 
1777  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1778  for (i = 0; i < nb_segments; i++) {
1779  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1780  uint64_t best_index_duration = 0;
1781 
1782  for (j = 0; j < nb_segments; j++) {
1783  MXFIndexTableSegment *s = unsorted_segments[j];
1784 
1785  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1786  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1787  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1788  */
1789  if ((i == 0 ||
1790  s->body_sid > last_body_sid ||
1791  s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1792  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1793  (best == -1 ||
1794  s->body_sid < best_body_sid ||
1795  s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1796  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1797  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)) {
1798  best = j;
1799  best_body_sid = s->body_sid;
1800  best_index_sid = s->index_sid;
1801  best_index_start = s->index_start_position;
1802  best_index_duration = s->index_duration;
1803  }
1804  }
1805 
1806  /* no suitable entry found -> we're done */
1807  if (best == -1)
1808  break;
1809 
1810  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1811  last_body_sid = best_body_sid;
1812  last_index_sid = best_index_sid;
1813  last_index_start = best_index_start;
1814  }
1815 
1816  av_free(unsorted_segments);
1817 
1818  return 0;
1819 }
1820 
1821 /**
1822  * Computes the absolute file offset of the given essence container offset
1823  */
1824 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1825 {
1826  MXFPartition *last_p = NULL;
1827  int a, b, m, m0;
1828 
1829  if (offset < 0)
1830  return AVERROR(EINVAL);
1831 
1832  a = -1;
1833  b = mxf->partitions_count;
1834 
1835  while (b - a > 1) {
1836  m0 = m = (a + b) >> 1;
1837 
1838  while (m < b && mxf->partitions[m].body_sid != body_sid)
1839  m++;
1840 
1841  if (m < b && mxf->partitions[m].body_offset <= offset)
1842  a = m;
1843  else
1844  b = m0;
1845  }
1846 
1847  if (a >= 0)
1848  last_p = &mxf->partitions[a];
1849 
1850  if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1851  *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1852  if (partition_out)
1853  *partition_out = last_p;
1854  return 0;
1855  }
1856 
1857  av_log(mxf->fc, AV_LOG_ERROR,
1858  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1859  offset, body_sid);
1860 
1861  return AVERROR_INVALIDDATA;
1862 }
1863 
1864 /**
1865  * Returns the end position of the essence container with given BodySID, or zero if unknown
1866  */
1867 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1868 {
1869  for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1870  MXFPartition *p = &mxf->partitions[x];
1871 
1872  if (p->body_sid != body_sid)
1873  continue;
1874 
1875  if (!p->essence_length)
1876  return 0;
1877 
1878  return p->essence_offset + p->essence_length;
1879  }
1880 
1881  return 0;
1882 }
1883 
1884 /* EditUnit -> absolute offset */
1885 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)
1886 {
1887  int i;
1888  int64_t offset_temp = 0;
1889 
1890  edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1891 
1892  for (i = 0; i < index_table->nb_segments; i++) {
1893  MXFIndexTableSegment *s = index_table->segments[i];
1894 
1895  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1896 
1897  if (edit_unit < s->index_start_position + s->index_duration) {
1898  int64_t index = edit_unit - s->index_start_position;
1899 
1900  if (s->edit_unit_byte_count) {
1901  if (index > INT64_MAX / s->edit_unit_byte_count ||
1902  s->edit_unit_byte_count * index > INT64_MAX - offset_temp)
1903  return AVERROR_INVALIDDATA;
1904 
1905  offset_temp += s->edit_unit_byte_count * index;
1906  } else {
1907  if (s->nb_index_entries == 2 * s->index_duration + 1)
1908  index *= 2; /* Avid index */
1909 
1910  if (index < 0 || index >= s->nb_index_entries) {
1911  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1912  index_table->index_sid, s->index_start_position);
1913  return AVERROR_INVALIDDATA;
1914  }
1915 
1916  offset_temp = s->stream_offset_entries[index];
1917  }
1918 
1919  if (edit_unit_out)
1920  *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1921 
1922  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1923  } else {
1924  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1925  offset_temp += s->edit_unit_byte_count * s->index_duration;
1926  }
1927  }
1928 
1929  if (nag)
1930  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);
1931 
1932  return AVERROR_INVALIDDATA;
1933 }
1934 
1935 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1936 {
1937  int i, j, x;
1938  int8_t max_temporal_offset = -128;
1939  uint8_t *flags;
1940 
1941  /* first compute how many entries we have */
1942  for (i = 0; i < index_table->nb_segments; i++) {
1943  MXFIndexTableSegment *s = index_table->segments[i];
1944 
1945  if (!s->nb_index_entries) {
1946  index_table->nb_ptses = 0;
1947  return 0; /* no TemporalOffsets */
1948  }
1949 
1950  if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1951  index_table->nb_ptses = 0;
1952  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1953  return 0;
1954  }
1955 
1956  if (s->nb_index_entries != s->index_duration &&
1957  s->nb_index_entries != s->index_duration + 1 && /* Avid index */
1958  s->nb_index_entries != s->index_duration * 2 + 1) {
1959  index_table->nb_ptses = 0;
1960  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration does not match nb_index_entries\n", s->index_sid);
1961  return 0;
1962  }
1963 
1964  index_table->nb_ptses += s->index_duration;
1965  }
1966 
1967  /* paranoid check */
1968  if (index_table->nb_ptses <= 0)
1969  return 0;
1970 
1971  if (!(index_table->ptses = av_malloc_array(index_table->nb_ptses, sizeof(int64_t))) ||
1972  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1973  !(index_table->offsets = av_malloc_array(index_table->nb_ptses, sizeof(int8_t))) ||
1974  !(flags = av_malloc_array(index_table->nb_ptses, sizeof(uint8_t)))) {
1975  av_freep(&index_table->ptses);
1976  av_freep(&index_table->fake_index);
1977  av_freep(&index_table->offsets);
1978  return AVERROR(ENOMEM);
1979  }
1980 
1981  /* we may have a few bad TemporalOffsets
1982  * make sure the corresponding PTSes don't have the bogus value 0 */
1983  for (x = 0; x < index_table->nb_ptses; x++)
1984  index_table->ptses[x] = AV_NOPTS_VALUE;
1985 
1986  /**
1987  * We have this:
1988  *
1989  * x TemporalOffset
1990  * 0: 0
1991  * 1: 1
1992  * 2: 1
1993  * 3: -2
1994  * 4: 1
1995  * 5: 1
1996  * 6: -2
1997  *
1998  * We want to transform it into this:
1999  *
2000  * x DTS PTS
2001  * 0: -1 0
2002  * 1: 0 3
2003  * 2: 1 1
2004  * 3: 2 2
2005  * 4: 3 6
2006  * 5: 4 4
2007  * 6: 5 5
2008  *
2009  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
2010  * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
2011  * The latter makes DTS <= PTS.
2012  */
2013  for (i = x = 0; i < index_table->nb_segments; i++) {
2014  MXFIndexTableSegment *s = index_table->segments[i];
2015  int index_delta = 1;
2016  int n = s->nb_index_entries;
2017 
2018  if (s->nb_index_entries == 2 * s->index_duration + 1)
2019  index_delta = 2; /* Avid index */
2020  if (s->nb_index_entries == index_delta * s->index_duration + 1)
2021  /* ignore the last entry - it's the size of the essence container in Avid */
2022  n--;
2023 
2024  for (j = 0; j < n; j += index_delta, x++) {
2025  int offset = s->temporal_offset_entries[j] / index_delta;
2026  int index = x + offset;
2027 
2028  if (x >= index_table->nb_ptses) {
2029  av_log(mxf->fc, AV_LOG_ERROR,
2030  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
2031  s->nb_index_entries, s->index_duration);
2032  break;
2033  }
2034 
2035  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
2036 
2037  if (index < 0 || index >= index_table->nb_ptses) {
2038  av_log(mxf->fc, AV_LOG_ERROR,
2039  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
2040  x, offset, index);
2041  continue;
2042  }
2043 
2044  index_table->offsets[x] = offset;
2045  index_table->ptses[index] = x;
2046  max_temporal_offset = FFMAX(max_temporal_offset, offset);
2047  }
2048  }
2049 
2050  /* calculate the fake index table in display order */
2051  for (x = 0; x < index_table->nb_ptses; x++) {
2052  index_table->fake_index[x].timestamp = x;
2053  if (index_table->ptses[x] != AV_NOPTS_VALUE)
2054  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2055  }
2056  av_freep(&flags);
2057 
2058  index_table->first_dts = -max_temporal_offset;
2059 
2060  return 0;
2061 }
2062 
2063 /**
2064  * Sorts and collects index table segments into index tables.
2065  * Also computes PTSes if possible.
2066  */
2067 static int mxf_compute_index_tables(MXFContext *mxf)
2068 {
2069  int i, j, k, ret, nb_sorted_segments;
2070  MXFIndexTableSegment **sorted_segments = NULL;
2071 
2072  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2073  nb_sorted_segments <= 0) {
2074  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2075  return 0;
2076  }
2077 
2078  /* sanity check and count unique BodySIDs/IndexSIDs */
2079  for (i = 0; i < nb_sorted_segments; i++) {
2080  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2081  mxf->nb_index_tables++;
2082  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2083  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2084  ret = AVERROR_INVALIDDATA;
2085  goto finish_decoding_index;
2086  }
2087  }
2088 
2089  mxf->index_tables = av_calloc(mxf->nb_index_tables,
2090  sizeof(*mxf->index_tables));
2091  if (!mxf->index_tables) {
2092  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2093  ret = AVERROR(ENOMEM);
2094  goto finish_decoding_index;
2095  }
2096 
2097  /* distribute sorted segments to index tables */
2098  for (i = j = 0; i < nb_sorted_segments; i++) {
2099  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2100  /* next IndexSID */
2101  j++;
2102  }
2103 
2104  mxf->index_tables[j].nb_segments++;
2105  }
2106 
2107  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2108  MXFIndexTable *t = &mxf->index_tables[j];
2109  MXFTrack *mxf_track = NULL;
2110 
2111  t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2112  if (!t->segments) {
2113  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2114  " pointer array\n");
2115  ret = AVERROR(ENOMEM);
2116  goto finish_decoding_index;
2117  }
2118 
2119  if (sorted_segments[i]->index_start_position)
2120  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2121  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2122 
2123  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2124  t->index_sid = sorted_segments[i]->index_sid;
2125  t->body_sid = sorted_segments[i]->body_sid;
2126 
2127  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2128  goto finish_decoding_index;
2129 
2130  for (k = 0; k < mxf->fc->nb_streams; k++) {
2131  MXFTrack *track = mxf->fc->streams[k]->priv_data;
2132  if (track && track->index_sid == t->index_sid) {
2133  mxf_track = track;
2134  break;
2135  }
2136  }
2137 
2138  /* fix zero IndexDurations */
2139  for (k = 0; k < t->nb_segments; k++) {
2140  if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2141  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2142  t->index_sid, k);
2143  if (mxf_track)
2144  t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2145  }
2146 
2147  if (t->segments[k]->index_duration)
2148  continue;
2149 
2150  if (t->nb_segments > 1)
2151  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2152  t->index_sid, k);
2153 
2154  if (!mxf_track) {
2155  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2156  break;
2157  }
2158 
2159  /* assume the first stream's duration is reasonable
2160  * leave index_duration = 0 on further segments in case we have any (unlikely)
2161  */
2162  t->segments[k]->index_duration = mxf_track->original_duration;
2163  break;
2164  }
2165  }
2166 
2167  ret = 0;
2168 finish_decoding_index:
2169  av_free(sorted_segments);
2170  return ret;
2171 }
2172 
2173 static int mxf_is_st_422(const UID *essence_container_ul) {
2174  static const uint8_t st_422_essence_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c };
2175 
2176  return essence_container_ul && mxf_match_uid(*essence_container_ul, st_422_essence_container_ul,
2177  sizeof(st_422_essence_container_ul));
2178 }
2179 
2180 static int mxf_is_intra_only(MXFDescriptor *descriptor)
2181 {
2182  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
2183  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
2184  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
2185  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
2186 }
2187 
2188 static void mxf_umid_to_str(const UID ul, const UID uid,
2189  char str[2 + sizeof(UID) * 4 + 1])
2190 {
2191  snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2192  ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2193  ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2194 }
2195 
2196 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2197  uint16_t patch, uint16_t release, char **str)
2198 {
2199  *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2200  if (!*str)
2201  return AVERROR(ENOMEM);
2202  return 0;
2203 }
2204 
2205 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2206 {
2207  char str[2 + 4 * sizeof(UID) + 1];
2208  if (!package)
2209  return 0;
2210  mxf_umid_to_str(package->package_ul, package->package_uid, str);
2211  av_dict_set(pm, key, str, 0);
2212  return 0;
2213 }
2214 
2215 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2216 {
2217  char buf[AV_TIMECODE_STR_SIZE];
2218  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2219 
2220  return 0;
2221 }
2222 
2223 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2224 {
2225  MXFTimecodeComponent *timecode;
2226  MXFPulldownComponent *pulldown;
2227 
2228  timecode = mxf_resolve_strong_ref(mxf, strong_ref, TimecodeComponent);
2229  if (timecode)
2230  return timecode;
2231 
2232  pulldown = mxf_resolve_strong_ref(mxf, strong_ref, PulldownComponent);
2233  if (pulldown)
2234  return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2235 
2236  return NULL;
2237 }
2238 
2239 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2240 {
2241  MXFPackage *package = NULL;
2242  int i;
2243 
2244  for (i = 0; i < mxf->packages_count; i++) {
2245  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2246  if (!package)
2247  continue;
2248 
2249  if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2250  return package;
2251  }
2252  return NULL;
2253 }
2254 
2255 static MXFDescriptor* mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
2256 {
2257  MXFDescriptor *descriptor = mxf_resolve_strong_ref(mxf, strong_ref, Descriptor);
2258  if (descriptor)
2259  return descriptor;
2260 
2261  descriptor = mxf_resolve_strong_ref(mxf, strong_ref, MultipleDescriptor);
2262  if (descriptor) {
2263  for (int i = 0; i < descriptor->file_descriptors_count; i++) {
2264  MXFDescriptor *file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2265 
2266  if (!file_descriptor) {
2267  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2268  continue;
2269  }
2270  if (file_descriptor->linked_track_id == track_id) {
2271  return file_descriptor;
2272  }
2273  }
2274  }
2275 
2276  return NULL;
2277 }
2278 
2279 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2280 {
2281  MXFStructuralComponent *component = NULL;
2282  MXFPackage *package = NULL;
2283  MXFDescriptor *descriptor = NULL;
2284  MXFEssenceGroup *essence_group;
2285  int i;
2286 
2287  component = mxf_resolve_strong_ref(mxf, strong_ref, SourceClip);
2288  if (component)
2289  return component;
2290 
2291  essence_group = mxf_resolve_strong_ref(mxf, strong_ref, EssenceGroup);
2292  if (!essence_group)
2293  return NULL;
2294 
2295  /* essence groups contains multiple representations of the same media,
2296  this return the first components with a valid Descriptor typically index 0 */
2297  for (i =0; i < essence_group->structural_components_count; i++){
2298  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2299  if (!component)
2300  continue;
2301 
2302  if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2303  continue;
2304 
2305  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2306  if (descriptor)
2307  return component;
2308  }
2309 
2310  return NULL;
2311 }
2312 
2313 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2314 {
2315  MXFTaggedValue *tag;
2316  int i;
2317  char *key = NULL;
2318 
2319  for (i = 0; i < package->comment_count; i++) {
2320  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2321  if (!tag || !tag->name || !tag->value)
2322  continue;
2323 
2324  key = av_asprintf("comment_%s", tag->name);
2325  if (!key)
2326  return AVERROR(ENOMEM);
2327 
2328  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2329  }
2330  return 0;
2331 }
2332 
2333 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2334 {
2335  MXFPackage *physical_package = NULL;
2336  MXFTrack *physical_track = NULL;
2337  MXFStructuralComponent *sourceclip = NULL;
2338  MXFTimecodeComponent *mxf_tc = NULL;
2339  int i, j, k;
2340  AVTimecode tc;
2341  int flags;
2342  int64_t start_position;
2343 
2344  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2345  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2346  if (!sourceclip)
2347  continue;
2348 
2349  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2350  break;
2351 
2352  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2353 
2354  /* the name of physical source package is name of the reel or tape */
2355  if (physical_package->name && physical_package->name[0])
2356  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2357 
2358  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2359  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2360  */
2361  for (j = 0; j < physical_package->tracks_count; j++) {
2362  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2363  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2364  continue;
2365  }
2366 
2367  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2368  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2369  continue;
2370  }
2371 
2372  if (physical_track->edit_rate.num <= 0 ||
2373  physical_track->edit_rate.den <= 0) {
2374  av_log(mxf->fc, AV_LOG_WARNING,
2375  "Invalid edit rate (%d/%d) found on structural"
2376  " component #%d, defaulting to 25/1\n",
2377  physical_track->edit_rate.num,
2378  physical_track->edit_rate.den, i);
2379  physical_track->edit_rate = (AVRational){25, 1};
2380  }
2381 
2382  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2383  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2384  continue;
2385 
2386  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2387  /* scale sourceclip start_position to match physical track edit rate */
2388  start_position = av_rescale_q(sourceclip->start_position,
2389  physical_track->edit_rate,
2390  source_track->edit_rate);
2391 
2392  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2393  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2394  return 0;
2395  }
2396  }
2397  }
2398  }
2399 
2400  return 0;
2401 }
2402 
2403 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2404 {
2405  MXFStructuralComponent *component = NULL;
2406  const MXFCodecUL *codec_ul = NULL;
2407  MXFPackage tmp_package;
2408  AVStream *st;
2409  int j;
2410 
2411  for (j = 0; j < track->sequence->structural_components_count; j++) {
2412  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2413  if (!component)
2414  continue;
2415  break;
2416  }
2417  if (!component)
2418  return 0;
2419 
2420  st = avformat_new_stream(mxf->fc, NULL);
2421  if (!st) {
2422  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2423  return AVERROR(ENOMEM);
2424  }
2425 
2426  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2427  st->codecpar->codec_id = AV_CODEC_ID_NONE;
2428  st->id = track->track_id;
2429 
2430  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2431  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2432  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2433  if (track->name && track->name[0])
2434  av_dict_set(&st->metadata, "track_name", track->name, 0);
2435 
2436  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2437  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2438  return 0;
2439 }
2440 
2441 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2442 {
2443  if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2444  /* CDCI range metadata */
2445  if (!descriptor->component_depth)
2446  return AVCOL_RANGE_UNSPECIFIED;
2447  if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2448  descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2449  (descriptor->color_range == (1<<descriptor->component_depth) ||
2450  descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2451  return AVCOL_RANGE_JPEG;
2452  if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2453  descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2454  descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2455  descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2456  return AVCOL_RANGE_MPEG;
2457  avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2458  descriptor->color_range, descriptor->black_ref_level,
2459  descriptor->white_ref_level, descriptor->component_depth);
2460  }
2461 
2462  return AVCOL_RANGE_UNSPECIFIED;
2463 }
2464 
2465 static int is_pcm(enum AVCodecID codec_id)
2466 {
2467  /* we only care about "normal" PCM codecs until we get samples */
2468  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2469 }
2470 
2471 static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2472 {
2473  // language abbr should contain at least 2 chars
2474  if (rfc5646 && strlen(rfc5646) > 1) {
2475  char primary_tag[4] =
2476  {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2477 
2478  const char *iso6392 = ff_convert_lang_to(primary_tag,
2479  AV_LANG_ISO639_2_BIBL);
2480  if (iso6392)
2481  return(av_dict_set(met, "language", iso6392, 0));
2482  }
2483  return 0;
2484 }
2485 
2486 static MXFMCASubDescriptor *find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
2487 {
2488  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
2489  for (int k = 0; k < mg->metadata_sets_count; k++) {
2490  MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mg->metadata_sets[k];
2491  if (!memcmp(&group->mca_link_id, mca_link_id, 16))
2492  return group;
2493  }
2494  return NULL;
2495 }
2496 
2497 static void parse_ffv1_sub_descriptor(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2498 {
2499  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2500  MXFFFV1SubDescriptor *ffv1_sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], FFV1SubDescriptor);
2501  if (ffv1_sub_descriptor == NULL)
2502  continue;
2503 
2504  descriptor->extradata = ffv1_sub_descriptor->extradata;
2505  descriptor->extradata_size = ffv1_sub_descriptor->extradata_size;
2506  ffv1_sub_descriptor->extradata = NULL;
2507  ffv1_sub_descriptor->extradata_size = 0;
2508  break;
2509  }
2510 }
2511 
2512 static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2513 {
2514  AVChannelLayout *ch_layout = &st->codecpar->ch_layout;
2515  char *language = NULL;
2516  int ambigous_language = 0;
2517  enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2518  int ambigous_service_type = 0;
2519  int ret;
2520 
2521  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2522  char *channel_language;
2523 
2524  MXFMCASubDescriptor *label = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], AudioChannelLabelSubDescriptor);
2525  if (label == NULL)
2526  continue;
2527 
2528  if (ch_layout->order == AV_CHANNEL_ORDER_UNSPEC) {
2529  av_channel_layout_uninit(ch_layout);
2530  ret = av_channel_layout_custom_init(ch_layout, descriptor->channels);
2531  if (ret < 0)
2532  return ret;
2533  }
2534 
2535  for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2536  if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2537  int target_channel = label->mca_channel_id;
2538  if (target_channel == 0 && descriptor->channels == 1)
2539  target_channel = 1;
2540  if (target_channel <= 0 || target_channel > descriptor->channels) {
2541  av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2542  return AVERROR_INVALIDDATA;
2543  }
2544  ch_layout->u.map[target_channel - 1].id = channel_ordering->channel;
2545  if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2546  service_type = channel_ordering->service_type;
2547  else if (service_type != channel_ordering->service_type)
2548  ambigous_service_type = 1;
2549  break;
2550  }
2551  }
2552 
2553  channel_language = label->language;
2554  if (!channel_language) {
2555  MXFMCASubDescriptor *group = find_mca_link_id(mxf, SoundfieldGroupLabelSubDescriptor, &label->soundfield_group_link_id);
2556  if (group) {
2557  channel_language = group->language;
2558  if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2559  MXFMCASubDescriptor *supergroup = find_mca_link_id(mxf, GroupOfSoundfieldGroupsLabelSubDescriptor,
2560  group->group_of_soundfield_groups_link_id_refs);
2561  if (supergroup)
2562  channel_language = supergroup->language;
2563  }
2564  }
2565  }
2566  if (channel_language) {
2567  if (language && strcmp(language, channel_language))
2568  ambigous_language = 1;
2569  else
2570  language = channel_language;
2571  }
2572  }
2573 
2574  if (language && !ambigous_language) {
2575  int ret = set_language(mxf->fc, language, &st->metadata);
2576  if (ret < 0)
2577  return ret;
2578  }
2579 
2580  if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2581  enum AVAudioServiceType *ast;
2582  AVPacketSideData *side_data = av_packet_side_data_new(&st->codecpar->coded_side_data,
2583  &st->codecpar->nb_coded_side_data,
2584  AV_PKT_DATA_AUDIO_SERVICE_TYPE,
2585  sizeof(*ast), 0);
2586  if (!side_data)
2587  return AVERROR(ENOMEM);
2588  ast = (enum AVAudioServiceType*)side_data->data;
2589  *ast = service_type;
2590  }
2591 
2592  ret = av_channel_layout_retype(ch_layout, 0, AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL);
2593  if (ret < 0)
2594  return ret;
2595 
2596  return 0;
2597 }
2598 
2599 static int mxf_parse_structural_metadata(MXFContext *mxf)
2600 {
2601  MXFPackage *material_package = NULL;
2602  int i, j, k, ret;
2603 
2604  /* TODO: handle multiple material packages (OP3x) */
2605  for (i = 0; i < mxf->packages_count; i++) {
2606  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2607  if (material_package) break;
2608  }
2609  if (!material_package) {
2610  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2611  return AVERROR_INVALIDDATA;
2612  }
2613 
2614  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2615  if (material_package->name && material_package->name[0])
2616  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2617  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2618 
2619  for (i = 0; i < material_package->tracks_count; i++) {
2620  MXFPackage *source_package = NULL;
2621  MXFTrack *material_track = NULL;
2622  MXFTrack *source_track = NULL;
2623  MXFTrack *temp_track = NULL;
2624  MXFDescriptor *descriptor = NULL;
2625  MXFStructuralComponent *component = NULL;
2626  MXFTimecodeComponent *mxf_tc = NULL;
2627  UID *essence_container_ul = NULL;
2628  const MXFCodecUL *codec_ul = NULL;
2629  const MXFCodecUL *container_ul = NULL;
2630  const MXFCodecUL *pix_fmt_ul = NULL;
2631  AVStream *st;
2632  FFStream *sti;
2633  AVTimecode tc;
2634  int flags;
2635 
2636  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2637  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2638  continue;
2639  }
2640 
2641  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2642  mxf_tc = (MXFTimecodeComponent*)component;
2643  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2644  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2645  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2646  }
2647  }
2648 
2649  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2650  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2651  continue;
2652  }
2653 
2654  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2655  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2656  if (!component)
2657  continue;
2658 
2659  mxf_tc = (MXFTimecodeComponent*)component;
2660  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2661  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2662  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2663  break;
2664  }
2665  }
2666 
2667  /* TODO: handle multiple source clips, only finds first valid source clip */
2668  if(material_track->sequence->structural_components_count > 1)
2669  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2670  material_track->track_id, material_track->sequence->structural_components_count);
2671 
2672  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2673  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2674  if (!component)
2675  continue;
2676 
2677  source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2678  if (!source_package) {
2679  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2680  continue;
2681  }
2682  for (k = 0; k < source_package->tracks_count; k++) {
2683  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2684  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2685  ret = AVERROR_INVALIDDATA;
2686  goto fail_and_free;
2687  }
2688  if (temp_track->track_id == component->source_track_id) {
2689  source_track = temp_track;
2690  break;
2691  }
2692  }
2693  if (!source_track) {
2694  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2695  break;
2696  }
2697 
2698  for (k = 0; k < mxf->essence_container_data_count; k++) {
2699  MXFEssenceContainerData *essence_data;
2700 
2701  if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2702  av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2703  continue;
2704  }
2705  if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2706  source_track->body_sid = essence_data->body_sid;
2707  source_track->index_sid = essence_data->index_sid;
2708  break;
2709  }
2710  }
2711 
2712  if(source_track && component)
2713  break;
2714  }
2715  if (!source_track || !component || !source_package) {
2716  if((ret = mxf_add_metadata_stream(mxf, material_track)))
2717  goto fail_and_free;
2718  continue;
2719  }
2720 
2721  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2722  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2723  ret = AVERROR_INVALIDDATA;
2724  goto fail_and_free;
2725  }
2726 
2727  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2728  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2729  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2730  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2731  continue;
2732  }
2733 
2734  st = avformat_new_stream(mxf->fc, NULL);
2735  if (!st) {
2736  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2737  ret = AVERROR(ENOMEM);
2738  goto fail_and_free;
2739  }
2740  sti = ffstream(st);
2741  st->id = material_track->track_id;
2742  st->priv_data = source_track;
2743 
2744  descriptor = mxf_resolve_descriptor(mxf, &source_package->descriptor_ref, source_track->track_id);
2745 
2746  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2747  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2748  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2749  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2750  else
2751  source_track->original_duration = st->duration = component->duration;
2752 
2753  if (st->duration == -1)
2754  st->duration = AV_NOPTS_VALUE;
2755  st->start_time = component->start_position;
2756  if (material_track->edit_rate.num <= 0 ||
2757  material_track->edit_rate.den <= 0) {
2758  av_log(mxf->fc, AV_LOG_WARNING,
2759  "Invalid edit rate (%d/%d) found on stream #%d, "
2760  "defaulting to 25/1\n",
2761  material_track->edit_rate.num,
2762  material_track->edit_rate.den, st->index);
2763  material_track->edit_rate = (AVRational){25, 1};
2764  }
2765  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2766 
2767  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2768  * the former is accessible via st->priv_data */
2769  source_track->edit_rate = material_track->edit_rate;
2770 
2771  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2772  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2773  st->codecpar->codec_type = codec_ul->id;
2774 
2775  if (!descriptor) {
2776  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2777  continue;
2778  }
2779  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2780  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2781  essence_container_ul = &descriptor->essence_container_ul;
2782  source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2783  if (source_track->wrapping == UnknownWrapped)
2784  av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2785  /* HACK: replacing the original key with mxf_encrypted_essence_container
2786  * is not allowed according to s429-6, try to find correct information anyway */
2787  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2788  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[CryptoContext];
2789  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2790  if (mg->metadata_sets_count) {
2791  MXFMetadataSet *metadata = mg->metadata_sets[0];
2792  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2793  }
2794  }
2795 
2796  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2797  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2798  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2799  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2800  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2801  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2802  }
2803 
2804  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2805  avcodec_get_name(st->codecpar->codec_id));
2806  for (k = 0; k < 16; k++) {
2807  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2808  descriptor->essence_codec_ul[k]);
2809  if (!(k+1 & 19) || k == 5)
2810  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2811  }
2812  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2813 
2814  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2815  if (source_package->name && source_package->name[0])
2816  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2817  if (material_track->name && material_track->name[0])
2818  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2819 
2820  mxf_parse_physical_source_package(mxf, source_track, st);
2821 
2822  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2823  source_track->intra_only = mxf_is_intra_only(descriptor);
2824  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2825  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2826  st->codecpar->codec_id = container_ul->id;
2827  st->codecpar->width = descriptor->width;
2828  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2829  switch (descriptor->frame_layout) {
2830  case FullFrame:
2831  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2832  break;
2833  case OneField:
2834  /* Every other line is stored and needs to be duplicated. */
2835  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2836  break; /* The correct thing to do here is fall through, but by breaking we might be
2837  able to decode some streams at half the vertical resolution, rather than not al all.
2838  It's also for compatibility with the old behavior. */
2839  case MixedFields:
2840  break;
2841  case SegmentedFrame:
2842  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2843  case SeparateFields:
2844  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2845  descriptor->video_line_map[0], descriptor->video_line_map[1],
2846  descriptor->field_dominance);
2847  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2848  /* Detect coded field order from VideoLineMap:
2849  * (even, even) => bottom field coded first
2850  * (even, odd) => top field coded first
2851  * (odd, even) => top field coded first
2852  * (odd, odd) => bottom field coded first
2853  */
2854  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2855  switch (descriptor->field_dominance) {
2856  case MXF_FIELD_DOMINANCE_DEFAULT:
2857  case MXF_FIELD_DOMINANCE_FF:
2858  st->codecpar->field_order = AV_FIELD_TT;
2859  break;
2860  case MXF_FIELD_DOMINANCE_FL:
2861  st->codecpar->field_order = AV_FIELD_TB;
2862  break;
2863  default:
2864  avpriv_request_sample(mxf->fc,
2865  "Field dominance %d support",
2866  descriptor->field_dominance);
2867  }
2868  } else {
2869  switch (descriptor->field_dominance) {
2870  case MXF_FIELD_DOMINANCE_DEFAULT:
2871  case MXF_FIELD_DOMINANCE_FF:
2872  st->codecpar->field_order = AV_FIELD_BB;
2873  break;
2874  case MXF_FIELD_DOMINANCE_FL:
2875  st->codecpar->field_order = AV_FIELD_BT;
2876  break;
2877  default:
2878  avpriv_request_sample(mxf->fc,
2879  "Field dominance %d support",
2880  descriptor->field_dominance);
2881  }
2882  }
2883  }
2884  /* Turn field height into frame height. */
2885  st->codecpar->height *= 2;
2886  break;
2887  default:
2888  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2889  }
2890 
2891  if (mxf_is_st_422(essence_container_ul)) {
2892  switch ((*essence_container_ul)[14]) {
2893  case 2: /* Cn: Clip- wrapped Picture Element */
2894  case 3: /* I1: Interlaced Frame, 1 field/KLV */
2895  case 4: /* I2: Interlaced Frame, 2 fields/KLV */
2896  case 6: /* P1: Frame- wrapped Picture Element */
2897  st->avg_frame_rate = source_track->edit_rate;
2898  st->r_frame_rate = st->avg_frame_rate;
2899  break;
2900  case 5: /* F1: Field-wrapped Picture Element */
2901  st->avg_frame_rate = av_mul_q(av_make_q(2, 1), source_track->edit_rate);
2902  st->r_frame_rate = st->avg_frame_rate;
2903  break;
2904  default:
2905  break;
2906  }
2907  }
2908 
2909  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2910  switch (descriptor->essence_codec_ul[14]) {
2911  case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2912  case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2913  case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2914  case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2915  case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2916  case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2917  }
2918  }
2919 
2920  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2921  st->codecpar->format = descriptor->pix_fmt;
2922  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2923  pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2924  &descriptor->essence_codec_ul);
2925  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2926  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2927  st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2928  &descriptor->essence_codec_ul)->id;
2929  if (!st->codecpar->codec_tag) {
2930  /* support files created before RP224v10 by defaulting to UYVY422
2931  if subsampling is 4:2:2 and component depth is 8-bit */
2932  if (descriptor->horiz_subsampling == 2 &&
2933  descriptor->vert_subsampling == 1 &&
2934  descriptor->component_depth == 8) {
2935  st->codecpar->format = AV_PIX_FMT_UYVY422;
2936  }
2937  }
2938  }
2939  }
2940  }
2941  sti->need_parsing = AVSTREAM_PARSE_HEADERS;
2942  if (material_track->sequence->origin) {
2943  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2944  }
2945  if (source_track->sequence->origin) {
2946  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2947  }
2948  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2949  sti->display_aspect_ratio = descriptor->aspect_ratio;
2950  st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2951  st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2952  st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2953  st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2954  if (descriptor->mastering) {
2955  if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
2956  AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2957  (uint8_t *)descriptor->mastering, sizeof(*descriptor->mastering), 0)) {
2958  ret = AVERROR(ENOMEM);
2959  goto fail_and_free;
2960  }
2961  descriptor->mastering = NULL;
2962  }
2963  if (descriptor->coll) {
2964  if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
2965  AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2966  (uint8_t *)descriptor->coll, descriptor->coll_size, 0)) {
2967  ret = AVERROR(ENOMEM);
2968  goto fail_and_free;
2969  }
2970  descriptor->coll = NULL;
2971  }
2972  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2973  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2974  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2975  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))
2976  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2977  st->codecpar->ch_layout.nb_channels = descriptor->channels;
2978 
2979  if (descriptor->sample_rate.den > 0) {
2980  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2981  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2982  } else {
2983  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2984  "found for stream #%d, time base forced to 1/48000\n",
2985  descriptor->sample_rate.num, descriptor->sample_rate.den,
2986  st->index);
2987  avpriv_set_pts_info(st, 64, 1, 48000);
2988  }
2989 
2990  /* if duration is set, rescale it from EditRate to SampleRate */
2991  if (st->duration != AV_NOPTS_VALUE)
2992  st->duration = av_rescale_q(st->duration,
2993  av_inv_q(material_track->edit_rate),
2994  st->time_base);
2995 
2996  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2997  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2998  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2999  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
3000  else if (descriptor->bits_per_sample == 32)
3001  st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
3002  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
3003  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3004  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
3005  else if (descriptor->bits_per_sample == 32)
3006  st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
3007  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
3008  sti->need_parsing = AVSTREAM_PARSE_FULL;
3009  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
3010  sti->need_parsing = AVSTREAM_PARSE_FULL;
3011  }
3012  st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
3013 
3014  if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
3015  av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
3016  return AVERROR_INVALIDDATA;
3017  }
3018 
3019  ret = parse_mca_labels(mxf, source_track, descriptor, st);
3020  if (ret < 0)
3021  return ret;
3022  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
3023  enum AVMediaType type;
3024  container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
3025  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
3026  st->codecpar->codec_id = container_ul->id;
3027  type = avcodec_get_type(st->codecpar->codec_id);
3028  if (type == AVMEDIA_TYPE_SUBTITLE)
3029  st->codecpar->codec_type = type;
3030  if (container_ul->desc)
3031  av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
3032  if (mxf->eia608_extract &&
3033  container_ul->desc &&
3034  !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
3035  st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
3036  st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
3037  }
3038  }
3039  if (!descriptor->extradata)
3040  parse_ffv1_sub_descriptor(mxf, source_track, descriptor, st);
3041  if (descriptor->extradata) {
3042  if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
3043  memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
3044  }
3045  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3046  int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
3047  &descriptor->essence_codec_ul)->id;
3048  if (coded_width)
3049  st->codecpar->width = coded_width;
3050  ret = ff_generate_avci_extradata(st);
3051  if (ret < 0)
3052  return ret;
3053  }
3054  if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
3055  /* TODO: decode timestamps */
3056  sti->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
3057  }
3058  }
3059 
3060  for (int i = 0; i < mxf->fc->nb_streams; i++) {
3061  MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
3062  if (track1 && track1->body_sid) {
3063  for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
3064  MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
3065  if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
3066  if (track1->wrapping == UnknownWrapped)
3067  track1->wrapping = track2->wrapping;
3068  else if (track2->wrapping == UnknownWrapped)
3069  track2->wrapping = track1->wrapping;
3070  else
3071  av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
3072  "with different wrapping\n", i, j, track1->body_sid);
3073  }
3074  }
3075  }
3076  }
3077 
3078  ret = 0;
3079 fail_and_free:
3080  return ret;
3081 }
3082 
3083 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
3084 {
3085  struct tm time = { 0 };
3086  int msecs;
3087  time.tm_year = (timestamp >> 48) - 1900;
3088  time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
3089  time.tm_mday = (timestamp >> 32 & 0xFF);
3090  time.tm_hour = (timestamp >> 24 & 0xFF);
3091  time.tm_min = (timestamp >> 16 & 0xFF);
3092  time.tm_sec = (timestamp >> 8 & 0xFF);
3093  msecs = (timestamp & 0xFF) * 4;
3094 
3095  /* Clip values for legacy reasons. Maybe we should return error instead? */
3096  time.tm_mon = av_clip(time.tm_mon, 0, 11);
3097  time.tm_mday = av_clip(time.tm_mday, 1, 31);
3098  time.tm_hour = av_clip(time.tm_hour, 0, 23);
3099  time.tm_min = av_clip(time.tm_min, 0, 59);
3100  time.tm_sec = av_clip(time.tm_sec, 0, 59);
3101  msecs = av_clip(msecs, 0, 999);
3102 
3103  return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
3104 }
3105 
3106 #define SET_STR_METADATA(pb, name, str) do { \
3107  if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
3108  return ret; \
3109  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3110 } while (0)
3111 
3112 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
3113  major = avio_rb16(pb); \
3114  minor = avio_rb16(pb); \
3115  tertiary = avio_rb16(pb); \
3116  patch = avio_rb16(pb); \
3117  release = avio_rb16(pb); \
3118  if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
3119  return ret; \
3120  av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3121 } while (0)
3122 
3123 #define SET_UID_METADATA(pb, name, var, str) do { \
3124  char uuid_str[2 * AV_UUID_LEN + 4 + 1]; \
3125  avio_read(pb, var, 16); \
3126  av_uuid_unparse(uid, uuid_str); \
3127  av_dict_set(&s->metadata, name, uuid_str, 0); \
3128 } while (0)
3129 
3130 #define SET_TS_METADATA(pb, name, var, str) do { \
3131  var = avio_rb64(pb); \
3132  if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
3133  return ret; \
3134 } while (0)
3135 
3136 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
3137 {
3138  MXFContext *mxf = arg;
3139  AVFormatContext *s = mxf->fc;
3140  int ret;
3141  UID uid = { 0 };
3142  char *str = NULL;
3143  uint64_t ts;
3144  uint16_t major, minor, tertiary, patch, release;
3145  switch (tag) {
3146  case 0x3C01:
3147  SET_STR_METADATA(pb, "company_name", str);
3148  break;
3149  case 0x3C02:
3150  SET_STR_METADATA(pb, "product_name", str);
3151  break;
3152  case 0x3C03:
3153  SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
3154  break;
3155  case 0x3C04:
3156  SET_STR_METADATA(pb, "product_version", str);
3157  break;
3158  case 0x3C05:
3159  SET_UID_METADATA(pb, "product_uid", uid, str);
3160  break;
3161  case 0x3C06:
3162  SET_TS_METADATA(pb, "modification_date", ts, str);
3163  break;
3164  case 0x3C07:
3165  SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
3166  break;
3167  case 0x3C08:
3168  SET_STR_METADATA(pb, "application_platform", str);
3169  break;
3170  case 0x3C09:
3171  SET_UID_METADATA(pb, "generation_uid", uid, str);
3172  break;
3173  case 0x3C0A:
3174  SET_UID_METADATA(pb, "uid", uid, str);
3175  break;
3176  }
3177  return 0;
3178 }
3179 
3180 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
3181 {
3182  MXFContext *mxf = arg;
3183  AVFormatContext *s = mxf->fc;
3184  int ret;
3185  char *str = NULL;
3186 
3187  if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
3188  SET_STR_METADATA(pb, "project_name", str);
3189  }
3190  return 0;
3191 }
3192 
3193 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
3194  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
3195  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
3196  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
3197  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
3198  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
3199  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
3200  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
3201  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
3202  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
3203  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
3204  { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
3205  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
3206  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
3207  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage },
3208  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
3209  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
3210  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
3211  { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
3212  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
3213  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
3214  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
3215  { { 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 */
3216  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
3217  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
3218  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
3219  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
3220  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
3221  { { 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 */
3222  { { 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 */
3223  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
3224  { { 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 */
3225  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6b,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), AudioChannelLabelSubDescriptor },
3226  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6c,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), SoundfieldGroupLabelSubDescriptor },
3227  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6d,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor },
3228  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x81,0x03 }, mxf_read_ffv1_sub_descriptor, sizeof(MXFFFV1SubDescriptor), FFV1SubDescriptor },
3229  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
3230  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
3231  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
3232  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
3233  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
3234  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
3235  { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
3236  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL },
3237 };
3238 
3239 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
3240 {
3241  ctx->partition_score = partition_score(partition);
3242  switch (type){
3243  case MultipleDescriptor:
3244  case Descriptor:
3245  ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
3246  ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
3247  break;
3248  default:
3249  break;
3250  }
3251  return 0;
3252 }
3253 
3254 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
3255 {
3256  AVIOContext *pb = mxf->fc->pb;
3257  uint64_t klv_end = avio_tell(pb) + klv->length;
3258  MXFMetadataSet *meta;
3259  void *ctx;
3260 
3261  if (ctx_size) {
3262  meta = av_mallocz(ctx_size);
3263  if (!meta)
3264  return AVERROR(ENOMEM);
3265  ctx = meta;
3266  mxf_metadataset_init(meta, type, mxf->current_partition);
3267  } else {
3268  meta = NULL;
3269  ctx = mxf;
3270  }
3271  while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
3272  int ret;
3273  int tag = avio_rb16(pb);
3274  int size = avio_rb16(pb); /* KLV specified by 0x53 */
3275  int64_t next = avio_tell(pb);
3276  UID uid = {0};
3277  if (next < 0 || next > INT64_MAX - size) {
3278  if (meta) {
3279  mxf_free_metadataset(&meta, type);
3280  }
3281  return next < 0 ? next : AVERROR_INVALIDDATA;
3282  }
3283  next += size;
3284 
3285  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
3286  if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
3287  av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
3288  continue;
3289  }
3290  if (tag > 0x7FFF) { /* dynamic tag */
3291  int i;
3292  for (i = 0; i < mxf->local_tags_count; i++) {
3293  int local_tag = AV_RB16(mxf->local_tags+i*18);
3294  if (local_tag == tag) {
3295  memcpy(uid, mxf->local_tags+i*18+2, 16);
3296  av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
3297  PRINT_KEY(mxf->fc, "uid", uid);
3298  }
3299  }
3300  }
3301  if (meta && tag == 0x3C0A) {
3302  avio_read(pb, meta->uid, 16);
3303  } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
3304  if (meta) {
3305  mxf_free_metadataset(&meta, type);
3306  }
3307  return ret;
3308  }
3309 
3310  /* Accept the 64k local set limit being exceeded (Avid). Don't accept
3311  * it extending past the end of the KLV though (zzuf5.mxf). */
3312  if (avio_tell(pb) > klv_end) {
3313  if (meta) {
3314  mxf_free_metadataset(&meta, type);
3315  }
3316 
3317  av_log(mxf->fc, AV_LOG_ERROR,
3318  "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
3319  tag, klv->offset);
3320  return AVERROR_INVALIDDATA;
3321  } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
3322  avio_seek(pb, next, SEEK_SET);
3323  }
3324  return meta ? mxf_add_metadata_set(mxf, &meta, type) : 0;
3325 }
3326 
3327 /**
3328  * Matches any partition pack key, in other words:
3329  * - HeaderPartition
3330  * - BodyPartition
3331  * - FooterPartition
3332  * @return non-zero if the key is a partition pack key, zero otherwise
3333  */
3334 static int mxf_is_partition_pack_key(UID key)
3335 {
3336  //NOTE: this is a little lax since it doesn't constraint key[14]
3337  return !memcmp(key, mxf_header_partition_pack_key, 13) &&
3338  key[13] >= 2 && key[13] <= 4;
3339 }
3340 
3341 /**
3342  * Parses a metadata KLV
3343  * @return <0 on error, 0 otherwise
3344  */
3345 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
3346  int ctx_size, enum MXFMetadataSetType type)
3347 {
3348  AVFormatContext *s = mxf->fc;
3349  int res;
3350  if (klv.key[5] == 0x53) {
3351  res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
3352  } else {
3353  uint64_t next = avio_tell(s->pb) + klv.length;
3354  res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
3355 
3356  /* only seek forward, else this can loop for a long time */
3357  if (avio_tell(s->pb) > next) {
3358  av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
3359  klv.offset);
3360  return AVERROR_INVALIDDATA;
3361  }
3362 
3363  avio_seek(s->pb, next, SEEK_SET);
3364  }
3365  if (res < 0) {
3366  av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3367  return res;
3368  }
3369  return 0;
3370 }
3371 
3372 /**
3373  * Seeks to the previous partition and parses it, if possible
3374  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3375  */
3376 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3377 {
3378  AVIOContext *pb = mxf->fc->pb;
3379  KLVPacket klv;
3380  int64_t current_partition_ofs;
3381  int ret;
3382 
3383  if (!mxf->current_partition ||
3384  mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3385  return 0; /* we've parsed all partitions */
3386 
3387  /* seek to previous partition */
3388  current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3389  avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3390  mxf->current_partition = NULL;
3391 
3392  av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3393 
3394  /* Make sure this is actually a PartitionPack, and if so parse it.
3395  * See deadlock2.mxf
3396  */
3397  if ((ret = klv_read_packet(mxf, &klv, pb)) < 0) {
3398  av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3399  return ret;
3400  }
3401 
3402  if (!mxf_is_partition_pack_key(klv.key)) {
3403  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3404  return AVERROR_INVALIDDATA;
3405  }
3406 
3407  /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3408  * can point to just before the current partition, causing klv_read_packet()
3409  * to sync back up to it. See deadlock3.mxf
3410  */
3411  if (klv.offset >= current_partition_ofs) {
3412  av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3413  PRIx64 " indirectly points to itself\n", current_partition_ofs);
3414  return AVERROR_INVALIDDATA;
3415  }
3416 
3417  if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3418  return ret;
3419 
3420  return 1;
3421 }
3422 
3423 /**
3424  * Called when essence is encountered
3425  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3426  */
3427 static int mxf_parse_handle_essence(MXFContext *mxf)
3428 {
3429  AVIOContext *pb = mxf->fc->pb;
3430  int64_t ret;
3431 
3432  if (mxf->parsing_backward) {
3433  return mxf_seek_to_previous_partition(mxf);
3434  } else {
3435  if (!mxf->footer_partition) {
3436  av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3437  return 0;
3438  }
3439 
3440  av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3441 
3442  /* remember where we were so we don't end up seeking further back than this */
3443  mxf->last_forward_tell = avio_tell(pb);
3444 
3445  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3446  av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3447  return -1;
3448  }
3449 
3450  /* seek to FooterPartition and parse backward */
3451  if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3452  av_log(mxf->fc, AV_LOG_ERROR,
3453  "failed to seek to FooterPartition @ 0x%" PRIx64
3454  " (%"PRId64") - partial file?\n",
3455  mxf->run_in + mxf->footer_partition, ret);
3456  return ret;
3457  }
3458 
3459  mxf->current_partition = NULL;
3460  mxf->parsing_backward = 1;
3461  }
3462 
3463  return 1;
3464 }
3465 
3466 /**
3467  * Called when the next partition or EOF is encountered
3468  * @return <= 0 if we should stop parsing, > 0 if we should keep going
3469  */
3470 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3471 {
3472  return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3473 }
3474 
3475 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3476 {
3477  for (int i = 0; i < s->nb_streams; i++) {
3478  MXFTrack *track = s->streams[i]->priv_data;
3479  if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3480  return track->wrapping;
3481  }
3482  return UnknownWrapped;
3483 }
3484 
3485 /**
3486  * Figures out the proper offset and length of the essence container in each partition
3487  */
3488 static void mxf_compute_essence_containers(AVFormatContext *s)
3489 {
3490  MXFContext *mxf = s->priv_data;
3491  int x;
3492 
3493  for (x = 0; x < mxf->partitions_count; x++) {
3494  MXFPartition *p = &mxf->partitions[x];
3495  MXFWrappingScheme wrapping;
3496 
3497  if (!p->body_sid)
3498  continue; /* BodySID == 0 -> no essence */
3499 
3500  /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3501  * otherwise we point essence_offset at the key of the first essence KLV.
3502  */
3503 
3504  wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3505 
3506  if (wrapping == ClipWrapped) {
3507  p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3508  p->essence_length = p->first_essence_klv.length;
3509  } else {
3510  p->essence_offset = p->first_essence_klv.offset;
3511 
3512  /* essence container spans to the next partition */
3513  if (x < mxf->partitions_count - 1)
3514  p->essence_length = mxf->partitions[x+1].pack_ofs - mxf->run_in - p->essence_offset;
3515 
3516  if (p->essence_length < 0) {
3517  /* next ThisPartition < essence_offset */
3518  p->essence_length = 0;
3519  av_log(mxf->fc, AV_LOG_ERROR,
3520  "partition %i: bad ThisPartition = %"PRIX64"\n",
3521  x+1, mxf->partitions[x+1].pack_ofs - mxf->run_in);
3522  }
3523  }
3524  }
3525 }
3526 
3527 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3528 {
3529  int i;
3530  for (i = 0; i < mxf->nb_index_tables; i++)
3531  if (mxf->index_tables[i].index_sid == index_sid)
3532  return &mxf->index_tables[i];
3533  return NULL;
3534 }
3535 
3536 /**
3537  * Deal with the case where for some audio atoms EditUnitByteCount is
3538  * very small (2, 4..). In those cases we should read more than one
3539  * sample per call to mxf_read_packet().
3540  */
3541 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3542 {
3543  MXFTrack *track = st->priv_data;
3544  MXFIndexTable *t;
3545 
3546  if (!track)
3547  return;
3548  track->edit_units_per_packet = 1;
3549  if (track->wrapping != ClipWrapped)
3550  return;
3551 
3552  t = mxf_find_index_table(mxf, track->index_sid);
3553 
3554  /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3555  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3556  !is_pcm(st->codecpar->codec_id) ||
3557  !t ||
3558  t->nb_segments != 1 ||
3559  t->segments[0]->edit_unit_byte_count >= 32)
3560  return;
3561 
3562  /* arbitrarily default to 48 kHz PAL audio frame size */
3563  /* TODO: We could compute this from the ratio between the audio
3564  * and video edit rates for 48 kHz NTSC we could use the
3565  * 1802-1802-1802-1802-1801 pattern. */
3566  track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3567 }
3568 
3569 /**
3570  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3571  */
3572 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3573 {
3574  MXFTrack *track = st->priv_data;
3575  MXFIndexTableSegment *segment = NULL;
3576  MXFPartition *p = NULL;
3577  int essence_partition_count = 0;
3578  int edit_unit_byte_count = 0;
3579  int i, ret;
3580  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[IndexTableSegment];
3581 
3582  if (!track || track->wrapping != ClipWrapped)
3583  return 0;
3584 
3585  /* check if track already has an IndexTableSegment */
3586  for (i = 0; i < mg->metadata_sets_count; i++) {
3587  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
3588  if (s->body_sid == track->body_sid)
3589  return 0;
3590  }
3591 
3592  /* find the essence partition */
3593  for (i = 0; i < mxf->partitions_count; i++) {
3594  /* BodySID == 0 -> no essence */
3595  if (mxf->partitions[i].body_sid != track->body_sid)
3596  continue;
3597 
3598  p = &mxf->partitions[i];
3599  essence_partition_count++;
3600  }
3601 
3602  /* only handle files with a single essence partition */
3603  if (essence_partition_count != 1)
3604  return 0;
3605 
3606  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3607  edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) *
3608  st->codecpar->ch_layout.nb_channels) >> 3;
3609  } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3610  edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3611  }
3612 
3613  if (edit_unit_byte_count <= 0)
3614  return 0;
3615 
3616  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);
3617 
3618  if (!(segment = av_mallocz(sizeof(*segment))))
3619  return AVERROR(ENOMEM);
3620 
3621  if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment, IndexTableSegment)))
3622  return ret;
3623 
3624  /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3625  * using the same SID for index is forbidden in MXF. */
3626  if (!track->index_sid)
3627  track->index_sid = track->body_sid;
3628 
3629  /* stream will be treated as small EditUnitByteCount */
3630  segment->edit_unit_byte_count = edit_unit_byte_count;
3631  segment->index_start_position = 0;
3632  segment->index_duration = st->duration;
3633  segment->index_edit_rate = av_inv_q(st->time_base);
3634  segment->index_sid = track->index_sid;
3635  segment->body_sid = p->body_sid;
3636  return 0;
3637 }
3638 
3639 static void mxf_read_random_index_pack(AVFormatContext *s)
3640 {
3641  MXFContext *mxf = s->priv_data;
3642  uint32_t length;
3643  int64_t file_size, max_rip_length, min_rip_length;
3644  KLVPacket klv;
3645 
3646  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3647  return;
3648 
3649  file_size = avio_size(s->pb);
3650 
3651  /* S377m says to check the RIP length for "silly" values, without defining "silly".
3652  * The limit below assumes a file with nothing but partition packs and a RIP.
3653  * Before changing this, consider that a muxer may place each sample in its own partition.
3654  *
3655  * 105 is the size of the smallest possible PartitionPack
3656  * 12 is the size of each RIP entry
3657  * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3658  */
3659  max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3660  max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3661 
3662  /* We're only interested in RIPs with at least two entries.. */
3663  min_rip_length = 16+1+24+4;
3664 
3665  /* See S377m section 11 */
3666  avio_seek(s->pb, file_size - 4, SEEK_SET);
3667  length = avio_rb32(s->pb);
3668 
3669  if (length < min_rip_length || length > max_rip_length)
3670  goto end;
3671  avio_seek(s->pb, file_size - length, SEEK_SET);
3672  if (klv_read_packet(mxf, &klv, s->pb) < 0 ||
3673  !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3674  goto end;
3675  if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3676  av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3677  goto end;
3678  }
3679 
3680  avio_skip(s->pb, klv.length - 12);
3681  mxf->footer_partition = avio_rb64(s->pb);
3682 
3683  /* sanity check */
3684  if (mxf->run_in + mxf->footer_partition >= file_size) {
3685  av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3686  mxf->footer_partition = 0;
3687  }
3688 
3689 end:
3690  avio_seek(s->pb, mxf->run_in, SEEK_SET);
3691 }
3692 
3693 static int mxf_read_header(AVFormatContext *s)
3694 {
3695  MXFContext *mxf = s->priv_data;
3696  KLVPacket klv;
3697  int64_t essence_offset = 0;
3698  int ret;
3699  int64_t run_in;
3700 
3701  mxf->last_forward_tell = INT64_MAX;
3702 
3703  if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3704  av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3705  return AVERROR_INVALIDDATA;
3706  }
3707  avio_seek(s->pb, -14, SEEK_CUR);
3708  mxf->fc = s;
3709  run_in = avio_tell(s->pb);
3710  if (run_in < 0 || run_in > RUN_IN_MAX)
3711  return AVERROR_INVALIDDATA;
3712  mxf->run_in = run_in;
3713 
3714  mxf_read_random_index_pack(s);
3715 
3716  while (!avio_feof(s->pb)) {
3717  const MXFMetadataReadTableEntry *metadata;
3718 
3719  ret = klv_read_packet(mxf, &klv, s->pb);
3720  if (ret < 0 || IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key)) {
3721  if (ret >= 0 && avio_size(s->pb) > klv.next_klv)
3722  av_log(s, AV_LOG_WARNING, "data after the RandomIndexPack, assuming end of file\n");
3723  /* EOF - seek to previous partition or stop */
3724  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3725  break;
3726  else
3727  continue;
3728  }
3729 
3730  PRINT_KEY(s, "read header", klv.key);
3731  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3732  if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key)) ||
3733  IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3734  IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3735  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3736  IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3737  IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3738 
3739  if (!mxf->current_partition) {
3740  av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3741  return AVERROR_INVALIDDATA;
3742  }
3743 
3744  if (!mxf->current_partition->first_essence_klv.offset)
3745  mxf->current_partition->first_essence_klv = klv;
3746 
3747  if (!essence_offset)
3748  essence_offset = klv.offset;
3749 
3750  /* seek to footer, previous partition or stop */
3751  if (mxf_parse_handle_essence(mxf) <= 0)
3752  break;
3753  continue;
3754  } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3755  /* next partition pack - keep going, seek to previous partition or stop */
3756  if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3757  break;
3758  else if (mxf->parsing_backward)
3759  continue;
3760  /* we're still parsing forward. proceed to parsing this partition pack */
3761  }
3762 
3763  for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3764  if (IS_KLV_KEY(klv.key, metadata->key)) {
3765  if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3766  return ret;
3767  break;
3768  }
3769  }
3770  if (!metadata->read) {
3771  av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3772  UID_ARG(klv.key));
3773  avio_skip(s->pb, klv.length);
3774  }
3775  }
3776  /* FIXME avoid seek */
3777  if (!essence_offset) {
3778  av_log(s, AV_LOG_ERROR, "no essence\n");
3779  return AVERROR_INVALIDDATA;
3780  }
3781  avio_seek(s->pb, essence_offset, SEEK_SET);
3782 
3783  /* we need to do this before computing the index tables
3784  * to be able to fill in zero IndexDurations with st->duration */
3785  if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3786  return ret;
3787 
3788  for (int i = 0; i < s->nb_streams; i++)
3789  mxf_handle_missing_index_segment(mxf, s->streams[i]);
3790 
3791  if ((ret = mxf_compute_index_tables(mxf)) < 0)
3792  return ret;
3793 
3794  if (mxf->nb_index_tables > 1) {
3795  /* TODO: look up which IndexSID to use via EssenceContainerData */
3796  av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3797  mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3798  } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3799  av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3800  return AVERROR_INVALIDDATA;
3801  }
3802 
3803  mxf_compute_essence_containers(s);
3804 
3805  for (int i = 0; i < s->nb_streams; i++)
3806  mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3807 
3808  return 0;
3809 }
3810 
3811 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3812 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3813 {
3814  int64_t a, b, m, offset;
3815  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3816 
3817  if (!t || track->original_duration <= 0)
3818  return -1;
3819 
3820  a = -1;
3821  b = track->original_duration;
3822  while (b - 1 > a) {
3823  m = (a + b) >> 1;
3824  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3825  return -1;
3826  if (offset < current_offset)
3827  a = m;
3828  else
3829  b = m;
3830  }
3831 
3832  *edit_unit_out = b;
3833 
3834  return 0;
3835 }
3836 
3837 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3838  int64_t edit_unit)
3839 {
3840  MXFTrack *track = st->priv_data;
3841  AVRational time_base = av_inv_q(track->edit_rate);
3842  AVRational sample_rate = av_inv_q(st->time_base);
3843 
3844  // For non-audio sample_count equals current edit unit
3845  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3846  return edit_unit;
3847 
3848  if ((sample_rate.num / sample_rate.den) == 48000) {
3849  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3850  } else {
3851  int64_t remainder = (sample_rate.num * (int64_t) time_base.num) %
3852  ( time_base.den * (int64_t)sample_rate.den);
3853  if (remainder)
3854  av_log(mxf->fc, AV_LOG_WARNING,
3855  "seeking detected on stream #%d with time base (%d/%d) and "
3856  "sample rate (%d/%d), audio pts won't be accurate.\n",
3857  st->index, time_base.num, time_base.den,
3858  sample_rate.num, sample_rate.den);
3859  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3860  }
3861 }
3862 
3863 /**
3864  * Make sure track->sample_count is correct based on what offset we're currently at.
3865  * Also determine the next edit unit (or packet) offset.
3866  * @return next_ofs if OK, <0 on error
3867  */
3868 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3869 {
3870  int64_t next_ofs = -1;
3871  MXFTrack *track = st->priv_data;
3872  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3873  int64_t new_edit_unit;
3874  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3875 
3876  if (!t || track->wrapping == UnknownWrapped)
3877  return -1;
3878 
3879  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3880  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3881  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3882  return -1;
3883  }
3884 
3885  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3886  if (next_ofs > current_offset)
3887  return next_ofs;
3888 
3889  if (!resync) {
3890  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3891  return -1;
3892  }
3893 
3894  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3895  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3896  return -1;
3897  }
3898 
3899  new_edit_unit--;
3900  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3901  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);
3902 
3903  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3904 }
3905 
3906 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3907  AVPacket *pkt)
3908 {
3909  AVStream *st = mxf->fc->streams[pkt->stream_index];
3910  MXFTrack *track = st->priv_data;
3911  int64_t bits_per_sample = par->bits_per_coded_sample;
3912 
3913  if (!bits_per_sample)
3914  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3915 
3916  pkt->pts = track->sample_count;
3917 
3918  if (par->ch_layout.nb_channels <= 0 ||
3919  bits_per_sample <= 0 ||
3920  par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
3921  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);
3922  else
3923  track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
3924 
3925  return 0;
3926 }
3927 
3928 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3929 {
3930  AVCodecParameters *par = st->codecpar;
3931  MXFTrack *track = st->priv_data;
3932 
3933  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3934  /* see if we have an index table to derive timestamps from */
3935  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3936 
3937  if (t && track->sample_count < t->nb_ptses) {
3938  pkt->dts = track->sample_count + t->first_dts;
3939  pkt->pts = t->ptses[track->sample_count];
3940  } else if (track->intra_only) {
3941  /* intra-only -> PTS = EditUnit.
3942  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3943  pkt->pts = track->sample_count;
3944  }
3945  track->sample_count++;
3946  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3947  int ret = mxf_set_audio_pts(mxf, par, pkt);
3948  if (ret < 0)
3949  return ret;
3950  } else if (track) {
3951  pkt->dts = pkt->pts = track->sample_count;
3952  pkt->duration = 1;
3953  track->sample_count++;
3954  }
3955  return 0;
3956 }
3957 
3958 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3959 {
3960  KLVPacket klv;
3961  MXFContext *mxf = s->priv_data;
3962  int ret;
3963 
3964  while (1) {
3965  int64_t max_data_size;
3966  int64_t pos = avio_tell(s->pb);
3967 
3968  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3969  mxf->current_klv_data = (KLVPacket){{0}};
3970  ret = klv_read_packet(mxf, &klv, s->pb);
3971  if (ret < 0)
3972  break;
3973  max_data_size = klv.length;
3974  pos = klv.next_klv - klv.length;
3975  PRINT_KEY(s, "read packet", klv.key);
3976  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3977  if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key))) {
3978  ret = mxf_decrypt_triplet(s, pkt, &klv);
3979  if (ret < 0) {
3980  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3981  return ret;
3982  }
3983  return 0;
3984  }
3985  } else {
3986  klv = mxf->current_klv_data;
3987  max_data_size = klv.next_klv - pos;
3988  }
3989  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3990  IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3991  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3992  int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3993  int index = mxf_get_stream_index(s, &klv, body_sid);
3994  int64_t next_ofs;
3995  AVStream *st;
3996  MXFTrack *track;
3997 
3998  if (index < 0) {
3999  av_log(s, AV_LOG_ERROR,
4000  "error getting stream index %"PRIu32"\n",
4001  AV_RB32(klv.key + 12));
4002  goto skip;
4003  }
4004 
4005  st = s->streams[index];
4006  track = st->priv_data;
4007 
4008  if (s->streams[index]->discard == AVDISCARD_ALL)
4009  goto skip;
4010 
4011  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
4012 
4013  if (track->wrapping != FrameWrapped) {
4014  int64_t size;
4015 
4016  if (next_ofs <= 0) {
4017  // If we have no way to packetize the data, then return it in chunks...
4018  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
4019  ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
4020  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
4021  }
4022  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
4023  } else {
4024  if ((size = next_ofs - pos) <= 0) {
4025  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
4026  mxf->current_klv_data = (KLVPacket){{0}};
4027  return AVERROR_INVALIDDATA;
4028  }
4029  // We must not overread, because the next edit unit might be in another KLV
4030  if (size > max_data_size)
4031  size = max_data_size;
4032  }
4033 
4034  mxf->current_klv_data = klv;
4035  klv.offset = pos;
4036  klv.length = size;
4037  klv.next_klv = klv.offset + klv.length;
4038  }
4039 
4040  /* check for 8 channels AES3 element */
4041  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
4042  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
4043  pkt, klv.length);
4044  if (ret < 0) {
4045  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
4046  mxf->current_klv_data = (KLVPacket){{0}};
4047  return ret;
4048  }
4049  } else if (mxf->eia608_extract &&
4050  s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4051  ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4052  if (ret < 0) {
4053  mxf->current_klv_data = (KLVPacket){{0}};
4054  return ret;
4055  }
4056  } else {
4057  ret = av_get_packet(s->pb, pkt, klv.length);
4058  if (ret < 0) {
4059  mxf->current_klv_data = (KLVPacket){{0}};
4060  return ret;
4061  }
4062  }
4063  pkt->stream_index = index;
4064  pkt->pos = klv.offset;
4065 
4066  ret = mxf_set_pts(mxf, st, pkt);
4067  if (ret < 0) {
4068  mxf->current_klv_data = (KLVPacket){{0}};
4069  return ret;
4070  }
4071 
4072  /* seek for truncated packets */
4073  avio_seek(s->pb, klv.next_klv, SEEK_SET);
4074 
4075  return 0;
4076  } else {
4077  skip:
4078  avio_skip(s->pb, max_data_size);
4079  mxf->current_klv_data = (KLVPacket){{0}};
4080  }
4081  }
4082  return avio_feof(s->pb) ? AVERROR_EOF : ret;
4083 }
4084 
4085 static int mxf_read_close(AVFormatContext *s)
4086 {
4087  MXFContext *mxf = s->priv_data;
4088  int i;
4089 
4090  av_freep(&mxf->packages_refs);
4091  av_freep(&mxf->essence_container_data_refs);
4092 
4093  for (i = 0; i < s->nb_streams; i++)
4094  s->streams[i]->priv_data = NULL;
4095 
4096  for (int type = 0; type < FF_ARRAY_ELEMS(mxf->metadata_set_groups); type++) {
4097  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
4098  for (i = 0; i < mg->metadata_sets_count; i++)
4099  mxf_free_metadataset(mg->metadata_sets + i, type);
4100  mg->metadata_sets_count = 0;
4101  av_freep(&mg->metadata_sets);
4102  }
4103  av_freep(&mxf->partitions);
4104  av_freep(&mxf->aesc);
4105  av_freep(&mxf->local_tags);
4106 
4107  if (mxf->index_tables) {
4108  for (i = 0; i < mxf->nb_index_tables; i++) {
4109  av_freep(&mxf->index_tables[i].segments);
4110  av_freep(&mxf->index_tables[i].ptses);
4111  av_freep(&mxf->index_tables[i].fake_index);
4112  av_freep(&mxf->index_tables[i].offsets);
4113  }
4114  }
4115  av_freep(&mxf->index_tables);
4116 
4117  return 0;
4118 }
4119 
4120 static int mxf_probe(const AVProbeData *p) {
4121  const uint8_t *bufp = p->buf;
4122  const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4123 
4124  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4125  return 0;
4126 
4127  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4128  end -= sizeof(mxf_header_partition_pack_key);
4129 
4130  for (; bufp < end;) {
4131  if (!((bufp[13] - 1) & 0xF2)){
4132  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4133  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4134  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4135  AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
4136  return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4137  bufp ++;
4138  } else
4139  bufp += 10;
4140  }
4141 
4142  return 0;
4143 }
4144 
4145 /* rudimentary byte seek */
4146 /* XXX: use MXF Index */
4147 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4148 {
4149  AVStream *st = s->streams[stream_index];
4150  int64_t seconds;
4151  MXFContext* mxf = s->priv_data;
4152  int64_t seekpos;
4153  int i, ret;
4154  MXFIndexTable *t;
4155  MXFTrack *source_track = st->priv_data;
4156 
4157  if (!source_track)
4158  return 0;
4159 
4160  /* if audio then truncate sample_time to EditRate */
4161  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4162  sample_time = av_rescale_q(sample_time, st->time_base,
4163  av_inv_q(source_track->edit_rate));
4164 
4165  if (mxf->nb_index_tables <= 0) {
4166  if (!s->bit_rate)
4167  return AVERROR_INVALIDDATA;
4168  if (sample_time < 0)
4169  sample_time = 0;
4170  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4171 
4172  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4173  if (seekpos < 0)
4174  return seekpos;
4175 
4176  avpriv_update_cur_dts(s, st, sample_time);
4177  mxf->current_klv_data = (KLVPacket){{0}};
4178  } else {
4179  MXFPartition *partition;
4180 
4181  t = &mxf->index_tables[0];
4182  if (t->index_sid != source_track->index_sid) {
4183  /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
4184  for (i = 0; i < s->nb_streams; i++) {
4185  MXFTrack *new_source_track = s->streams[i]->priv_data;
4186  if (new_source_track && new_source_track->index_sid == t->index_sid) {
4187  sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
4188  source_track = new_source_track;
4189  st = s->streams[i];
4190  break;
4191  }
4192  }
4193  if (i == s->nb_streams)
4194  return AVERROR_INVALIDDATA;
4195  }
4196 
4197  /* clamp above zero, else ff_index_search_timestamp() returns negative
4198  * this also means we allow seeking before the start */
4199  sample_time = FFMAX(sample_time, 0);
4200 
4201  if (t->fake_index) {
4202  /* The first frames may not be keyframes in presentation order, so
4203  * we have to advance the target to be able to find the first
4204  * keyframe backwards... */
4205  if (!(flags & AVSEEK_FLAG_ANY) &&
4206  (flags & AVSEEK_FLAG_BACKWARD) &&
4207  t->ptses[0] != AV_NOPTS_VALUE &&
4208  sample_time < t->ptses[0] &&
4209  (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
4210  sample_time = t->ptses[0];
4211 
4212  /* behave as if we have a proper index */
4213  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
4214  return sample_time;
4215  /* get the stored order index from the display order index */
4216  sample_time += t->offsets[sample_time];
4217  } else {
4218  /* no IndexEntryArray (one or more CBR segments)
4219  * make sure we don't seek past the end */
4220  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
4221  }
4222 
4223  if (source_track->wrapping == UnknownWrapped)
4224  av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
4225 
4226  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
4227  return ret;
4228 
4229  avpriv_update_cur_dts(s, st, sample_time);
4230  if (source_track->wrapping == ClipWrapped) {
4231  KLVPacket klv = partition->first_essence_klv;
4232  if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
4233  av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
4234  return AVERROR_INVALIDDATA;
4235  }
4236  mxf->current_klv_data = klv;
4237  } else {
4238  mxf->current_klv_data = (KLVPacket){{0}};
4239  }
4240  avio_seek(s->pb, seekpos, SEEK_SET);
4241  }
4242 
4243  // Update all tracks sample count
4244  for (i = 0; i < s->nb_streams; i++) {
4245  AVStream *cur_st = s->streams[i];
4246  MXFTrack *cur_track = cur_st->priv_data;
4247  if (cur_track) {
4248  int64_t track_edit_unit = sample_time;
4249  if (st != cur_st)
4250  mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
4251  cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
4252  }
4253  }
4254  return 0;
4255 }
4256 
4257 static const AVOption options[] = {
4258  { "eia608_extract", "extract eia 608 captions from s436m track",
4259  offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
4260  AV_OPT_FLAG_DECODING_PARAM },
4261  { NULL },
4262 };
4263 
4264 static const AVClass demuxer_class = {
4265  .class_name = "mxf",
4266  .item_name = av_default_item_name,
4267  .option = options,
4268  .version = LIBAVUTIL_VERSION_INT,
4269  .category = AV_CLASS_CATEGORY_DEMUXER,
4270 };
4271 
4272 const FFInputFormat ff_mxf_demuxer = {
4273  .p.name = "mxf",
4274  .p.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
4275  .p.flags = AVFMT_SEEK_TO_PTS,
4276  .p.priv_class = &demuxer_class,
4277  .priv_data_size = sizeof(MXFContext),
4278  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
4279  .read_probe = mxf_probe,
4280  .read_header = mxf_read_header,
4281  .read_packet = mxf_read_packet,
4282  .read_close = mxf_read_close,
4283  .read_seek = mxf_read_seek,
4284 };
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:3693
AV_CODEC_ID_EIA_608
@ AV_CODEC_ID_EIA_608
Definition: codec_id.h:559
MXFMetadataSet::uid
UID uid
Definition: mxfdec.c:117
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
OPSONYOpt
@ OPSONYOpt
Definition: mxfdec.c:89
MXFContext::op
MXFOP op
Definition: mxfdec.c:302
MXFIndexTable::offsets
int8_t * offsets
Definition: mxfdec.c:295
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:366
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:307
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:98
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:3488
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:3906
mxf_add_timecode_metadata
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
Definition: mxfdec.c:2215
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:2421
opt.h
mxf_ffv1_extradata
static const uint8_t mxf_ffv1_extradata[]
Definition: mxfdec.c:349
OPAtom
@ OPAtom
Definition: mxfdec.c:88
Track
Definition: ismindex.c:69
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
AVChannelLayout::u
union AVChannelLayout::@352 u
Details about which channels are present in this layout.
MXFTrack::edit_rate
AVRational edit_rate
Definition: mxfdec.c:183
AV_PROFILE_JPEG2000_DCINEMA_4K
#define AV_PROFILE_JPEG2000_DCINEMA_4K
Definition: defs.h:151
OP2b
@ OP2b
Definition: mxfdec.c:83
FF_MXF_MasteringDisplayMinimumLuminance
#define FF_MXF_MasteringDisplayMinimumLuminance
Definition: mxf.h:100
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
MXFContext::index_tables
MXFIndexTable * index_tables
Definition: mxfdec.c:320
mxf_parse_package_comments
static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
Definition: mxfdec.c:2313
MXFPartition::complete
int complete
Definition: mxfdec.c:100
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVStream::priv_data
void * priv_data
Definition: avformat.h:768
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:3752
RawVWrap
@ RawVWrap
Definition: mxf.h:85
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:200
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
ff_mxf_demuxer
const FFInputFormat ff_mxf_demuxer
Definition: mxfdec.c:4272
MXFMCASubDescriptor::soundfield_group_link_id
UID soundfield_group_link_id
Definition: mxfdec.c:237
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:232
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:1629
avlanguage.h
AVChannelLayout::map
AVChannelCustom * map
This member must be used when the channel order is AV_CHANNEL_ORDER_CUSTOM.
Definition: channel_layout.h:354
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
MXFPartition::kag_size
int32_t kag_size
Definition: mxfdec.c:107
dict_internal.h
MXFPartition::type
MXFPartitionType type
Definition: mxfdec.c:101
OP3b
@ OP3b
Definition: mxfdec.c:86
FF_MXF_MasteringDisplayPrimaries
#define FF_MXF_MasteringDisplayPrimaries
Definition: mxf.h:97
KLVPacket::offset
int64_t offset
Definition: mxf.h:76
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:358
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
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:1323
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
mxf_indirect_value_utf16be
static const uint8_t mxf_indirect_value_utf16be[]
Definition: mxfdec.c:353
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
MXFStructuralComponent::source_track_id
int source_track_id
Definition: mxfdec.c:138
MXFEssenceContainerData::package_ul
UID package_ul
Definition: mxfdec.c:280
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
SourceClip
@ SourceClip
Definition: mxf.h:35
MXFWrappingScheme
MXFWrappingScheme
Definition: mxfdec.c:92
mxf_read_pixel_layout
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
Definition: mxfdec.c:1287
AVOption
AVOption.
Definition: opt.h:346
b
#define b
Definition: input.c:41
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
mxf_resolve_strong_ref
static void * mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
Definition: mxfdec.c:1580
MXFTrack::index_sid
int index_sid
Definition: mxfdec.c:187
MXFMCASubDescriptor::language
char * language
Definition: mxfdec.c:242
mxf_data_essence_container_uls
static const MXFCodecUL mxf_data_essence_container_uls[]
Definition: mxfdec.c:1650
MXFDescriptor::video_line_map
int video_line_map[2]
Definition: mxfdec.c:203
MXFDescriptor::field_dominance
int field_dominance
Definition: mxfdec.c:207
mxf_set_pts
static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
Definition: mxfdec.c:3928
MXFContext::packages_refs
UID * packages_refs
Definition: mxfdec.c:303
MXFStructuralComponent::source_package_uid
UID source_package_uid
Definition: mxfdec.c:134
MXFPartition
Definition: mxfdec.c:98
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
OP1a
@ OP1a
Definition: mxfdec.c:79
mxf_read_content_storage
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1045
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
MXFMetadataSet
Definition: mxfdec.c:116
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
mxf_read_track
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1109
mxf_intra_only_essence_container_uls
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition: mxfdec.c:1616
MXFPartition::pack_length
int pack_length
Definition: mxfdec.c:110
MXFMCASubDescriptor::meta
MXFMetadataSet meta
Definition: mxfdec.c:234
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:260
MXFContext::current_klv_data
KLVPacket current_klv_data
Definition: mxfdec.c:313
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
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:3427
MXFEssenceContainerData::package_uid
UID package_uid
Definition: mxfdec.c:279
MXFDescriptor::black_ref_level
unsigned int black_ref_level
Definition: mxfdec.c:212
MXFDescriptor::essence_container_ul
UID essence_container_ul
Definition: mxfdec.c:195
MXFPulldownComponent
Definition: mxfdec.c:158
mxf_resolve_descriptor
static MXFDescriptor * mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
Definition: mxfdec.c:2255
MXFIndexTableSegment::index_edit_rate
AVRational index_edit_rate
Definition: mxfdec.c:256
MXFDescriptor::essence_codec_ul
UID essence_codec_ul
Definition: mxfdec.c:196
MXFIndexTableSegment::index_duration
uint64_t index_duration
Definition: mxfdec.c:258
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:378
MXFDescriptor::file_descriptors_count
int file_descriptors_count
Definition: mxfdec.c:218
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
mxf_header_partition_pack_key
static const uint8_t mxf_header_partition_pack_key[]
Definition: mxfdec.c:335
Footer
@ Footer
Definition: mxfdec.c:75
MXFPackage::comment_refs
UID * comment_refs
Definition: mxfdec.c:273
MXFContext
Definition: mxfdec.c:298
MXFTrack::sequence_ref
UID sequence_ref
Definition: mxfdec.c:179
ff_mxf_color_trc_uls
const MXFCodecUL ff_mxf_color_trc_uls[]
Definition: mxf.c:112
mxf_parse_structural_metadata
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:2599
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:322
TimecodeComponent
@ TimecodeComponent
Definition: mxf.h:36
MXFDescriptor::color_range
unsigned int color_range
Definition: mxfdec.c:214
sample_rate
sample_rate
Definition: ffmpeg_filter.c:409
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:35
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:128
MXFDescriptor::width
int width
Definition: mxfdec.c:200
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:204
ff_mxf_codec_tag_uls
const MXFCodecUL ff_mxf_codec_tag_uls[]
Definition: mxf.c:92
MXFEssenceGroup
Definition: mxfdec.c:163
ff_generate_avci_extradata
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: demux_utils.c:200
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
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:3527
MXFPartitionType
MXFPartitionType
Definition: mxfdec.c:72
mxf_read_essence_group
static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1153
mxf_group_of_soundfield_groups_link_id
static const uint8_t mxf_group_of_soundfield_groups_link_id[]
Definition: mxfdec.c:360
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:201
MXFEssenceContainerData::meta
MXFMetadataSet meta
Definition: mxfdec.c:278
MXFIndexTableSegment::nb_index_entries
int nb_index_entries
Definition: mxfdec.c:262
MXFTrack::edit_units_per_packet
int edit_units_per_packet
Definition: mxfdec.c:190
mxf.h
mxf_set_current_edit_unit
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
Make sure track->sample_count is correct based on what offset we're currently at.
Definition: mxfdec.c:3868
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:853
mxf_apple_coll_max_fall
static const uint8_t mxf_apple_coll_max_fall[]
Definition: mxfdec.c:355
MXFPartition::closed
int closed
Definition: mxfdec.c:99
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
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:2435
mxf_mca_rfc5646_spoken_language
static const uint8_t mxf_mca_rfc5646_spoken_language[]
Definition: mxfdec.c:364
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: avpacket.c:113
MXFDescriptor::channels
int channels
Definition: mxfdec.c:208
timecode.h
mxf_get_next_track_edit_unit
static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
Definition: mxfdec.c:3812
MXFDescriptor::coll_size
size_t coll_size
Definition: mxfdec.c:230
mxf_read_random_index_pack
static void mxf_read_random_index_pack(AVFormatContext *s)
Definition: mxfdec.c:3639
MXFCodecUL::id
int id
Definition: mxf.h:108
MXFMetadataReadTableEntry::key
const UID key
Definition: mxfdec.c:328
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:2497
MXFTrack::original_duration
int64_t original_duration
Definition: mxfdec.c:186
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
mxf_handle_missing_index_segment
static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
Definition: mxfdec.c:3572
MXFSequence::structural_components_refs
UID * structural_components_refs
Definition: mxfdec.c:144
val
static double val(void *priv, double ch)
Definition: aeval.c:78
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:87
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:228
MXFIndexTable::first_dts
int64_t first_dts
Definition: mxfdec.c:290
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
MXFDescriptor::horiz_subsampling
unsigned int horiz_subsampling
Definition: mxfdec.c:215
MXFChannelOrderingUL
Definition: mxfdec.c:1657
MXFPackage::meta
MXFMetadataSet meta
Definition: mxfdec.c:266
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:455
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:1824
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:203
MXFTrack::meta
MXFMetadataSet meta
Definition: mxfdec.c:177
MXFContext::last_forward_partition
int last_forward_partition
Definition: mxfdec.c:318
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:2196
MXFDescriptor::frame_layout
int frame_layout
Definition: mxfdec.c:202
mxf_timestamp_to_int64
static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
Definition: mxfdec.c:3083
OneField
@ OneField
Definition: mxf.h:64
MXFDescriptor::linked_track_id
int linked_track_id
Definition: mxfdec.c:221
mxf_read_identification_metadata
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
Definition: mxfdec.c:3136
MXFPackage::tracks_refs
UID * tracks_refs
Definition: mxfdec.c:269
mxf_probe
static int mxf_probe(const AVProbeData *p)
Definition: mxfdec.c:4120
MXFMetadataReadTableEntry
Definition: mxfdec.c:327
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:760
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:59
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:1490
MXFEssenceGroup::structural_components_count
int structural_components_count
Definition: mxfdec.c:166
mxf_metadata_read_table
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
Definition: mxfdec.c:3193
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:1935
MXFIndexTableSegment
Definition: mxfdec.c:251
MXFIndexTable::nb_segments
int nb_segments
Definition: mxfdec.c:292
PRINT_KEY
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:155
MXFDescriptor::duration
int64_t duration
Definition: mxfdec.c:210
MXFPartition::index_byte_count
int64_t index_byte_count
Definition: mxfdec.c:109
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
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:3180
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:358
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:346
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:254
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:248
MXFTimecodeComponent::drop_frame
int drop_frame
Definition: mxfdec.c:152
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:215
MXFTrack::track_number
uint8_t track_number[4]
Definition: mxfdec.c:182
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h: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:112
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:440
MXFContext::local_tags_count
int local_tags_count
Definition: mxfdec.c:311
MXFSequence
Definition: mxfdec.c:141
MXFDescriptor::sub_descriptors_count
int sub_descriptors_count
Definition: mxfdec.c:220
MXFPackage::package_uid
UID package_uid
Definition: mxfdec.c:267
AV_CHAN_SIDE_RIGHT
@ AV_CHAN_SIDE_RIGHT
Definition: channel_layout.h:60
av_mastering_display_metadata_alloc
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc(void)
Copyright (c) 2016 Neil Birkbeck neil.birkbeck@gmail.com
Definition: mastering_display_metadata.c:27
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
MXFPartition::essence_offset
int64_t essence_offset
absolute offset of essence
Definition: mxfdec.c:105
UID
AVUUID UID
Definition: mxf.h:30
mxf_read_seek
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mxfdec.c:4147
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:374
mxf_indirect_value_utf16le
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfdec.c:352
CryptoContext
Definition: crypto.c:31
MXFStructuralComponent::meta
MXFMetadataSet meta
Definition: mxfdec.c:132
ctx
AVFormatContext * ctx
Definition: movenc.c:48
MXFCodecUL::matching_len
unsigned matching_len
Definition: mxf.h:107
MXFContext::packages_count
int packages_count
Definition: mxfdec.c:304
mxf_encrypted_essence_container
static const uint8_t mxf_encrypted_essence_container[]
Definition: mxfdec.c:347
MXFIndexTableSegment::body_sid
int body_sid
Definition: mxfdec.c:255
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:226
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:317
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:387
key
const char * key
Definition: hwcontext_opencl.c:189
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
MXFDescriptor::color_primaries_ul
UID color_primaries_ul
Definition: mxfdec.c:225
mxf_apple_coll_max_cll
static const uint8_t mxf_apple_coll_max_cll[]
Definition: mxfdec.c:354
klv_decode_ber_length
static int64_t klv_decode_ber_length(AVIOContext *pb)
Definition: mxfdec.c:429
MXFTimecodeComponent
Definition: mxfdec.c:150
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
mxf_mca_label_dictionary_id
static const uint8_t mxf_mca_label_dictionary_id[]
Definition: mxfdec.c:357
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:45
MXFIndexTable::fake_index
AVIndexEntry * fake_index
Definition: mxfdec.c:294
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:229
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:363
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: demux.h:35
OP3c
@ OP3c
Definition: mxfdec.c:87
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h: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:3376
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:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
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:261
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:766
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:2433
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
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:1560
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:782
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:130
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:321
MXFChannelOrderingUL::uid
UID uid
Definition: mxfdec.c:1658
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:1544
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:1885
index_table
static const uint8_t index_table[8]
Definition: siren.c:34
mxf_picture_essence_container_uls
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition: mxfdec.c:1593
MXFStructuralComponent::duration
int64_t duration
Definition: mxfdec.c:136
CryptoContext
@ CryptoContext
Definition: mxf.h:42
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
MXF_MAX_CHUNK_SIZE
#define MXF_MAX_CHUNK_SIZE
Definition: mxfdec.c:69
is_pcm
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:2465
MXFCryptoContext
Definition: mxfdec.c:126
FF_MXF_MASTERING_CHROMA_DEN
#define FF_MXF_MASTERING_CHROMA_DEN
Definition: mxf.h:102
AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
#define AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
The specified retype target order is ignored and the simplest possible (canonical) order is used for ...
Definition: channel_layout.h:692
mxf_avid_project_name
static const uint8_t mxf_avid_project_name[]
Definition: mxfdec.c:350
MXFDescriptor::color_space_ul
UID color_space_ul
Definition: mxfdec.c:227
AV_CHAN_TOP_BACK_CENTER
@ AV_CHAN_TOP_BACK_CENTER
Definition: channel_layout.h:66
FullFrame
@ FullFrame
Definition: mxf.h:62
AVIndexEntry::flags
int flags
Definition: avformat.h:612
OP3a
@ OP3a
Definition: mxfdec.c:85
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:907
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1297
RawAWrap
@ RawAWrap
Definition: mxf.h:84
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:362
av_aes_crypt
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: aes.c:169
parseutils.h
MXFPartition::header_byte_count
int64_t header_byte_count
Definition: mxfdec.c:108
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
av_aes_alloc
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:35
MXFMCASubDescriptor::mca_channel_id
int mca_channel_id
Definition: mxfdec.c:241
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
AV_CHAN_BOTTOM_FRONT_RIGHT
@ AV_CHAN_BOTTOM_FRONT_RIGHT
Definition: channel_layout.h:81
time.h
Track
@ Track
Definition: mxf.h:41
MXFDescriptor::aspect_ratio
AVRational aspect_ratio
Definition: mxfdec.c:199
AV_CHAN_TOP_CENTER
@ AV_CHAN_TOP_CENTER
Definition: channel_layout.h:61
MXFEssenceGroup::duration
int64_t duration
Definition: mxfdec.c:167
MXFTrack::sample_count
uint64_t sample_count
Definition: mxfdec.c:185
mxf_umid_to_str
static void mxf_umid_to_str(const UID ul, const UID uid, char str[2+sizeof(UID) *4+1])
Definition: mxfdec.c:2188
mxf_get_sorted_table_segments
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
Definition: mxfdec.c:1741
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:236
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:649
SET_UID_METADATA
#define SET_UID_METADATA(pb, name, var, str)
Definition: mxfdec.c:3123
MXFEssenceContainerData::index_sid
int index_sid
Definition: mxfdec.c:281
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MXFDescriptor::height
int height
Definition: mxfdec.c:201
mxf_is_partition_pack_key
static int mxf_is_partition_pack_key(UID key)
Matches any partition pack key, in other words:
Definition: mxfdec.c:3334
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:222
MXFMCASubDescriptor::mca_link_id
UID mca_link_id
Definition: mxfdec.c:236
mxf_parse_physical_source_package
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
Definition: mxfdec.c:2333
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:1867
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:1311
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
MXFMetadataSetGroup
Definition: mxfdec.c:121
mxf_read_essence_container_data
static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c: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:103
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:340
MXFChannelOrderingUL::service_type
enum AVAudioServiceType service_type
Definition: mxfdec.c:1660
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:523
MXFEssenceContainerData::body_sid
int body_sid
Definition: mxfdec.c:282
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:106
set_language
static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
Definition: mxfdec.c:2471
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
Header
@ Header
Definition: mxfdec.c:73
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
FFStream
Definition: internal.h:193
mxf_mastering_display_uls
static const uint8_t mxf_mastering_display_uls[4][16]
Definition: mxfdec.c:369
MXFContext::nb_index_tables
int nb_index_tables
Definition: mxfdec.c:319
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:2403
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:865
sample
#define sample
Definition: flacdsp_template.c:44
MXF_FIELD_DOMINANCE_FF
#define MXF_FIELD_DOMINANCE_FF
Definition: mxfdec.c:205
AV_CHAN_LOW_FREQUENCY
@ AV_CHAN_LOW_FREQUENCY
Definition: channel_layout.h:53
size
int size
Definition: twinvq_data.h:10344
MXFTimecodeComponent::meta
MXFMetadataSet meta
Definition: mxfdec.c:151
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_CHAN_BACK_RIGHT
@ AV_CHAN_BACK_RIGHT
Definition: channel_layout.h:55
MXFMetadataReadTableEntry::ctx_size
int ctx_size
Definition: mxfdec.c:330
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
MXFDescriptor
Definition: mxfdec.c:193
AV_CHAN_SIDE_LEFT
@ AV_CHAN_SIDE_LEFT
Definition: channel_layout.h:59
OP2c
@ OP2c
Definition: mxfdec.c:84
MXFStructuralComponent::start_position
int64_t start_position
Definition: mxfdec.c:137
MXFPackage::comment_count
int comment_count
Definition: mxfdec.c:274
J2KWrap
@ J2KWrap
Definition: mxf.h:86
mxf_mca_link_id
static const uint8_t mxf_mca_link_id[]
Definition: mxfdec.c:361
MXFPartition::pack_ofs
int64_t pack_ofs
absolute offset of pack in file, including run-in
Definition: mxfdec.c:111
mxf_get_wrapping_kind
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
Definition: mxfdec.c:1703
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
MXFMetadataSetGroup::metadata_sets_count
int metadata_sets_count
Definition: mxfdec.c:123
MXFContext::partitions
MXFPartition * partitions
Definition: mxfdec.c:300
MXFDescriptor::file_descriptors_refs
UID * file_descriptors_refs
Definition: mxfdec.c:217
mxf_is_intra_only
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition: mxfdec.c:2180
mxf_read_sync
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:446
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
MXFStructuralComponent::data_definition_ul
UID data_definition_ul
Definition: mxfdec.c:135
MXFIndexTable
Definition: mxfdec.c:286
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:602
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:253
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:876
mxf_compute_sample_count
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
Definition: mxfdec.c:3837
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: avpacket.c:697
mxf_get_wrapping_by_body_sid
static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
Definition: mxfdec.c:3475
MXFIndexTableSegment::index_start_position
uint64_t index_start_position
Definition: mxfdec.c:257
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:233
mxf_mca_channel_id
static const uint8_t mxf_mca_channel_id[]
Definition: mxfdec.c:362
mxf_add_umid_metadata
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
Definition: mxfdec.c:2205
AV_CHAN_FRONT_LEFT_OF_CENTER
@ AV_CHAN_FRONT_LEFT_OF_CENTER
Definition: channel_layout.h:56
MixedFields
@ MixedFields
Definition: mxf.h:65
MXFMetadataSet::partition_score
uint64_t partition_score
Definition: mxfdec.c:118
SET_STR_METADATA
#define SET_STR_METADATA(pb, name, str)
Definition: mxfdec.c:3106
mxf_get_codec_ul
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition: mxfdec.c:1570
MXFMCASubDescriptor::group_of_soundfield_groups_link_id_count
int group_of_soundfield_groups_link_id_count
Definition: mxfdec.c:239
MXFSequence::structural_components_count
int structural_components_count
Definition: mxfdec.c:145
MXFMetadataReadFunc
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:325
mxf_klv_key
static const uint8_t mxf_klv_key[]
Definition: mxfdec.c:341
MXFContext::partitions_count
unsigned partitions_count
Definition: mxfdec.c:301
mxf_read_packet
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:3958
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
MXFDescriptor::bits_per_sample
int bits_per_sample
Definition: mxfdec.c:209
mxf_parse_handle_partition_or_eof
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
Definition: mxfdec.c:3470
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:222
RUN_IN_MAX
#define RUN_IN_MAX
Definition: mxfdec.c:70
MXFIndexTable::nb_ptses
int nb_ptses
Definition: mxfdec.c:289
MXFMCASubDescriptor::uid
UID uid
Definition: mxfdec.c:235
mxf_system_item_key_cp
static const uint8_t mxf_system_item_key_cp[]
Definition: mxfdec.c:339
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:342
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:306
MXFContext::parsing_backward
int parsing_backward
Definition: mxfdec.c:316
MXFChannelOrderingUL::channel
enum AVChannel channel
Definition: mxfdec.c:1659
MXFIndexTable::segments
MXFIndexTableSegment ** segments
Definition: mxfdec.c:293
container_ul
const UID container_ul
Definition: mxfenc.c:2334
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:525
MXFIndexTableSegment::meta
MXFMetadataSet meta
Definition: mxfdec.c:252
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:131
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
MXF_FIELD_DOMINANCE_FL
#define MXF_FIELD_DOMINANCE_FL
Definition: mxfdec.c:206
mxf_resolve_source_package
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
Definition: mxfdec.c:2239
MXFTrack::body_sid
int body_sid
Definition: mxfdec.c:188
MXFDescriptor::sub_descriptors_refs
UID * sub_descriptors_refs
Definition: mxfdec.c:219
codec_ul
UID codec_ul
Definition: mxfenc.c:2227
MXFIndexTable::ptses
int64_t * ptses
Definition: mxfdec.c:291
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:573
MXFContext::essence_container_data_refs
UID * essence_container_data_refs
Definition: mxfdec.c:305
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
MXFDescriptor::vert_subsampling
unsigned int vert_subsampling
Definition: mxfdec.c:216
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:202
MXF_FIELD_DOMINANCE_DEFAULT
#define MXF_FIELD_DOMINANCE_DEFAULT
Definition: mxfdec.c:204
MXFSequence::duration
int64_t duration
Definition: mxfdec.c:146
ff_mxf_pixel_format_uls
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition: mxf.c: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:226
mxf_get_color_range
static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
Definition: mxfdec.c:2441
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
mxf_mca_tag_name
static const uint8_t mxf_mca_tag_name[]
Definition: mxfdec.c:359
MXFTrack::wrapping
MXFWrappingScheme wrapping
Definition: mxfdec.c:189
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:76
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:337
EssenceContainerData
@ EssenceContainerData
Definition: mxf.h:48
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: defs.h:225
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:254
MXFEssenceGroup::structural_components_refs
UID * structural_components_refs
Definition: mxfdec.c:165
MXFPackage::tracks_count
int tracks_count
Definition: mxfdec.c:270
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:627
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
MXFTrack::name
char * name
Definition: mxfdec.c:181
MXFDescriptor::pix_fmt
enum AVPixelFormat pix_fmt
Definition: mxfdec.c:224
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
MXFTrack::track_id
int track_id
Definition: mxfdec.c:180
MXFStructuralComponent::source_package_ul
UID source_package_ul
Definition: mxfdec.c:133
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
AV_CHAN_STEREO_LEFT
@ AV_CHAN_STEREO_LEFT
Stereo downmix.
Definition: channel_layout.h:69
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:666
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
SET_VERSION_METADATA
#define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str)
Definition: mxfdec.c:3112
mxf_crypto_source_container_ul
static const uint8_t mxf_crypto_source_container_ul[]
Definition: mxfdec.c:345
MXFMCASubDescriptor::group_of_soundfield_groups_link_id_refs
UID * group_of_soundfield_groups_link_id_refs
Definition: mxfdec.c:238
MXFTrack::sequence
MXFSequence * sequence
Definition: mxfdec.c:178
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
MXFPackage
Definition: mxfdec.c:265
MXFMetadataReadTableEntry::type
enum MXFMetadataSetType type
Definition: mxfdec.c:331
MXFTrack
Definition: mxfdec.c:176
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:103
mxf_compute_index_tables
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
Definition: mxfdec.c:2067
mxf_resolve_timecode_component
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:2223
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:314
tag
uint32_t tag
Definition: movenc.c:1791
MXFTimecodeComponent::start_frame
int start_frame
Definition: mxfdec.c:153
MXFPartition::essence_length
int64_t essence_length
Definition: mxfdec.c:106
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:755
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
KLVPacket
Definition: mxf.h:74
MXFCryptoContext::meta
MXFMetadataSet meta
Definition: mxfdec.c:127
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:230
MXFEssenceContainerData
Definition: mxfdec.c:277
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:150
mxf_intra_only_picture_essence_coding_uls
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
Definition: mxfdec.c:1622
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:745
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:459
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
FrameWrapped
@ FrameWrapped
Definition: mxfdec.c:94
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: avpacket.c:704
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_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:2486
MXFTimecodeComponent::tc
AVTimecode tc
Definition: mxfdec.c:155
KLVPacket::length
uint64_t length
Definition: mxf.h:77
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:313
BodyPartition
@ BodyPartition
Definition: mxfdec.c:74
mxf_metadataset_init
static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
Definition: mxfdec.c:3239
MXFDescriptor::white_ref_level
unsigned int white_ref_level
Definition: mxfdec.c:213
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
MXFContext::fc
AVFormatContext * fc
Definition: mxfdec.c:308
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
OP2a
@ OP2a
Definition: mxfdec.c:82
MXFFFV1SubDescriptor::meta
MXFMetadataSet meta
Definition: mxfdec.c:246
MXFDescriptor::extradata
uint8_t * extradata
Definition: mxfdec.c:222
channel_layout.h
ff_mxf_decode_pixel_layout
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition: mxf.c:177
MXFDescriptor::sample_rate
AVRational sample_rate
Definition: mxfdec.c:198
AV_CHAN_LOW_FREQUENCY_2
@ AV_CHAN_LOW_FREQUENCY_2
Definition: channel_layout.h:76
AV_CHAN_TOP_BACK_LEFT
@ AV_CHAN_TOP_BACK_LEFT
Definition: channel_layout.h:65
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
OP1b
@ OP1b
Definition: mxfdec.c:80
SoundfieldGroupLabelSubDescriptor
@ SoundfieldGroupLabelSubDescriptor
Definition: mxf.h:54
MXFOP
MXFOP
Definition: mxfdec.c:78
MXFDescriptor::extradata_size
int extradata_size
Definition: mxfdec.c:223
FF_MXF_MasteringDisplayMaximumLuminance
#define FF_MXF_MasteringDisplayMaximumLuminance
Definition: mxf.h:99
AVRational::den
int den
Denominator.
Definition: rational.h:60
mxf_resolve_sourceclip
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:2279
MXFTaggedValue::name
char * name
Definition: mxfdec.c:172
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
MXFContext::local_tags
uint8_t * local_tags
Definition: mxfdec.c:310
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:432
MXFSequence::origin
uint8_t origin
Definition: mxfdec.c:147
MXFTaggedValue::meta
MXFMetadataSet meta
Definition: mxfdec.c:171
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:611
mxf_system_item_key_gc
static const uint8_t mxf_system_item_key_gc[]
Definition: mxfdec.c:340
AV_CHAN_BACK_LEFT
@ AV_CHAN_BACK_LEFT
Definition: channel_layout.h:54
MXFFFV1SubDescriptor::extradata
uint8_t * extradata
Definition: mxfdec.c:247
MXFDescriptor::codec_ul
UID codec_ul
Definition: mxfdec.c:197
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
MXFContext::aesc
struct AVAES * aesc
Definition: mxfdec.c:309
mxf_jp2k_rsiz
static const uint8_t mxf_jp2k_rsiz[]
Definition: mxfdec.c:351
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:3254
mxf_essence_element_key
static const uint8_t mxf_essence_element_key[]
Definition: mxfdec.c:336
parse_mca_labels
static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
Definition: mxfdec.c:2512
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:524
segment
Definition: hls.c:76
MXFFFV1SubDescriptor
Definition: mxfdec.c:245
AV_CHAN_BOTTOM_FRONT_CENTER
@ AV_CHAN_BOTTOM_FRONT_CENTER
Definition: channel_layout.h:79
MXFPackage::package_ul
UID package_ul
Definition: mxfdec.c:268
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:317
MXFContext::current_partition
MXFPartition * current_partition
Definition: mxfdec.c:315
MXFTrack::intra_only
int intra_only
Definition: mxfdec.c:184
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
Definition: dict.c:167
demuxer_class
static const AVClass demuxer_class
Definition: mxfdec.c:4264
options
static const AVOption options[]
Definition: mxfdec.c:4257
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:121
tc
#define tc
Definition: regdef.h:69
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:273
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:368
mxf_channel_ordering
static const MXFChannelOrderingUL mxf_channel_ordering[]
Definition: mxfdec.c:1663
OP1c
@ OP1c
Definition: mxfdec.c:81
MXFPackage::descriptor_ref
UID descriptor_ref
Definition: mxfdec.c:271
MXFMetadataSetGroup::metadata_sets
MXFMetadataSet ** metadata_sets
Definition: mxfdec.c:122
MXFSequence::data_definition_ul
UID data_definition_ul
Definition: mxfdec.c:143
mastering_display_metadata.h
KLVPacket::next_klv
int64_t next_klv
Definition: mxf.h:78
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h: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:376
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:3541
mxf_is_st_422
static int mxf_is_st_422(const UID *essence_container_ul)
Definition: mxfdec.c:2173
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
MXFTaggedValue
Definition: mxfdec.c:170
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
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:542
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:259
mxf_read_close
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:4085
MXFEssenceGroup::meta
MXFMetadataSet meta
Definition: mxfdec.c:164
MXFDescriptor::component_depth
unsigned int component_depth
Definition: mxfdec.c:211
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
mxf_get_stream_index
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
Definition: mxfdec.c:481
UnknownWrapped
@ UnknownWrapped
Definition: mxfdec.c:93
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
MXFMetadataReadTableEntry::read
MXFMetadataReadFunc * read
Definition: mxfdec.c:329
MXFPartition::first_essence_klv
KLVPacket first_essence_klv
Definition: mxfdec.c:113
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MXFPulldownComponent::input_segment_ref
UID input_segment_ref
Definition: mxfdec.c:160
ClipWrapped
@ ClipWrapped
Definition: mxfdec.c:95
MXFTimecodeComponent::rate
struct AVRational rate
Definition: mxfdec.c:154
MXFIndexTable::index_sid
int index_sid
Definition: mxfdec.c:287
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:3345
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:240
MXFPartition::previous_partition
uint64_t previous_partition
Definition: mxfdec.c:102
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
D10D11Wrap
@ D10D11Wrap
Definition: mxf.h:83
Sequence
@ Sequence
Definition: mxf.h:38
MXFPulldownComponent::meta
MXFMetadataSet meta
Definition: mxfdec.c:159
AV_CODEC_ID_TIFF
@ AV_CODEC_ID_TIFF
Definition: codec_id.h:148
AV_CHAN_FRONT_LEFT
@ AV_CHAN_FRONT_LEFT
Definition: channel_layout.h:50
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
avstring.h
MXFTaggedValue::value
char * value
Definition: mxfdec.c:173
MXFIndexTable::body_sid
int body_sid
Definition: mxfdec.c:288
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:3130
mxf_sony_mpeg4_extradata
static const uint8_t mxf_sony_mpeg4_extradata[]
Definition: mxfdec.c:348
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:648
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:223
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:338
MXFCodecUL::uid
UID uid
Definition: mxf.h:106
MXFDescriptor::meta
MXFMetadataSet meta
Definition: mxfdec.c:194
AVChannelCustom::id
enum AVChannel id
Definition: channel_layout.h:268
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:1637
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:272
mxf_avid_essence_element_key
static const uint8_t mxf_avid_essence_element_key[]
Definition: mxfdec.c:337
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:200
MXFContext::footer_partition
uint64_t footer_partition
Definition: mxfdec.c:312
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
MXFPartition::body_sid
int body_sid
Definition: mxfdec.c:104
MXFSequence::meta
MXFMetadataSet meta
Definition: mxfdec.c:142
MXFPartition::body_offset
int64_t body_offset
Definition: mxfdec.c:112
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:239
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:345
Generated on Thu Sep 26 2024 23:15:49 for FFmpeg by   doxygen 1.8.17