FFmpeg
mxfdec.c
Go to the documentation of this file.
1 /*
2  * MXF demuxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * References
24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25  * SMPTE 377M MXF File Format Specifications
26  * SMPTE 378M Operational Pattern 1a
27  * SMPTE 379M MXF Generic Container
28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31  * SMPTE 2067-21 Interoperable Master Format — Application #2E
32  *
33  * Principle
34  * Search for Track numbers which will identify essence element KLV packets.
35  * Search for SourcePackage which define tracks which contains Track numbers.
36  * Material Package contains tracks with reference to SourcePackage tracks.
37  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
38  * Assign Descriptors to correct Tracks.
39  *
40  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
41  * Metadata parsing resolves Strong References to objects.
42  *
43  * Simple demuxer, only OP1A supported and some files might not work at all.
44  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
45  */
46 
47 #include <inttypes.h>
48 #include <time.h>
49 
50 #include "libavutil/aes.h"
51 #include "libavutil/avstring.h"
52 #include "libavutil/mastering_display_metadata.h"
53 #include "libavutil/mathematics.h"
54 #include "libavutil/mem.h"
55 #include "libavcodec/bytestream.h"
56 #include "libavcodec/defs.h"
57 #include "libavcodec/internal.h"
58 #include "libavutil/channel_layout.h"
59 #include "libavutil/dict_internal.h"
60 #include "libavutil/intreadwrite.h"
61 #include "libavutil/parseutils.h"
62 #include "libavutil/timecode.h"
63 #include "libavutil/opt.h"
64 #include "avformat.h"
65 #include "avlanguage.h"
66 #include "demux.h"
67 #include "internal.h"
68 #include "mxf.h"
69 
70 #define MXF_MAX_CHUNK_SIZE (32 << 20)
71 #define RUN_IN_MAX (65535+1) // S377m-2004 section 5.5 and S377-1-2009 section 6.5, the +1 is to be slightly more tolerant
72 
73 typedef enum {
74  Header,
75  BodyPartition,
76  Footer
77 } MXFPartitionType;
78 
79 typedef enum {
80  OP1a = 1,
81  OP1b,
82  OP1c,
83  OP2a,
84  OP2b,
85  OP2c,
86  OP3a,
87  OP3b,
88  OP3c,
89  OPAtom,
90  OPSONYOpt, /* FATE sample, violates the spec in places */
91 } MXFOP;
92 
93 typedef enum {
94  UnknownWrapped = 0,
95  FrameWrapped,
96  ClipWrapped,
97 } MXFWrappingScheme;
98 
99 typedef struct MXFPartition {
100  int closed;
101  int complete;
102  MXFPartitionType type;
103  uint64_t previous_partition;
104  int index_sid;
105  int body_sid;
106  int64_t essence_offset; ///< absolute offset of essence
107  int64_t essence_length;
108  int32_t kag_size;
109  int64_t header_byte_count;
110  int64_t index_byte_count;
111  int pack_length;
112  int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
113  int64_t body_offset;
114  KLVPacket first_essence_klv;
115 } MXFPartition;
116 
117 typedef struct MXFMetadataSet {
118  UID uid;
119  uint64_t partition_score;
120 } MXFMetadataSet;
121 
122 typedef struct MXFMetadataSetGroup {
123  MXFMetadataSet **metadata_sets;
124  int metadata_sets_count;
125 } MXFMetadataSetGroup;
126 
127 typedef struct MXFCryptoContext {
128  MXFMetadataSet meta;
129  UID source_container_ul;
130 } MXFCryptoContext;
131 
132 typedef struct MXFStructuralComponent {
133  MXFMetadataSet meta;
134  UID source_package_ul;
135  UID source_package_uid;
136  UID data_definition_ul;
137  int64_t duration;
138  int64_t start_position;
139  int source_track_id;
140 } MXFStructuralComponent;
141 
142 typedef struct MXFSequence {
143  MXFMetadataSet meta;
144  UID data_definition_ul;
145  UID *structural_components_refs;
146  int structural_components_count;
147  int64_t duration;
148  uint8_t origin;
149 } MXFSequence;
150 
151 typedef struct MXFTimecodeComponent {
152  MXFMetadataSet meta;
153  int drop_frame;
154  int start_frame;
155  struct AVRational rate;
156  AVTimecode tc;
157 } MXFTimecodeComponent;
158 
159 typedef struct {
160  MXFMetadataSet meta;
161  UID input_segment_ref;
162 } MXFPulldownComponent;
163 
164 typedef struct {
165  MXFMetadataSet meta;
166  UID *structural_components_refs;
167  int structural_components_count;
168  int64_t duration;
169 } MXFEssenceGroup;
170 
171 typedef struct {
172  MXFMetadataSet meta;
173  char *name;
174  char *value;
175 } MXFTaggedValue;
176 
177 typedef struct {
178  MXFMetadataSet meta;
179  MXFSequence *sequence; /* mandatory, and only one */
180  UID sequence_ref;
181  int track_id;
182  char *name;
183  uint8_t track_number[4];
184  AVRational edit_rate;
185  int intra_only;
186  uint64_t sample_count;
187  int64_t original_duration; /* st->duration in SampleRate/EditRate units */
188  int index_sid;
189  int body_sid;
190  MXFWrappingScheme wrapping;
191  int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
192 } MXFTrack;
193 
194 typedef struct MXFDescriptor {
195  MXFMetadataSet meta;
196  UID essence_container_ul;
197  UID essence_codec_ul;
198  UID codec_ul;
199  AVRational sample_rate;
200  AVRational aspect_ratio;
201  int width;
202  int height; /* Field height, not frame height */
203  int frame_layout; /* See MXFFrameLayout enum */
204  int video_line_map[2];
205 #define MXF_FIELD_DOMINANCE_DEFAULT 0
206 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
207 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
208  int field_dominance;
209  int channels;
210  int bits_per_sample;
211  int64_t duration; /* ContainerDuration optional property */
212  unsigned int component_depth;
213  unsigned int black_ref_level;
214  unsigned int white_ref_level;
215  unsigned int color_range;
216  unsigned int horiz_subsampling;
217  unsigned int vert_subsampling;
218  UID *file_descriptors_refs;
219  int file_descriptors_count;
220  UID *sub_descriptors_refs;
221  int sub_descriptors_count;
222  int linked_track_id;
223  uint8_t *extradata;
224  int extradata_size;
225  enum AVPixelFormat pix_fmt;
226  UID color_primaries_ul;
227  UID color_trc_ul;
228  UID color_space_ul;
229  AVMasteringDisplayMetadata *mastering;
230  AVContentLightMetadata *coll;
231  size_t coll_size;
232 } MXFDescriptor;
233 
234 typedef struct MXFMCASubDescriptor {
235  MXFMetadataSet meta;
236  UID uid;
237  UID mca_link_id;
238  UID soundfield_group_link_id;
239  UID *group_of_soundfield_groups_link_id_refs;
240  int group_of_soundfield_groups_link_id_count;
241  UID mca_label_dictionary_id;
242  int mca_channel_id;
243  char *language;
244 } MXFMCASubDescriptor;
245 
246 typedef struct MXFFFV1SubDescriptor {
247  MXFMetadataSet meta;
248  uint8_t *extradata;
249  int extradata_size;
250 } MXFFFV1SubDescriptor;
251 
252 typedef struct MXFIndexTableSegment {
253  MXFMetadataSet meta;
254  unsigned edit_unit_byte_count;
255  int index_sid;
256  int body_sid;
257  AVRational index_edit_rate;
258  uint64_t index_start_position;
259  uint64_t index_duration;
260  int8_t *temporal_offset_entries;
261  int *flag_entries;
262  uint64_t *stream_offset_entries;
263  int nb_index_entries;
264 } MXFIndexTableSegment;
265 
266 typedef struct MXFPackage {
267  MXFMetadataSet meta;
268  UID package_uid;
269  UID package_ul;
270  UID *tracks_refs;
271  int tracks_count;
272  UID descriptor_ref;
273  char *name;
274  UID *comment_refs;
275  int comment_count;
276 } MXFPackage;
277 
278 typedef struct MXFEssenceContainerData {
279  MXFMetadataSet meta;
280  UID package_uid;
281  UID package_ul;
282  int index_sid;
283  int body_sid;
284 } MXFEssenceContainerData;
285 
286 /* decoded index table */
287 typedef struct MXFIndexTable {
288  int index_sid;
289  int body_sid;
290  int nb_ptses; /* number of PTSes or total duration of index */
291  int64_t first_dts; /* DTS = EditUnit + first_dts */
292  int64_t *ptses; /* maps EditUnit -> PTS */
293  int nb_segments;
294  MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
295  AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
296  int8_t *offsets; /* temporal offsets for display order to stored order conversion */
297 } MXFIndexTable;
298 
299 typedef struct MXFContext {
300  const AVClass *class; /**< Class for private options. */
301  MXFPartition *partitions;
302  unsigned partitions_count;
303  MXFOP op;
304  UID *packages_refs;
305  int packages_count;
306  UID *essence_container_data_refs;
307  int essence_container_data_count;
308  MXFMetadataSetGroup metadata_set_groups[MetadataSetTypeNB];
309  AVFormatContext *fc;
310  struct AVAES *aesc;
311  uint8_t *local_tags;
312  int local_tags_count;
313  uint64_t footer_partition;
314  KLVPacket current_klv_data;
315  int run_in;
316  MXFPartition *current_partition;
317  int parsing_backward;
318  int64_t last_forward_tell;
319  int last_forward_partition;
320  int nb_index_tables;
321  MXFIndexTable *index_tables;
322  int eia608_extract;
323 } MXFContext;
324 
325 /* NOTE: klv_offset is not set (-1) for local keys */
326 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
327 
328 typedef struct MXFMetadataReadTableEntry {
329  const UID key;
330  MXFMetadataReadFunc *read;
331  int ctx_size;
332  enum MXFMetadataSetType type;
333 } MXFMetadataReadTableEntry;
334 
335 /* partial keys to match */
336 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
337 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
338 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
339 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
340 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
341 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
342 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
343 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
344 
345 /* complete keys to match */
346 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 };
347 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
348 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
349 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
350 static const uint8_t mxf_ffv1_extradata[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x04,0x01,0x06,0x0c,0x01,0x00,0x00,0x00 }; // FFV1InitializationMetadata
351 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
352 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00 };
353 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 };
354 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 };
355 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 };
356 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 };
357 
358 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 };
359 static const uint8_t mxf_mca_tag_symbol[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x02,0x00,0x00,0x00 };
360 static const uint8_t mxf_mca_tag_name[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x03,0x00,0x00,0x00 };
361 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 };
362 static const uint8_t mxf_mca_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x05,0x00,0x00,0x00 };
363 static const uint8_t mxf_mca_channel_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x04,0x0a,0x00,0x00,0x00,0x00 };
364 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 };
365 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 };
366 
367 static const uint8_t mxf_sub_descriptor[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00 };
368 
369 static const uint8_t mxf_mastering_display_prefix[13] = { FF_MXF_MasteringDisplay_PREFIX };
370 static const uint8_t mxf_mastering_display_uls[4][16] = {
371  FF_MXF_MasteringDisplayPrimaries,
372  FF_MXF_MasteringDisplayWhitePointChromaticity,
373  FF_MXF_MasteringDisplayMaximumLuminance,
374  FF_MXF_MasteringDisplayMinimumLuminance,
375 };
376 
377 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
378 
379 static void mxf_free_metadataset(MXFMetadataSet **ctx, enum MXFMetadataSetType type)
380 {
381  MXFIndexTableSegment *seg;
382  switch (type) {
383  case Descriptor:
384  case MultipleDescriptor:
385  av_freep(&((MXFDescriptor *)*ctx)->extradata);
386  av_freep(&((MXFDescriptor *)*ctx)->mastering);
387  av_freep(&((MXFDescriptor *)*ctx)->coll);
388  av_freep(&((MXFDescriptor *)*ctx)->file_descriptors_refs);
389  av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
390  break;
391  case FFV1SubDescriptor:
392  av_freep(&((MXFFFV1SubDescriptor *)*ctx)->extradata);
393  break;
394  case AudioChannelLabelSubDescriptor:
395  case SoundfieldGroupLabelSubDescriptor:
396  case GroupOfSoundfieldGroupsLabelSubDescriptor:
397  av_freep(&((MXFMCASubDescriptor *)*ctx)->language);
398  av_freep(&((MXFMCASubDescriptor *)*ctx)->group_of_soundfield_groups_link_id_refs);
399  break;
400  case Sequence:
401  av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
402  break;
403  case EssenceGroup:
404  av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
405  break;
406  case SourcePackage:
407  case MaterialPackage:
408  av_freep(&((MXFPackage *)*ctx)->tracks_refs);
409  av_freep(&((MXFPackage *)*ctx)->name);
410  av_freep(&((MXFPackage *)*ctx)->comment_refs);
411  break;
412  case TaggedValue:
413  av_freep(&((MXFTaggedValue *)*ctx)->name);
414  av_freep(&((MXFTaggedValue *)*ctx)->value);
415  break;
416  case Track:
417  av_freep(&((MXFTrack *)*ctx)->name);
418  break;
419  case IndexTableSegment:
420  seg = (MXFIndexTableSegment *)*ctx;
421  av_freep(&seg->temporal_offset_entries);
422  av_freep(&seg->flag_entries);
423  av_freep(&seg->stream_offset_entries);
424  default:
425  break;
426  }
427  av_freep(ctx);
428 }
429 
430 static int64_t klv_decode_ber_length(AVIOContext *pb)
431 {
432  uint64_t size = avio_r8(pb);
433  if (size & 0x80) { /* long form */
434  int bytes_num = size & 0x7f;
435  /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
436  if (bytes_num > 8)
437  return AVERROR_INVALIDDATA;
438  size = 0;
439  while (bytes_num--)
440  size = size << 8 | avio_r8(pb);
441  }
442  if (size > INT64_MAX)
443  return AVERROR_INVALIDDATA;
444  return size;
445 }
446 
447 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
448 {
449  int i, b;
450  for (i = 0; i < size && !avio_feof(pb); i++) {
451  b = avio_r8(pb);
452  if (b == key[0])
453  i = 0;
454  else if (b != key[i])
455  i = -1;
456  }
457  return i == size;
458 }
459 
460 static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
461 {
462  int64_t length, pos;
463  if (!mxf_read_sync(pb, mxf_klv_key, 4))
464  return AVERROR_INVALIDDATA;
465  klv->offset = avio_tell(pb) - 4;
466  if (klv->offset < mxf->run_in)
467  return AVERROR_INVALIDDATA;
468 
469  memcpy(klv->key, mxf_klv_key, 4);
470  avio_read(pb, klv->key + 4, 12);
471  length = klv_decode_ber_length(pb);
472  if (length < 0)
473  return length;
474  klv->length = length;
475  pos = avio_tell(pb);
476  if (pos > INT64_MAX - length)
477  return AVERROR_INVALIDDATA;
478  klv->next_klv = pos + length;
479  return 0;
480 }
481 
482 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
483 {
484  int i;
485 
486  for (i = 0; i < s->nb_streams; i++) {
487  MXFTrack *track = s->streams[i]->priv_data;
488  /* SMPTE 379M 7.3 */
489  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)))
490  return i;
491  }
492  /* return 0 if only one stream, for OP Atom files with 0 as track number */
493  return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
494 }
495 
496 static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
497 {
498  // we look for partition where the offset is placed
499  int a, b, m;
500  int64_t pack_ofs;
501 
502  a = -1;
503  b = mxf->partitions_count;
504 
505  while (b - a > 1) {
506  m = (a + b) >> 1;
507  pack_ofs = mxf->partitions[m].pack_ofs;
508  if (pack_ofs <= offset)
509  a = m;
510  else
511  b = m;
512  }
513 
514  if (a == -1)
515  return 0;
516  return mxf->partitions[a].body_sid;
517 }
518 
519 static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
520 {
521  int count = avio_rb16(s->pb);
522  int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
523  int line_num, sample_coding, sample_count;
524  int did, sdid, data_length;
525  int i, ret;
526 
527  if (count > 1)
528  av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
529 
530  for (i = 0; i < count; i++) {
531  if (length < 6) {
532  av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
533  return AVERROR_INVALIDDATA;
534  }
535  line_num = avio_rb16(s->pb);
536  avio_r8(s->pb); // wrapping type
537  sample_coding = avio_r8(s->pb);
538  sample_count = avio_rb16(s->pb);
539  length -= 6 + 8 + sample_count;
540  if (line_num != 9 && line_num != 11)
541  continue;
542  if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
543  av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
544  continue;
545  }
546  if (length < 0)
547  return AVERROR_INVALIDDATA;
548 
549  avio_rb32(s->pb); // array count
550  avio_rb32(s->pb); // array elem size
551  did = avio_r8(s->pb);
552  sdid = avio_r8(s->pb);
553  data_length = avio_r8(s->pb);
554  if (did != 0x61 || sdid != 1) {
555  av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
556  continue;
557  }
558  cdp_identifier = avio_rb16(s->pb); // cdp id
559  if (cdp_identifier != 0x9669) {
560  av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
561  return AVERROR_INVALIDDATA;
562  }
563  cdp_length = avio_r8(s->pb);
564  avio_r8(s->pb); // cdp_frame_rate
565  avio_r8(s->pb); // cdp_flags
566  avio_rb16(s->pb); // cdp_hdr_sequence_cntr
567  ccdata_id = avio_r8(s->pb); // ccdata_id
568  if (ccdata_id != 0x72) {
569  av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
570  return AVERROR_INVALIDDATA;
571  }
572  cc_count = avio_r8(s->pb) & 0x1f;
573  ret = av_get_packet(s->pb, pkt, cc_count * 3);
574  if (ret < 0)
575  return ret;
576  if (cdp_length - 9 - 4 < cc_count * 3) {
577  av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
578  return AVERROR_INVALIDDATA;
579  }
580  avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
581  cdp_footer_id = avio_r8(s->pb);
582  if (cdp_footer_id != 0x74) {
583  av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
584  return AVERROR_INVALIDDATA;
585  }
586  avio_rb16(s->pb); // cdp_ftr_sequence_cntr
587  avio_r8(s->pb); // packet_checksum
588  break;
589  }
590 
591  return 0;
592 }
593 
594 /* XXX: use AVBitStreamFilter */
595 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
596 {
597  const uint8_t *buf_ptr, *end_ptr;
598  uint8_t *data_ptr;
599  int i;
600 
601  if (length > 61444) /* worst case PAL 1920 samples 8 channels */
602  return AVERROR_INVALIDDATA;
603  length = av_get_packet(pb, pkt, length);
604  if (length < 0)
605  return length;
606  data_ptr = pkt->data;
607  end_ptr = pkt->data + length;
608  buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
609 
610  if (st->codecpar->ch_layout.nb_channels > 8)
611  return AVERROR_INVALIDDATA;
612 
613  for (; end_ptr - buf_ptr >= st->codecpar->ch_layout.nb_channels * 4; ) {
614  for (i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {
615  uint32_t sample = bytestream_get_le32(&buf_ptr);
616  if (st->codecpar->bits_per_coded_sample == 24)
617  bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
618  else
619  bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
620  }
621  // always 8 channels stored SMPTE 331M
622  buf_ptr += 32 - st->codecpar->ch_layout.nb_channels * 4;
623  }
624  av_shrink_packet(pkt, data_ptr - pkt->data);
625  return 0;
626 }
627 
628 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
629 {
630  static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
631  MXFContext *mxf = s->priv_data;
632  AVIOContext *pb = s->pb;
633  int64_t end = avio_tell(pb) + klv->length;
634  int64_t size;
635  uint64_t orig_size;
636  uint64_t plaintext_size;
637  uint8_t ivec[16];
638  uint8_t tmpbuf[16];
639  int index;
640  int body_sid;
641 
642  if (!mxf->aesc && s->key && s->keylen == 16) {
643  mxf->aesc = av_aes_alloc();
644  if (!mxf->aesc)
645  return AVERROR(ENOMEM);
646  av_aes_init(mxf->aesc, s->key, 128, 1);
647  }
648  // crypto context
649  size = klv_decode_ber_length(pb);
650  if (size < 0)
651  return size;
652  avio_skip(pb, size);
653  // plaintext offset
654  klv_decode_ber_length(pb);
655  plaintext_size = avio_rb64(pb);
656  // source klv key
657  klv_decode_ber_length(pb);
658  avio_read(pb, klv->key, 16);
659  if (!IS_KLV_KEY(klv, mxf_essence_element_key))
660  return AVERROR_INVALIDDATA;
661 
662  body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
663  index = mxf_get_stream_index(s, klv, body_sid);
664  if (index < 0)
665  return AVERROR_INVALIDDATA;
666  // source size
667  klv_decode_ber_length(pb);
668  orig_size = avio_rb64(pb);
669  if (orig_size < plaintext_size)
670  return AVERROR_INVALIDDATA;
671  // enc. code
672  size = klv_decode_ber_length(pb);
673  if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)
674  return AVERROR_INVALIDDATA;
675  avio_read(pb, ivec, 16);
676  avio_read(pb, tmpbuf, 16);
677  if (mxf->aesc)
678  av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
679  if (memcmp(tmpbuf, checkv, 16))
680  av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
681  size -= 32;
682  size = av_get_packet(pb, pkt, size);
683  if (size < 0)
684  return size;
685  else if (size < plaintext_size)
686  return AVERROR_INVALIDDATA;
687  size -= plaintext_size;
688  if (mxf->aesc)
689  av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
690  &pkt->data[plaintext_size], size >> 4, ivec, 1);
691  av_shrink_packet(pkt, orig_size);
692  pkt->stream_index = index;
693  avio_skip(pb, end - avio_tell(pb));
694  return 0;
695 }
696 
697 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
698 {
699  MXFContext *mxf = arg;
700  int item_num = avio_rb32(pb);
701  int item_len = avio_rb32(pb);
702 
703  if (item_len != 18) {
704  avpriv_request_sample(pb, "Primer pack item length %d", item_len);
705  return AVERROR_PATCHWELCOME;
706  }
707  if (item_num > 65536 || item_num < 0) {
708  av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
709  return AVERROR_INVALIDDATA;
710  }
711  if (mxf->local_tags)
712  av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
713  av_free(mxf->local_tags);
714  mxf->local_tags_count = 0;
715  mxf->local_tags = av_calloc(item_num, item_len);
716  if (!mxf->local_tags)
717  return AVERROR(ENOMEM);
718  mxf->local_tags_count = item_num;
719  avio_read(pb, mxf->local_tags, item_num*item_len);
720  return 0;
721 }
722 
723 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
724 {
725  MXFContext *mxf = arg;
726  AVFormatContext *s = mxf->fc;
727  MXFPartition *partition, *tmp_part;
728  UID op;
729  uint64_t footer_partition;
730  uint32_t nb_essence_containers;
731  uint64_t this_partition;
732 
733  if (mxf->partitions_count >= INT_MAX / 2)
734  return AVERROR_INVALIDDATA;
735 
736  av_assert0(klv_offset >= mxf->run_in);
737 
738  tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
739  if (!tmp_part)
740  return AVERROR(ENOMEM);
741  mxf->partitions = tmp_part;
742 
743  if (mxf->parsing_backward) {
744  /* insert the new partition pack in the middle
745  * this makes the entries in mxf->partitions sorted by offset */
746  memmove(&mxf->partitions[mxf->last_forward_partition+1],
747  &mxf->partitions[mxf->last_forward_partition],
748  (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
749  partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
750  } else {
751  mxf->last_forward_partition++;
752  partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
753  }
754 
755  memset(partition, 0, sizeof(*partition));
756  mxf->partitions_count++;
757  partition->pack_length = avio_tell(pb) - klv_offset + size;
758  partition->pack_ofs = klv_offset;
759 
760  switch(uid[13]) {
761  case 2:
762  partition->type = Header;
763  break;
764  case 3:
765  partition->type = BodyPartition;
766  break;
767  case 4:
768  partition->type = Footer;
769  break;
770  default:
771  av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
772  return AVERROR_INVALIDDATA;
773  }
774 
775  /* consider both footers to be closed (there is only Footer and CompleteFooter) */
776  partition->closed = partition->type == Footer || !(uid[14] & 1);
777  partition->complete = uid[14] > 2;
778  avio_skip(pb, 4);
779  partition->kag_size = avio_rb32(pb);
780  this_partition = avio_rb64(pb);
781  if (this_partition != klv_offset - mxf->run_in) {
782  av_log(mxf->fc, AV_LOG_ERROR,
783  "this_partition %"PRId64" mismatches %"PRId64"\n",
784  this_partition, klv_offset - mxf->run_in);
785  return AVERROR_INVALIDDATA;
786  }
787  partition->previous_partition = avio_rb64(pb);
788  footer_partition = avio_rb64(pb);
789  partition->header_byte_count = avio_rb64(pb);
790  partition->index_byte_count = avio_rb64(pb);
791  partition->index_sid = avio_rb32(pb);
792  partition->body_offset = avio_rb64(pb);
793  partition->body_sid = avio_rb32(pb);
794  if (partition->body_offset < 0)
795  return AVERROR_INVALIDDATA;
796 
797  if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
798  av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
799  return AVERROR_INVALIDDATA;
800  }
801  nb_essence_containers = avio_rb32(pb);
802 
803  if (partition->type == Header) {
804  char str[36];
805  snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));
806  av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);
807  }
808 
809  if (this_partition &&
810  partition->previous_partition == this_partition) {
811  av_log(mxf->fc, AV_LOG_ERROR,
812  "PreviousPartition equal to ThisPartition %"PRIx64"\n",
813  partition->previous_partition);
814  /* override with the actual previous partition offset */
815  if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
816  MXFPartition *prev =
817  mxf->partitions + mxf->last_forward_partition - 2;
818  partition->previous_partition = prev->pack_ofs - mxf->run_in;
819  }
820  /* if no previous body partition are found point to the header
821  * partition */
822  if (partition->previous_partition == this_partition)
823  partition->previous_partition = 0;
824  av_log(mxf->fc, AV_LOG_ERROR,
825  "Overriding PreviousPartition with %"PRIx64"\n",
826  partition->previous_partition);
827  }
828 
829  /* some files don't have FooterPartition set in every partition */
830  if (footer_partition) {
831  if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
832  av_log(mxf->fc, AV_LOG_ERROR,
833  "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
834  mxf->footer_partition, footer_partition);
835  } else {
836  mxf->footer_partition = footer_partition;
837  }
838  }
839 
840  av_log(mxf->fc, AV_LOG_TRACE,
841  "PartitionPack: ThisPartition = 0x%"PRIX64
842  ", PreviousPartition = 0x%"PRIX64", "
843  "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
844  this_partition,
845  partition->previous_partition, footer_partition,
846  partition->index_sid, partition->body_sid);
847 
848  /* sanity check PreviousPartition if set */
849  //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
850  if (partition->previous_partition &&
851  mxf->run_in + partition->previous_partition >= klv_offset) {
852  av_log(mxf->fc, AV_LOG_ERROR,
853  "PreviousPartition points to this partition or forward\n");
854  return AVERROR_INVALIDDATA;
855  }
856 
857  if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
858  else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
859  else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
860  else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
861  else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
862  else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
863  else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
864  else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
865  else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
866  else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
867  else if (op[12] == 0x10) {
868  /* SMPTE 390m: "There shall be exactly one essence container"
869  * The following block deals with files that violate this, namely:
870  * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
871  * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
872  if (nb_essence_containers != 1) {
873  MXFOP op = nb_essence_containers ? OP1a : OPAtom;
874 
875  /* only nag once */
876  if (!mxf->op)
877  av_log(mxf->fc, AV_LOG_WARNING,
878  "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
879  nb_essence_containers,
880  op == OP1a ? "OP1a" : "OPAtom");
881 
882  mxf->op = op;
883  } else
884  mxf->op = OPAtom;
885  } else {
886  av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
887  mxf->op = OP1a;
888  }
889 
890  if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
891  av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
892  partition->kag_size);
893 
894  if (mxf->op == OPSONYOpt)
895  partition->kag_size = 512;
896  else
897  partition->kag_size = 1;
898 
899  av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
900  }
901 
902  return 0;
903 }
904 
905 static uint64_t partition_score(MXFPartition *p)
906 {
907  uint64_t score;
908  if (!p)
909  return 0;
910  if (p->type == Footer)
911  score = 5;
912  else if (p->complete)
913  score = 4;
914  else if (p->closed)
915  score = 3;
916  else
917  score = 1;
918  return (score << 60) | ((uint64_t)p->pack_ofs >> 4);
919 }
920 
921 static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set, enum MXFMetadataSetType type)
922 {
923  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
924  int ret;
925 
926  // Index Table is special because it might be added manually without
927  // partition and we iterate thorugh all instances of them. Also some files
928  // use the same Instance UID for different index tables...
929  if (type != IndexTableSegment) {
930  for (int i = 0; i < mg->metadata_sets_count; i++) {
931  if (!memcmp((*metadata_set)->uid, mg->metadata_sets[i]->uid, 16)) {
932  uint64_t old_s = mg->metadata_sets[i]->partition_score;
933  uint64_t new_s = (*metadata_set)->partition_score;
934  if (old_s > new_s) {
935  mxf_free_metadataset(metadata_set, type);
936  return 0;
937  }
938  }
939  }
940  }
941 
942  ret = av_dynarray_add_nofree(&mg->metadata_sets, &mg->metadata_sets_count, *metadata_set);
943  if (ret < 0) {
944  mxf_free_metadataset(metadata_set, type);
945  return ret;
946  }
947  return 0;
948 }
949 
950 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
951 {
952  MXFCryptoContext *cryptocontext = arg;
953  if (size != 16)
954  return AVERROR_INVALIDDATA;
955  if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
956  avio_read(pb, cryptocontext->source_container_ul, 16);
957  return 0;
958 }
959 
960 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
961 {
962  int64_t ret;
963  unsigned c = avio_rb32(pb);
964 
965  //avio_read() used int
966  if (c > INT_MAX / sizeof(UID))
967  return AVERROR_PATCHWELCOME;
968  *count = c;
969 
970  av_free(*refs);
971  *refs = av_malloc_array(*count, sizeof(UID));
972  if (!*refs) {
973  *count = 0;
974  return AVERROR(ENOMEM);
975  }
976  avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
977  ret = avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
978  if (ret != *count * sizeof(UID)) {
979  *count = ret < 0 ? 0 : ret / sizeof(UID);
980  return ret < 0 ? ret : AVERROR_INVALIDDATA;
981  }
982 
983  return 0;
984 }
985 
986 static inline int mxf_read_us_ascii_string(AVIOContext *pb, int size, char** str)
987 {
988  int ret;
989  size_t buf_size;
990 
991  if (size < 0 || size > INT_MAX - 1)
992  return AVERROR(EINVAL);
993 
994  buf_size = size + 1;
995  av_free(*str);
996  *str = av_malloc(buf_size);
997  if (!*str)
998  return AVERROR(ENOMEM);
999 
1000  ret = avio_get_str(pb, size, *str, buf_size);
1001 
1002  if (ret < 0) {
1003  av_freep(str);
1004  return ret;
1005  }
1006 
1007  return ret;
1008 }
1009 
1010 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
1011 {
1012  int ret;
1013  size_t buf_size;
1014 
1015  if (size < 0 || size > INT_MAX/2)
1016  return AVERROR(EINVAL);
1017 
1018  buf_size = size + size / 2 + 1;
1019  av_free(*str);
1020  *str = av_malloc(buf_size);
1021  if (!*str)
1022  return AVERROR(ENOMEM);
1023 
1024  if (be)
1025  ret = avio_get_str16be(pb, size, *str, buf_size);
1026  else
1027  ret = avio_get_str16le(pb, size, *str, buf_size);
1028 
1029  if (ret < 0) {
1030  av_freep(str);
1031  return ret;
1032  }
1033 
1034  return ret;
1035 }
1036 
1037 #define READ_STR16(type, big_endian) \
1038 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
1039 { \
1040 return mxf_read_utf16_string(pb, size, str, big_endian); \
1041 }
1042 READ_STR16(be, 1)
1043 READ_STR16(le, 0)
1044 #undef READ_STR16
1045 
1046 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1047 {
1048  MXFContext *mxf = arg;
1049  switch (tag) {
1050  case 0x1901:
1051  if (mxf->packages_refs)
1052  av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
1053  return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
1054  case 0x1902:
1055  return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
1056  }
1057  return 0;
1058 }
1059 
1060 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1061 {
1062  MXFStructuralComponent *source_clip = arg;
1063  switch(tag) {
1064  case 0x0202:
1065  source_clip->duration = avio_rb64(pb);
1066  break;
1067  case 0x1201:
1068  source_clip->start_position = avio_rb64(pb);
1069  break;
1070  case 0x1101:
1071  /* UMID, only get last 16 bytes */
1072  avio_read(pb, source_clip->source_package_ul, 16);
1073  avio_read(pb, source_clip->source_package_uid, 16);
1074  break;
1075  case 0x1102:
1076  source_clip->source_track_id = avio_rb32(pb);
1077  break;
1078  }
1079  return 0;
1080 }
1081 
1082 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1083 {
1084  MXFTimecodeComponent *mxf_timecode = arg;
1085  switch(tag) {
1086  case 0x1501:
1087  mxf_timecode->start_frame = avio_rb64(pb);
1088  break;
1089  case 0x1502:
1090  mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
1091  break;
1092  case 0x1503:
1093  mxf_timecode->drop_frame = avio_r8(pb);
1094  break;
1095  }
1096  return 0;
1097 }
1098 
1099 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1100 {
1101  MXFPulldownComponent *mxf_pulldown = arg;
1102  switch(tag) {
1103  case 0x0d01:
1104  avio_read(pb, mxf_pulldown->input_segment_ref, 16);
1105  break;
1106  }
1107  return 0;
1108 }
1109 
1110 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1111 {
1112  MXFTrack *track = arg;
1113  switch(tag) {
1114  case 0x4801:
1115  track->track_id = avio_rb32(pb);
1116  break;
1117  case 0x4804:
1118  avio_read(pb, track->track_number, 4);
1119  break;
1120  case 0x4802:
1121  mxf_read_utf16be_string(pb, size, &track->name);
1122  break;
1123  case 0x4b01:
1124  track->edit_rate.num = avio_rb32(pb);
1125  track->edit_rate.den = avio_rb32(pb);
1126  break;
1127  case 0x4803:
1128  avio_read(pb, track->sequence_ref, 16);
1129  break;
1130  }
1131  return 0;
1132 }
1133 
1134 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1135 {
1136  MXFSequence *sequence = arg;
1137  switch(tag) {
1138  case 0x0202:
1139  sequence->duration = avio_rb64(pb);
1140  break;
1141  case 0x0201:
1142  avio_read(pb, sequence->data_definition_ul, 16);
1143  break;
1144  case 0x4b02:
1145  sequence->origin = avio_r8(pb);
1146  break;
1147  case 0x1001:
1148  return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
1149  &sequence->structural_components_count);
1150  }
1151  return 0;
1152 }
1153 
1154 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1155 {
1156  MXFEssenceGroup *essence_group = arg;
1157  switch (tag) {
1158  case 0x0202:
1159  essence_group->duration = avio_rb64(pb);
1160  break;
1161  case 0x0501:
1162  return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
1163  &essence_group->structural_components_count);
1164  }
1165  return 0;
1166 }
1167 
1168 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1169 {
1170  MXFPackage *package = arg;
1171  switch(tag) {
1172  case 0x4403:
1173  return mxf_read_strong_ref_array(pb, &package->tracks_refs,
1174  &package->tracks_count);
1175  case 0x4401:
1176  /* UMID */
1177  avio_read(pb, package->package_ul, 16);
1178  avio_read(pb, package->package_uid, 16);
1179  break;
1180  case 0x4701:
1181  avio_read(pb, package->descriptor_ref, 16);
1182  break;
1183  case 0x4402:
1184  return mxf_read_utf16be_string(pb, size, &package->name);
1185  case 0x4406:
1186  return mxf_read_strong_ref_array(pb, &package->comment_refs,
1187  &package->comment_count);
1188  }
1189  return 0;
1190 }
1191 
1192 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1193 {
1194  MXFEssenceContainerData *essence_data = arg;
1195  switch(tag) {
1196  case 0x2701:
1197  /* linked package umid UMID */
1198  avio_read(pb, essence_data->package_ul, 16);
1199  avio_read(pb, essence_data->package_uid, 16);
1200  break;
1201  case 0x3f06:
1202  essence_data->index_sid = avio_rb32(pb);
1203  break;
1204  case 0x3f07:
1205  essence_data->body_sid = avio_rb32(pb);
1206  break;
1207  }
1208  return 0;
1209 }
1210 
1211 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
1212 {
1213  int i, length;
1214  uint32_t nb_index_entries;
1215 
1216  if (segment->temporal_offset_entries)
1217  return AVERROR_INVALIDDATA;
1218 
1219  nb_index_entries = avio_rb32(pb);
1220  if (nb_index_entries > INT_MAX)
1221  return AVERROR_INVALIDDATA;
1222  segment->nb_index_entries = nb_index_entries;
1223 
1224  length = avio_rb32(pb);
1225  if(segment->nb_index_entries && length < 11)
1226  return AVERROR_INVALIDDATA;
1227 
1228  if (!FF_ALLOC_TYPED_ARRAY(segment->temporal_offset_entries, segment->nb_index_entries) ||
1229  !FF_ALLOC_TYPED_ARRAY(segment->flag_entries , segment->nb_index_entries) ||
1230  !FF_ALLOC_TYPED_ARRAY(segment->stream_offset_entries , segment->nb_index_entries)) {
1231  av_freep(&segment->temporal_offset_entries);
1232  av_freep(&segment->flag_entries);
1233  return AVERROR(ENOMEM);
1234  }
1235 
1236  for (i = 0; i < segment->nb_index_entries; i++) {
1237  if(avio_feof(pb))
1238  return AVERROR_INVALIDDATA;
1239  segment->temporal_offset_entries[i] = avio_r8(pb);
1240  avio_r8(pb); /* KeyFrameOffset */
1241  segment->flag_entries[i] = avio_r8(pb);
1242  segment->stream_offset_entries[i] = avio_rb64(pb);
1243  avio_skip(pb, length - 11);
1244  }
1245  return 0;
1246 }
1247 
1248 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1249 {
1250  MXFIndexTableSegment *segment = arg;
1251  switch(tag) {
1252  case 0x3F05:
1253  segment->edit_unit_byte_count = avio_rb32(pb);
1254  av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1255  break;
1256  case 0x3F06:
1257  segment->index_sid = avio_rb32(pb);
1258  av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1259  break;
1260  case 0x3F07:
1261  segment->body_sid = avio_rb32(pb);
1262  av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1263  break;
1264  case 0x3F0A:
1265  av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1266  return mxf_read_index_entry_array(pb, segment);
1267  case 0x3F0B:
1268  segment->index_edit_rate.num = avio_rb32(pb);
1269  segment->index_edit_rate.den = avio_rb32(pb);
1270  if (segment->index_edit_rate.num <= 0 ||
1271  segment->index_edit_rate.den <= 0)
1272  return AVERROR_INVALIDDATA;
1273  av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1274  segment->index_edit_rate.den);
1275  break;
1276  case 0x3F0C:
1277  segment->index_start_position = avio_rb64(pb);
1278  av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1279  break;
1280  case 0x3F0D:
1281  segment->index_duration = avio_rb64(pb);
1282  av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1283  break;
1284  }
1285  return 0;
1286 }
1287 
1288 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1289 {
1290  int code, value, ofs = 0;
1291  char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1292 
1293  do {
1294  code = avio_r8(pb);
1295  value = avio_r8(pb);
1296  av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1297 
1298  if (ofs <= 14) {
1299  layout[ofs++] = code;
1300  layout[ofs++] = value;
1301  } else
1302  break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1303  } while (code != 0); /* SMPTE 377M E.2.46 */
1304 
1305  ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1306 }
1307 
1308 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1309 {
1310  MXFDescriptor *descriptor = arg;
1311  int entry_count, entry_size;
1312 
1313  switch(tag) {
1314  case 0x3F01:
1315  return mxf_read_strong_ref_array(pb, &descriptor->file_descriptors_refs,
1316  &descriptor->file_descriptors_count);
1317  case 0x3002: /* ContainerDuration */
1318  descriptor->duration = avio_rb64(pb);
1319  break;
1320  case 0x3004:
1321  avio_read(pb, descriptor->essence_container_ul, 16);
1322  break;
1323  case 0x3005:
1324  avio_read(pb, descriptor->codec_ul, 16);
1325  break;
1326  case 0x3006:
1327  descriptor->linked_track_id = avio_rb32(pb);
1328  break;
1329  case 0x3201: /* PictureEssenceCoding */
1330  avio_read(pb, descriptor->essence_codec_ul, 16);
1331  break;
1332  case 0x3203:
1333  descriptor->width = avio_rb32(pb);
1334  break;
1335  case 0x3202:
1336  descriptor->height = avio_rb32(pb);
1337  break;
1338  case 0x320C:
1339  descriptor->frame_layout = avio_r8(pb);
1340  break;
1341  case 0x320D:
1342  entry_count = avio_rb32(pb);
1343  entry_size = avio_rb32(pb);
1344  if (entry_size == 4) {
1345  if (entry_count > 0)
1346  descriptor->video_line_map[0] = avio_rb32(pb);
1347  else
1348  descriptor->video_line_map[0] = 0;
1349  if (entry_count > 1)
1350  descriptor->video_line_map[1] = avio_rb32(pb);
1351  else
1352  descriptor->video_line_map[1] = 0;
1353  } else
1354  av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1355  break;
1356  case 0x320E:
1357  descriptor->aspect_ratio.num = avio_rb32(pb);
1358  descriptor->aspect_ratio.den = avio_rb32(pb);
1359  break;
1360  case 0x3210:
1361  avio_read(pb, descriptor->color_trc_ul, 16);
1362  break;
1363  case 0x3212:
1364  descriptor->field_dominance = avio_r8(pb);
1365  break;
1366  case 0x3219:
1367  avio_read(pb, descriptor->color_primaries_ul, 16);
1368  break;
1369  case 0x321A:
1370  avio_read(pb, descriptor->color_space_ul, 16);
1371  break;
1372  case 0x3301:
1373  descriptor->component_depth = avio_rb32(pb);
1374  break;
1375  case 0x3302:
1376  descriptor->horiz_subsampling = avio_rb32(pb);
1377  break;
1378  case 0x3304:
1379  descriptor->black_ref_level = avio_rb32(pb);
1380  break;
1381  case 0x3305:
1382  descriptor->white_ref_level = avio_rb32(pb);
1383  break;
1384  case 0x3306:
1385  descriptor->color_range = avio_rb32(pb);
1386  break;
1387  case 0x3308:
1388  descriptor->vert_subsampling = avio_rb32(pb);
1389  break;
1390  case 0x3D03:
1391  descriptor->sample_rate.num = avio_rb32(pb);
1392  descriptor->sample_rate.den = avio_rb32(pb);
1393  break;
1394  case 0x3D06: /* SoundEssenceCompression */
1395  avio_read(pb, descriptor->essence_codec_ul, 16);
1396  break;
1397  case 0x3D07:
1398  descriptor->channels = avio_rb32(pb);
1399  break;
1400  case 0x3D01:
1401  descriptor->bits_per_sample = avio_rb32(pb);
1402  break;
1403  case 0x3401:
1404  mxf_read_pixel_layout(pb, descriptor);
1405  break;
1406  default:
1407  /* Private uid used by SONY C0023S01.mxf */
1408  if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1409  if (descriptor->extradata)
1410  av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1411  av_free(descriptor->extradata);
1412  descriptor->extradata_size = 0;
1413  descriptor->extradata = av_malloc(size);
1414  if (!descriptor->extradata)
1415  return AVERROR(ENOMEM);
1416  descriptor->extradata_size = size;
1417  avio_read(pb, descriptor->extradata, size);
1418  }
1419  if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1420  uint32_t rsiz = avio_rb16(pb);
1421  if (rsiz == AV_PROFILE_JPEG2000_DCINEMA_2K ||
1422  rsiz == AV_PROFILE_JPEG2000_DCINEMA_4K)
1423  descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1424  }
1425  if (IS_KLV_KEY(uid, mxf_mastering_display_prefix)) {
1426  if (!descriptor->mastering) {
1427  descriptor->mastering = av_mastering_display_metadata_alloc();
1428  if (!descriptor->mastering)
1429  return AVERROR(ENOMEM);
1430  }
1431  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[0])) {
1432  for (int i = 0; i < 3; i++) {
1433  /* Order: large x, large y, other (i.e. RGB) */
1434  descriptor->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1435  descriptor->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1436  }
1437  /* Check we have seen mxf_mastering_display_white_point_chromaticity */
1438  if (descriptor->mastering->white_point[0].den != 0)
1439  descriptor->mastering->has_primaries = 1;
1440  }
1441  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[1])) {
1442  descriptor->mastering->white_point[0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1443  descriptor->mastering->white_point[1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1444  /* Check we have seen mxf_mastering_display_primaries */
1445  if (descriptor->mastering->display_primaries[0][0].den != 0)
1446  descriptor->mastering->has_primaries = 1;
1447  }
1448  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[2])) {
1449  descriptor->mastering->max_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1450  /* Check we have seen mxf_mastering_display_minimum_luminance */
1451  if (descriptor->mastering->min_luminance.den != 0)
1452  descriptor->mastering->has_luminance = 1;
1453  }
1454  if (IS_KLV_KEY(uid, mxf_mastering_display_uls[3])) {
1455  descriptor->mastering->min_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1456  /* Check we have seen mxf_mastering_display_maximum_luminance */
1457  if (descriptor->mastering->max_luminance.den != 0)
1458  descriptor->mastering->has_luminance = 1;
1459  }
1460  }
1461  if (IS_KLV_KEY(uid, mxf_apple_coll_prefix)) {
1462  if (!descriptor->coll) {
1463  descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1464  if (!descriptor->coll)
1465  return AVERROR(ENOMEM);
1466  }
1467  if (IS_KLV_KEY(uid, mxf_apple_coll_max_cll)) {
1468  descriptor->coll->MaxCLL = avio_rb16(pb);
1469  }
1470  if (IS_KLV_KEY(uid, mxf_apple_coll_max_fall)) {
1471  descriptor->coll->MaxFALL = avio_rb16(pb);
1472  }
1473  }
1474 
1475  if (IS_KLV_KEY(uid, mxf_sub_descriptor))
1476  return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs, &descriptor->sub_descriptors_count);
1477 
1478  break;
1479  }
1480  return 0;
1481 }
1482 
1483 static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1484 {
1485  MXFMCASubDescriptor *mca_sub_descriptor = arg;
1486 
1487  if (IS_KLV_KEY(uid, mxf_mca_label_dictionary_id))
1488  avio_read(pb, mca_sub_descriptor->mca_label_dictionary_id, 16);
1489 
1490  if (IS_KLV_KEY(uid, mxf_mca_link_id))
1491  avio_read(pb, mca_sub_descriptor->mca_link_id, 16);
1492 
1493  if (IS_KLV_KEY(uid, mxf_soundfield_group_link_id))
1494  avio_read(pb, mca_sub_descriptor->soundfield_group_link_id, 16);
1495 
1496  if (IS_KLV_KEY(uid, mxf_group_of_soundfield_groups_link_id))
1497  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);
1498 
1499  if (IS_KLV_KEY(uid, mxf_mca_channel_id))
1500  mca_sub_descriptor->mca_channel_id = avio_rb32(pb);
1501 
1502  if (IS_KLV_KEY(uid, mxf_mca_rfc5646_spoken_language))
1503  return mxf_read_us_ascii_string(pb, size, &mca_sub_descriptor->language);
1504 
1505  return 0;
1506 }
1507 
1508 static int mxf_read_ffv1_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1509 {
1510  MXFFFV1SubDescriptor *ffv1_sub_descriptor = arg;
1511 
1512  if (IS_KLV_KEY(uid, mxf_ffv1_extradata) && size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ) {
1513  if (ffv1_sub_descriptor->extradata)
1514  av_log(NULL, AV_LOG_WARNING, "Duplicate ffv1_extradata\n");
1515  av_free(ffv1_sub_descriptor->extradata);
1516  ffv1_sub_descriptor->extradata_size = 0;
1517  ffv1_sub_descriptor->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
1518  if (!ffv1_sub_descriptor->extradata)
1519  return AVERROR(ENOMEM);
1520  ffv1_sub_descriptor->extradata_size = size;
1521  avio_read(pb, ffv1_sub_descriptor->extradata, size);
1522  }
1523 
1524  return 0;
1525 }
1526 
1527 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1528 {
1529  MXFTaggedValue *tagged_value = arg;
1530  uint8_t key[17];
1531 
1532  if (size <= 17)
1533  return 0;
1534 
1535  avio_read(pb, key, 17);
1536  /* TODO: handle other types of of indirect values */
1537  if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1538  return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1539  } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1540  return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1541  }
1542  return 0;
1543 }
1544 
1545 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1546 {
1547  MXFTaggedValue *tagged_value = arg;
1548  switch (tag){
1549  case 0x5001:
1550  return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1551  case 0x5003:
1552  return mxf_read_indirect_value(tagged_value, pb, size);
1553  }
1554  return 0;
1555 }
1556 
1557 /*
1558  * Match an uid independently of the version byte and up to len common bytes
1559  * Returns: boolean
1560  */
1561 static int mxf_match_uid(const UID key, const uint8_t uid_prefix[], int len)
1562 {
1563  int i;
1564  for (i = 0; i < len; i++) {
1565  if (i != 7 && key[i] != uid_prefix[i])
1566  return 0;
1567  }
1568  return 1;
1569 }
1570 
1571 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1572 {
1573  while (uls->uid[0]) {
1574  if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1575  break;
1576  uls++;
1577  }
1578  return uls;
1579 }
1580 
1581 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1582 {
1583  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
1584 
1585  if (!strong_ref)
1586  return NULL;
1587  for (int i = mg->metadata_sets_count - 1; i >= 0; i--)
1588  if (!memcmp(*strong_ref, mg->metadata_sets[i]->uid, 16))
1589  return mg->metadata_sets[i];
1590 
1591  return NULL;
1592 }
1593 
1594 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1595  // video essence container uls
1596  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14, J2KWrap },
1597  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264, NULL, 15 }, /* H.264 */
1598  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14, AV_CODEC_ID_DNXHD, NULL, 14 }, /* VC-3 */
1599  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1, NULL, 14 }, /* VC-1 */
1600  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1601  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14, AV_CODEC_ID_DIRAC, NULL, 14 }, /* VC-2 */
1602  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14, AV_CODEC_ID_CFHD, NULL, 14 }, /* VC-5 */
1603  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1604  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1605  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15, D10D11Wrap }, /* SMPTE D-10 mapping */
1606  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x23,0x01,0x00 }, 14, AV_CODEC_ID_FFV1, NULL, 14 },
1607  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO, NULL, 15 }, /* DV 625 25mbps */
1608  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO, NULL, 15, RawVWrap }, /* uncompressed picture */
1609  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1610  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1611  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16, AV_CODEC_ID_HEVC, NULL, 15 }, /* Canon XF-HEVC */
1612  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1613  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1614 };
1615 
1616 /* EC ULs for intra-only formats */
1617 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1618  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 mappings */
1619  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1620 };
1621 
1622 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1623 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1624  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */
1625  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1626  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1627 };
1628 
1629 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1630 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1631  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1632  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1633  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1634  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1635  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1636 };
1637 
1638 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1639  // sound essence container uls
1640  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 14, RawAWrap }, /* BWF */
1641  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2, NULL, 15 }, /* MPEG-ES */
1642  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 13 }, /* D-10 Mapping 50Mbps PAL Extended Template */
1643  { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14, AV_CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */
1644  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1645  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x16,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC ADIF (SMPTE 381-4) */
1646  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x17,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC ADTS (SMPTE 381-4) */
1647  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x18,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC LATM/LOAS (SMPTE 381-4) */
1648  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1649 };
1650 
1651 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1652  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_smpte_436M", 11 },
1653  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_vanc_smpte_436M", 11 },
1654  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1655  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1656 };
1657 
1658 typedef struct MXFChannelOrderingUL {
1659  UID uid;
1660  enum AVChannel channel;
1661  enum AVAudioServiceType service_type;
1662 } MXFChannelOrderingUL;
1663 
1664 static const MXFChannelOrderingUL mxf_channel_ordering[] = {
1665  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x01,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left
1666  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x02,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right
1667  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x03,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center
1668  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x04,0x00,0x00,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Low Frequency Effects
1669  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x05,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround
1670  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x06,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround
1671  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x07,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround
1672  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x08,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround
1673  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x09,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround
1674  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0a,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround
1675  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0b,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_LEFT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Center
1676  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0c,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_RIGHT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Center
1677  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0d,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Surround
1678  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0e,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, // Hearing impaired audio channel
1679  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0f,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED }, // Visually impaired narrative audio channel
1680  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x03,0x00,0x00,0x00 }, AV_CHAN_STEREO_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Total
1681  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x04,0x00,0x00,0x00 }, AV_CHAN_STEREO_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Total
1682  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x01,0x00,0x00 }, AV_CHAN_TOP_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Height
1683  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x02,0x00,0x00 }, AV_CHAN_TOP_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Height
1684  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x03,0x00,0x00 }, AV_CHAN_TOP_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Height
1685  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x04,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround Height
1686  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x05,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround Height
1687  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x06,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround Height
1688  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x07,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround Height
1689  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x08,0x00,0x00 }, AV_CHAN_TOP_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround Height
1690  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x09,0x00,0x00 }, AV_CHAN_TOP_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround Height
1691  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0a,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Top Surround
1692  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0b,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Top Surround
1693  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0c,0x00,0x00 }, AV_CHAN_TOP_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Top Surround
1694  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0d,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Front Subwoofer
1695  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0e,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY_2, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Front Subwoofer
1696  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0f,0x00,0x00 }, AV_CHAN_TOP_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear Height
1697  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x10,0x00,0x00 }, AV_CHAN_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear
1698  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x11,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Below
1699  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x12,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Below
1700  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x13,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Below
1701  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_AUDIO_SERVICE_TYPE_NB },
1702 };
1703 
1704 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1705 {
1706  int val;
1707  const MXFCodecUL *codec_ul;
1708 
1709  codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1710  if (!codec_ul->uid[0])
1711  codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1712  if (!codec_ul->uid[0])
1713  codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1714  if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1715  return UnknownWrapped;
1716 
1717  val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1718  switch (codec_ul->wrapping_indicator_type) {
1719  case RawVWrap:
1720  val = val % 4;
1721  break;
1722  case RawAWrap:
1723  if (val == 0x03 || val == 0x04)
1724  val -= 0x02;
1725  break;
1726  case D10D11Wrap:
1727  if (val == 0x02)
1728  val = 0x01;
1729  break;
1730  case J2KWrap:
1731  if (val != 0x02)
1732  val = 0x01;
1733  break;
1734  }
1735  if (val == 0x01)
1736  return FrameWrapped;
1737  if (val == 0x02)
1738  return ClipWrapped;
1739  return UnknownWrapped;
1740 }
1741 
1742 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1743 {
1744  int i, j, nb_segments = 0;
1745  MXFIndexTableSegment **unsorted_segments;
1746  int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1747  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[IndexTableSegment];
1748 
1749  /* count number of segments, allocate arrays and copy unsorted segments */
1750  nb_segments = mg->metadata_sets_count;
1751  if (!nb_segments)
1752  return AVERROR_INVALIDDATA;
1753 
1754  if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1755  !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1756  av_freep(sorted_segments);
1757  av_free(unsorted_segments);
1758  return AVERROR(ENOMEM);
1759  }
1760 
1761  for (i = nb_segments = 0; i < mg->metadata_sets_count; i++) {
1762  MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
1763  if (s->edit_unit_byte_count || s->nb_index_entries)
1764  unsorted_segments[nb_segments++] = s;
1765  else
1766  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1767  s->index_sid, s->index_start_position);
1768  }
1769 
1770  if (!nb_segments) {
1771  av_freep(sorted_segments);
1772  av_free(unsorted_segments);
1773  return AVERROR_INVALIDDATA;
1774  }
1775 
1776  *nb_sorted_segments = 0;
1777 
1778  /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1779  for (i = 0; i < nb_segments; i++) {
1780  int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1781  uint64_t best_index_duration = 0;
1782 
1783  for (j = 0; j < nb_segments; j++) {
1784  MXFIndexTableSegment *s = unsorted_segments[j];
1785 
1786  /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1787  * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1788  * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1789  */
1790  if ((i == 0 ||
1791  s->body_sid > last_body_sid ||
1792  s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1793  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1794  (best == -1 ||
1795  s->body_sid < best_body_sid ||
1796  s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1797  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1798  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1799  best = j;
1800  best_body_sid = s->body_sid;
1801  best_index_sid = s->index_sid;
1802  best_index_start = s->index_start_position;
1803  best_index_duration = s->index_duration;
1804  }
1805  }
1806 
1807  /* no suitable entry found -> we're done */
1808  if (best == -1)
1809  break;
1810 
1811  (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1812  last_body_sid = best_body_sid;
1813  last_index_sid = best_index_sid;
1814  last_index_start = best_index_start;
1815  }
1816 
1817  av_free(unsorted_segments);
1818 
1819  return 0;
1820 }
1821 
1822 /**
1823  * Computes the absolute file offset of the given essence container offset
1824  */
1825 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1826 {
1827  MXFPartition *last_p = NULL;
1828  int a, b, m, m0;
1829 
1830  if (offset < 0)
1831  return AVERROR(EINVAL);
1832 
1833  a = -1;
1834  b = mxf->partitions_count;
1835 
1836  while (b - a > 1) {
1837  m0 = m = (a + b) >> 1;
1838 
1839  while (m < b && mxf->partitions[m].body_sid != body_sid)
1840  m++;
1841 
1842  if (m < b && mxf->partitions[m].body_offset <= offset)
1843  a = m;
1844  else
1845  b = m0;
1846  }
1847 
1848  if (a >= 0)
1849  last_p = &mxf->partitions[a];
1850 
1851  if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1852  *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1853  if (partition_out)
1854  *partition_out = last_p;
1855  return 0;
1856  }
1857 
1858  av_log(mxf->fc, AV_LOG_ERROR,
1859  "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1860  offset, body_sid);
1861 
1862  return AVERROR_INVALIDDATA;
1863 }
1864 
1865 /**
1866  * Returns the end position of the essence container with given BodySID, or zero if unknown
1867  */
1868 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1869 {
1870  for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1871  MXFPartition *p = &mxf->partitions[x];
1872 
1873  if (p->body_sid != body_sid)
1874  continue;
1875 
1876  if (!p->essence_length)
1877  return 0;
1878 
1879  return p->essence_offset + p->essence_length;
1880  }
1881 
1882  return 0;
1883 }
1884 
1885 /* EditUnit -> absolute offset */
1886 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
1887 {
1888  int i;
1889  int64_t offset_temp = 0;
1890 
1891  edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1892 
1893  for (i = 0; i < index_table->nb_segments; i++) {
1894  MXFIndexTableSegment *s = index_table->segments[i];
1895 
1896  edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1897 
1898  if (edit_unit < s->index_start_position + s->index_duration) {
1899  int64_t index = edit_unit - s->index_start_position;
1900 
1901  if (s->edit_unit_byte_count) {
1902  if (index > INT64_MAX / s->edit_unit_byte_count ||
1903  s->edit_unit_byte_count * index > INT64_MAX - offset_temp)
1904  return AVERROR_INVALIDDATA;
1905 
1906  offset_temp += s->edit_unit_byte_count * index;
1907  } else {
1908  if (s->nb_index_entries == 2 * s->index_duration + 1)
1909  index *= 2; /* Avid index */
1910 
1911  if (index < 0 || index >= s->nb_index_entries) {
1912  av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1913  index_table->index_sid, s->index_start_position);
1914  return AVERROR_INVALIDDATA;
1915  }
1916 
1917  offset_temp = s->stream_offset_entries[index];
1918  }
1919 
1920  if (edit_unit_out)
1921  *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1922 
1923  return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1924  } else {
1925  /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1926  offset_temp += s->edit_unit_byte_count * s->index_duration;
1927  }
1928  }
1929 
1930  if (nag)
1931  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);
1932 
1933  return AVERROR_INVALIDDATA;
1934 }
1935 
1936 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1937 {
1938  int i, j, x;
1939  int8_t max_temporal_offset = -128;
1940  uint8_t *flags;
1941 
1942  /* first compute how many entries we have */
1943  for (i = 0; i < index_table->nb_segments; i++) {
1944  MXFIndexTableSegment *s = index_table->segments[i];
1945 
1946  if (!s->nb_index_entries) {
1947  index_table->nb_ptses = 0;
1948  return 0; /* no TemporalOffsets */
1949  }
1950 
1951  if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1952  index_table->nb_ptses = 0;
1953  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1954  return 0;
1955  }
1956 
1957  if (s->nb_index_entries != s->index_duration &&
1958  s->nb_index_entries != s->index_duration + 1 && /* Avid index */
1959  s->nb_index_entries != s->index_duration * 2 + 1) {
1960  index_table->nb_ptses = 0;
1961  av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration does not match nb_index_entries\n", s->index_sid);
1962  return 0;
1963  }
1964 
1965  index_table->nb_ptses += s->index_duration;
1966  }
1967 
1968  /* paranoid check */
1969  if (index_table->nb_ptses <= 0)
1970  return 0;
1971 
1972  if (!(index_table->ptses = av_malloc_array(index_table->nb_ptses, sizeof(int64_t))) ||
1973  !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1974  !(index_table->offsets = av_malloc_array(index_table->nb_ptses, sizeof(int8_t))) ||
1975  !(flags = av_malloc_array(index_table->nb_ptses, sizeof(uint8_t)))) {
1976  av_freep(&index_table->ptses);
1977  av_freep(&index_table->fake_index);
1978  av_freep(&index_table->offsets);
1979  return AVERROR(ENOMEM);
1980  }
1981 
1982  /* we may have a few bad TemporalOffsets
1983  * make sure the corresponding PTSes don't have the bogus value 0 */
1984  for (x = 0; x < index_table->nb_ptses; x++)
1985  index_table->ptses[x] = AV_NOPTS_VALUE;
1986 
1987  /**
1988  * We have this:
1989  *
1990  * x TemporalOffset
1991  * 0: 0
1992  * 1: 1
1993  * 2: 1
1994  * 3: -2
1995  * 4: 1
1996  * 5: 1
1997  * 6: -2
1998  *
1999  * We want to transform it into this:
2000  *
2001  * x DTS PTS
2002  * 0: -1 0
2003  * 1: 0 3
2004  * 2: 1 1
2005  * 3: 2 2
2006  * 4: 3 6
2007  * 5: 4 4
2008  * 6: 5 5
2009  *
2010  * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
2011  * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
2012  * The latter makes DTS <= PTS.
2013  */
2014  for (i = x = 0; i < index_table->nb_segments; i++) {
2015  MXFIndexTableSegment *s = index_table->segments[i];
2016  int index_delta = 1;
2017  int n = s->nb_index_entries;
2018 
2019  if (s->nb_index_entries == 2 * s->index_duration + 1)
2020  index_delta = 2; /* Avid index */
2021  if (s->nb_index_entries == index_delta * s->index_duration + 1)
2022  /* ignore the last entry - it's the size of the essence container in Avid */
2023  n--;
2024 
2025  for (j = 0; j < n; j += index_delta, x++) {
2026  int offset = s->temporal_offset_entries[j] / index_delta;
2027  int index = x + offset;
2028 
2029  if (x >= index_table->nb_ptses) {
2030  av_log(mxf->fc, AV_LOG_ERROR,
2031  "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
2032  s->nb_index_entries, s->index_duration);
2033  break;
2034  }
2035 
2036  flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
2037 
2038  if (index < 0 || index >= index_table->nb_ptses) {
2039  av_log(mxf->fc, AV_LOG_ERROR,
2040  "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
2041  x, offset, index);
2042  continue;
2043  }
2044 
2045  index_table->offsets[x] = offset;
2046  index_table->ptses[index] = x;
2047  max_temporal_offset = FFMAX(max_temporal_offset, offset);
2048  }
2049  }
2050 
2051  /* calculate the fake index table in display order */
2052  for (x = 0; x < index_table->nb_ptses; x++) {
2053  index_table->fake_index[x].timestamp = x;
2054  if (index_table->ptses[x] != AV_NOPTS_VALUE)
2055  index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2056  }
2057  av_freep(&flags);
2058 
2059  index_table->first_dts = -max_temporal_offset;
2060 
2061  return 0;
2062 }
2063 
2064 /**
2065  * Sorts and collects index table segments into index tables.
2066  * Also computes PTSes if possible.
2067  */
2068 static int mxf_compute_index_tables(MXFContext *mxf)
2069 {
2070  int i, j, k, ret, nb_sorted_segments;
2071  MXFIndexTableSegment **sorted_segments = NULL;
2072 
2073  if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2074  nb_sorted_segments <= 0) {
2075  av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2076  return 0;
2077  }
2078 
2079  /* sanity check and count unique BodySIDs/IndexSIDs */
2080  for (i = 0; i < nb_sorted_segments; i++) {
2081  if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2082  mxf->nb_index_tables++;
2083  else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2084  av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2085  ret = AVERROR_INVALIDDATA;
2086  goto finish_decoding_index;
2087  }
2088  }
2089 
2090  mxf->index_tables = av_calloc(mxf->nb_index_tables,
2091  sizeof(*mxf->index_tables));
2092  if (!mxf->index_tables) {
2093  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2094  ret = AVERROR(ENOMEM);
2095  goto finish_decoding_index;
2096  }
2097 
2098  /* distribute sorted segments to index tables */
2099  for (i = j = 0; i < nb_sorted_segments; i++) {
2100  if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2101  /* next IndexSID */
2102  j++;
2103  }
2104 
2105  mxf->index_tables[j].nb_segments++;
2106  }
2107 
2108  for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2109  MXFIndexTable *t = &mxf->index_tables[j];
2110  MXFTrack *mxf_track = NULL;
2111 
2112  t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2113  if (!t->segments) {
2114  av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2115  " pointer array\n");
2116  ret = AVERROR(ENOMEM);
2117  goto finish_decoding_index;
2118  }
2119 
2120  if (sorted_segments[i]->index_start_position)
2121  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2122  sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2123 
2124  memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2125  t->index_sid = sorted_segments[i]->index_sid;
2126  t->body_sid = sorted_segments[i]->body_sid;
2127 
2128  if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2129  goto finish_decoding_index;
2130 
2131  for (k = 0; k < mxf->fc->nb_streams; k++) {
2132  MXFTrack *track = mxf->fc->streams[k]->priv_data;
2133  if (track && track->index_sid == t->index_sid) {
2134  mxf_track = track;
2135  break;
2136  }
2137  }
2138 
2139  /* fix zero IndexDurations */
2140  for (k = 0; k < t->nb_segments; k++) {
2141  if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2142  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2143  t->index_sid, k);
2144  if (mxf_track)
2145  t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2146  }
2147 
2148  if (t->segments[k]->index_duration)
2149  continue;
2150 
2151  if (t->nb_segments > 1)
2152  av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2153  t->index_sid, k);
2154 
2155  if (!mxf_track) {
2156  av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2157  break;
2158  }
2159 
2160  /* assume the first stream's duration is reasonable
2161  * leave index_duration = 0 on further segments in case we have any (unlikely)
2162  */
2163  t->segments[k]->index_duration = mxf_track->original_duration;
2164  break;
2165  }
2166  }
2167 
2168  ret = 0;
2169 finish_decoding_index:
2170  av_free(sorted_segments);
2171  return ret;
2172 }
2173 
2174 static int mxf_is_st_422(const UID *essence_container_ul) {
2175  static const uint8_t st_422_essence_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c };
2176 
2177  return essence_container_ul && mxf_match_uid(*essence_container_ul, st_422_essence_container_ul,
2178  sizeof(st_422_essence_container_ul));
2179 }
2180 
2181 static int mxf_is_intra_only(MXFDescriptor *descriptor)
2182 {
2183  return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
2184  &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
2185  mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
2186  &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
2187 }
2188 
2189 static void mxf_umid_to_str(const UID ul, const UID uid,
2190  char str[2 + sizeof(UID) * 4 + 1])
2191 {
2192  snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2193  ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2194  ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2195 }
2196 
2197 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2198  uint16_t patch, uint16_t release, char **str)
2199 {
2200  *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2201  if (!*str)
2202  return AVERROR(ENOMEM);
2203  return 0;
2204 }
2205 
2206 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2207 {
2208  char str[2 + 4 * sizeof(UID) + 1];
2209  if (!package)
2210  return 0;
2211  mxf_umid_to_str(package->package_ul, package->package_uid, str);
2212  av_dict_set(pm, key, str, 0);
2213  return 0;
2214 }
2215 
2216 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2217 {
2218  char buf[AV_TIMECODE_STR_SIZE];
2219  av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2220 
2221  return 0;
2222 }
2223 
2224 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2225 {
2226  MXFTimecodeComponent *timecode;
2227  MXFPulldownComponent *pulldown;
2228 
2229  timecode = mxf_resolve_strong_ref(mxf, strong_ref, TimecodeComponent);
2230  if (timecode)
2231  return timecode;
2232 
2233  pulldown = mxf_resolve_strong_ref(mxf, strong_ref, PulldownComponent);
2234  if (pulldown)
2235  return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2236 
2237  return NULL;
2238 }
2239 
2240 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2241 {
2242  MXFPackage *package = NULL;
2243  int i;
2244 
2245  for (i = 0; i < mxf->packages_count; i++) {
2246  package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2247  if (!package)
2248  continue;
2249 
2250  if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2251  return package;
2252  }
2253  return NULL;
2254 }
2255 
2256 static MXFDescriptor* mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
2257 {
2258  MXFDescriptor *descriptor = mxf_resolve_strong_ref(mxf, strong_ref, Descriptor);
2259  if (descriptor)
2260  return descriptor;
2261 
2262  descriptor = mxf_resolve_strong_ref(mxf, strong_ref, MultipleDescriptor);
2263  if (descriptor) {
2264  for (int i = 0; i < descriptor->file_descriptors_count; i++) {
2265  MXFDescriptor *file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2266 
2267  if (!file_descriptor) {
2268  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2269  continue;
2270  }
2271  if (file_descriptor->linked_track_id == track_id) {
2272  return file_descriptor;
2273  }
2274  }
2275  }
2276 
2277  return NULL;
2278 }
2279 
2280 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2281 {
2282  MXFStructuralComponent *component = NULL;
2283  MXFPackage *package = NULL;
2284  MXFDescriptor *descriptor = NULL;
2285  MXFEssenceGroup *essence_group;
2286  int i;
2287 
2288  component = mxf_resolve_strong_ref(mxf, strong_ref, SourceClip);
2289  if (component)
2290  return component;
2291 
2292  essence_group = mxf_resolve_strong_ref(mxf, strong_ref, EssenceGroup);
2293  if (!essence_group)
2294  return NULL;
2295 
2296  /* essence groups contains multiple representations of the same media,
2297  this return the first components with a valid Descriptor typically index 0 */
2298  for (i =0; i < essence_group->structural_components_count; i++){
2299  component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2300  if (!component)
2301  continue;
2302 
2303  if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2304  continue;
2305 
2306  descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2307  if (descriptor)
2308  return component;
2309  }
2310 
2311  return NULL;
2312 }
2313 
2314 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2315 {
2316  MXFTaggedValue *tag;
2317  int i;
2318  char *key = NULL;
2319 
2320  for (i = 0; i < package->comment_count; i++) {
2321  tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2322  if (!tag || !tag->name || !tag->value)
2323  continue;
2324 
2325  key = av_asprintf("comment_%s", tag->name);
2326  if (!key)
2327  return AVERROR(ENOMEM);
2328 
2329  av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2330  }
2331  return 0;
2332 }
2333 
2334 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2335 {
2336  MXFPackage *physical_package = NULL;
2337  MXFTrack *physical_track = NULL;
2338  MXFStructuralComponent *sourceclip = NULL;
2339  MXFTimecodeComponent *mxf_tc = NULL;
2340  int i, j, k;
2341  AVTimecode tc;
2342  int flags;
2343  int64_t start_position;
2344 
2345  for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2346  sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2347  if (!sourceclip)
2348  continue;
2349 
2350  if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2351  break;
2352 
2353  mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2354 
2355  /* the name of physical source package is name of the reel or tape */
2356  if (physical_package->name && physical_package->name[0])
2357  av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2358 
2359  /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2360  * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2361  */
2362  for (j = 0; j < physical_package->tracks_count; j++) {
2363  if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2364  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2365  continue;
2366  }
2367 
2368  if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2369  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2370  continue;
2371  }
2372 
2373  if (physical_track->edit_rate.num <= 0 ||
2374  physical_track->edit_rate.den <= 0) {
2375  av_log(mxf->fc, AV_LOG_WARNING,
2376  "Invalid edit rate (%d/%d) found on structural"
2377  " component #%d, defaulting to 25/1\n",
2378  physical_track->edit_rate.num,
2379  physical_track->edit_rate.den, i);
2380  physical_track->edit_rate = (AVRational){25, 1};
2381  }
2382 
2383  for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2384  if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2385  continue;
2386 
2387  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2388  /* scale sourceclip start_position to match physical track edit rate */
2389  start_position = av_rescale_q(sourceclip->start_position,
2390  physical_track->edit_rate,
2391  source_track->edit_rate);
2392 
2393  if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2394  mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2395  return 0;
2396  }
2397  }
2398  }
2399  }
2400 
2401  return 0;
2402 }
2403 
2404 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2405 {
2406  MXFStructuralComponent *component = NULL;
2407  const MXFCodecUL *codec_ul = NULL;
2408  MXFPackage tmp_package;
2409  AVStream *st;
2410  int j;
2411 
2412  for (j = 0; j < track->sequence->structural_components_count; j++) {
2413  component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2414  if (!component)
2415  continue;
2416  break;
2417  }
2418  if (!component)
2419  return 0;
2420 
2421  st = avformat_new_stream(mxf->fc, NULL);
2422  if (!st) {
2423  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2424  return AVERROR(ENOMEM);
2425  }
2426 
2427  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2428  st->codecpar->codec_id = AV_CODEC_ID_NONE;
2429  st->id = track->track_id;
2430 
2431  memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2432  memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2433  mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2434  if (track->name && track->name[0])
2435  av_dict_set(&st->metadata, "track_name", track->name, 0);
2436 
2437  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2438  av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2439  return 0;
2440 }
2441 
2442 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2443 {
2444  if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2445  /* CDCI range metadata */
2446  if (!descriptor->component_depth)
2447  return AVCOL_RANGE_UNSPECIFIED;
2448  if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2449  descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2450  (descriptor->color_range == (1<<descriptor->component_depth) ||
2451  descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2452  return AVCOL_RANGE_JPEG;
2453  if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2454  descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2455  descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2456  descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2457  return AVCOL_RANGE_MPEG;
2458  avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2459  descriptor->color_range, descriptor->black_ref_level,
2460  descriptor->white_ref_level, descriptor->component_depth);
2461  }
2462 
2463  return AVCOL_RANGE_UNSPECIFIED;
2464 }
2465 
2466 static int is_pcm(enum AVCodecID codec_id)
2467 {
2468  /* we only care about "normal" PCM codecs until we get samples */
2469  return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2470 }
2471 
2472 static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2473 {
2474  // language abbr should contain at least 2 chars
2475  if (rfc5646 && strlen(rfc5646) > 1) {
2476  char primary_tag[4] =
2477  {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2478 
2479  const char *iso6392 = ff_convert_lang_to(primary_tag,
2480  AV_LANG_ISO639_2_BIBL);
2481  if (iso6392)
2482  return(av_dict_set(met, "language", iso6392, 0));
2483  }
2484  return 0;
2485 }
2486 
2487 static MXFMCASubDescriptor *find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
2488 {
2489  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
2490  for (int k = 0; k < mg->metadata_sets_count; k++) {
2491  MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mg->metadata_sets[k];
2492  if (!memcmp(&group->mca_link_id, mca_link_id, 16))
2493  return group;
2494  }
2495  return NULL;
2496 }
2497 
2498 static void parse_ffv1_sub_descriptor(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2499 {
2500  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2501  MXFFFV1SubDescriptor *ffv1_sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], FFV1SubDescriptor);
2502  if (ffv1_sub_descriptor == NULL)
2503  continue;
2504 
2505  descriptor->extradata = ffv1_sub_descriptor->extradata;
2506  descriptor->extradata_size = ffv1_sub_descriptor->extradata_size;
2507  ffv1_sub_descriptor->extradata = NULL;
2508  ffv1_sub_descriptor->extradata_size = 0;
2509  break;
2510  }
2511 }
2512 
2513 static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2514 {
2515  AVChannelLayout *ch_layout = &st->codecpar->ch_layout;
2516  char *language = NULL;
2517  int ambigous_language = 0;
2518  enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2519  int ambigous_service_type = 0;
2520  int ret;
2521 
2522  for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2523  char *channel_language;
2524 
2525  MXFMCASubDescriptor *label = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], AudioChannelLabelSubDescriptor);
2526  if (label == NULL)
2527  continue;
2528 
2529  if (ch_layout->order == AV_CHANNEL_ORDER_UNSPEC) {
2530  av_channel_layout_uninit(ch_layout);
2531  ret = av_channel_layout_custom_init(ch_layout, descriptor->channels);
2532  if (ret < 0)
2533  return ret;
2534  }
2535 
2536  for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2537  if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2538  int target_channel = label->mca_channel_id;
2539  if (target_channel == 0 && descriptor->channels == 1)
2540  target_channel = 1;
2541  if (target_channel <= 0 || target_channel > descriptor->channels) {
2542  av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2543  return AVERROR_INVALIDDATA;
2544  }
2545  ch_layout->u.map[target_channel - 1].id = channel_ordering->channel;
2546  if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2547  service_type = channel_ordering->service_type;
2548  else if (service_type != channel_ordering->service_type)
2549  ambigous_service_type = 1;
2550  break;
2551  }
2552  }
2553 
2554  channel_language = label->language;
2555  if (!channel_language) {
2556  MXFMCASubDescriptor *group = find_mca_link_id(mxf, SoundfieldGroupLabelSubDescriptor, &label->soundfield_group_link_id);
2557  if (group) {
2558  channel_language = group->language;
2559  if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2560  MXFMCASubDescriptor *supergroup = find_mca_link_id(mxf, GroupOfSoundfieldGroupsLabelSubDescriptor,
2561  group->group_of_soundfield_groups_link_id_refs);
2562  if (supergroup)
2563  channel_language = supergroup->language;
2564  }
2565  }
2566  }
2567  if (channel_language) {
2568  if (language && strcmp(language, channel_language))
2569  ambigous_language = 1;
2570  else
2571  language = channel_language;
2572  }
2573  }
2574 
2575  if (language && !ambigous_language) {
2576  int ret = set_language(mxf->fc, language, &st->metadata);
2577  if (ret < 0)
2578  return ret;
2579  }
2580 
2581  if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2582  enum AVAudioServiceType *ast;
2583  AVPacketSideData *side_data = av_packet_side_data_new(&st->codecpar->coded_side_data,
2584  &st->codecpar->nb_coded_side_data,
2585  AV_PKT_DATA_AUDIO_SERVICE_TYPE,
2586  sizeof(*ast), 0);
2587  if (!side_data)
2588  return AVERROR(ENOMEM);
2589  ast = (enum AVAudioServiceType*)side_data->data;
2590  *ast = service_type;
2591  }
2592 
2593  ret = av_channel_layout_retype(ch_layout, 0, AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL);
2594  if (ret < 0)
2595  return ret;
2596 
2597  return 0;
2598 }
2599 
2600 static int mxf_parse_structural_metadata(MXFContext *mxf)
2601 {
2602  MXFPackage *material_package = NULL;
2603  int i, j, k, ret;
2604 
2605  /* TODO: handle multiple material packages (OP3x) */
2606  for (i = 0; i < mxf->packages_count; i++) {
2607  material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2608  if (material_package) break;
2609  }
2610  if (!material_package) {
2611  av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2612  return AVERROR_INVALIDDATA;
2613  }
2614 
2615  mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2616  if (material_package->name && material_package->name[0])
2617  av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2618  mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2619 
2620  for (i = 0; i < material_package->tracks_count; i++) {
2621  MXFPackage *source_package = NULL;
2622  MXFTrack *material_track = NULL;
2623  MXFTrack *source_track = NULL;
2624  MXFTrack *temp_track = NULL;
2625  MXFDescriptor *descriptor = NULL;
2626  MXFStructuralComponent *component = NULL;
2627  MXFTimecodeComponent *mxf_tc = NULL;
2628  UID *essence_container_ul = NULL;
2629  const MXFCodecUL *codec_ul = NULL;
2630  const MXFCodecUL *container_ul = NULL;
2631  const MXFCodecUL *pix_fmt_ul = NULL;
2632  AVStream *st;
2633  FFStream *sti;
2634  AVTimecode tc;
2635  int flags;
2636 
2637  if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2638  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2639  continue;
2640  }
2641 
2642  if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2643  mxf_tc = (MXFTimecodeComponent*)component;
2644  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2645  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2646  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2647  }
2648  }
2649 
2650  if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2651  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2652  continue;
2653  }
2654 
2655  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2656  component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2657  if (!component)
2658  continue;
2659 
2660  mxf_tc = (MXFTimecodeComponent*)component;
2661  flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2662  if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2663  mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2664  break;
2665  }
2666  }
2667 
2668  /* TODO: handle multiple source clips, only finds first valid source clip */
2669  if(material_track->sequence->structural_components_count > 1)
2670  av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2671  material_track->track_id, material_track->sequence->structural_components_count);
2672 
2673  for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2674  component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2675  if (!component)
2676  continue;
2677 
2678  source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2679  if (!source_package) {
2680  av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2681  continue;
2682  }
2683  for (k = 0; k < source_package->tracks_count; k++) {
2684  if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2685  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2686  ret = AVERROR_INVALIDDATA;
2687  goto fail_and_free;
2688  }
2689  if (temp_track->track_id == component->source_track_id) {
2690  source_track = temp_track;
2691  break;
2692  }
2693  }
2694  if (!source_track) {
2695  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2696  break;
2697  }
2698 
2699  for (k = 0; k < mxf->essence_container_data_count; k++) {
2700  MXFEssenceContainerData *essence_data;
2701 
2702  if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2703  av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2704  continue;
2705  }
2706  if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2707  source_track->body_sid = essence_data->body_sid;
2708  source_track->index_sid = essence_data->index_sid;
2709  break;
2710  }
2711  }
2712 
2713  if(source_track && component)
2714  break;
2715  }
2716  if (!source_track || !component || !source_package) {
2717  if((ret = mxf_add_metadata_stream(mxf, material_track)))
2718  goto fail_and_free;
2719  continue;
2720  }
2721 
2722  if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2723  av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2724  ret = AVERROR_INVALIDDATA;
2725  goto fail_and_free;
2726  }
2727 
2728  /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2729  * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2730  if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2731  av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2732  continue;
2733  }
2734 
2735  st = avformat_new_stream(mxf->fc, NULL);
2736  if (!st) {
2737  av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2738  ret = AVERROR(ENOMEM);
2739  goto fail_and_free;
2740  }
2741  sti = ffstream(st);
2742  st->id = material_track->track_id;
2743  st->priv_data = source_track;
2744 
2745  descriptor = mxf_resolve_descriptor(mxf, &source_package->descriptor_ref, source_track->track_id);
2746 
2747  /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2748  * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2749  if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2750  source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2751  else
2752  source_track->original_duration = st->duration = component->duration;
2753 
2754  if (st->duration == -1)
2755  st->duration = AV_NOPTS_VALUE;
2756  st->start_time = component->start_position;
2757  if (material_track->edit_rate.num <= 0 ||
2758  material_track->edit_rate.den <= 0) {
2759  av_log(mxf->fc, AV_LOG_WARNING,
2760  "Invalid edit rate (%d/%d) found on stream #%d, "
2761  "defaulting to 25/1\n",
2762  material_track->edit_rate.num,
2763  material_track->edit_rate.den, st->index);
2764  material_track->edit_rate = (AVRational){25, 1};
2765  }
2766  avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2767 
2768  /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2769  * the former is accessible via st->priv_data */
2770  source_track->edit_rate = material_track->edit_rate;
2771 
2772  PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2773  codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2774  st->codecpar->codec_type = codec_ul->id;
2775 
2776  if (!descriptor) {
2777  av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2778  continue;
2779  }
2780  PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2781  PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2782  essence_container_ul = &descriptor->essence_container_ul;
2783  source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2784  if (source_track->wrapping == UnknownWrapped)
2785  av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2786  /* HACK: replacing the original key with mxf_encrypted_essence_container
2787  * is not allowed according to s429-6, try to find correct information anyway */
2788  if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2789  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[CryptoContext];
2790  av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2791  if (mg->metadata_sets_count) {
2792  MXFMetadataSet *metadata = mg->metadata_sets[0];
2793  essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2794  }
2795  }
2796 
2797  /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2798  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2799  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2800  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2801  codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2802  st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2803  }
2804 
2805  av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2806  avcodec_get_name(st->codecpar->codec_id));
2807  for (k = 0; k < 16; k++) {
2808  av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2809  descriptor->essence_codec_ul[k]);
2810  if (!(k+1 & 19) || k == 5)
2811  av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2812  }
2813  av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2814 
2815  mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2816  if (source_package->name && source_package->name[0])
2817  av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2818  if (material_track->name && material_track->name[0])
2819  av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2820 
2821  mxf_parse_physical_source_package(mxf, source_track, st);
2822 
2823  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2824  source_track->intra_only = mxf_is_intra_only(descriptor);
2825  container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2826  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2827  st->codecpar->codec_id = container_ul->id;
2828  st->codecpar->width = descriptor->width;
2829  st->codecpar->height = descriptor->height; /* Field height, not frame height */
2830  switch (descriptor->frame_layout) {
2831  case FullFrame:
2832  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2833  break;
2834  case OneField:
2835  /* Every other line is stored and needs to be duplicated. */
2836  av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2837  break; /* The correct thing to do here is fall through, but by breaking we might be
2838  able to decode some streams at half the vertical resolution, rather than not al all.
2839  It's also for compatibility with the old behavior. */
2840  case MixedFields:
2841  break;
2842  case SegmentedFrame:
2843  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2844  case SeparateFields:
2845  av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2846  descriptor->video_line_map[0], descriptor->video_line_map[1],
2847  descriptor->field_dominance);
2848  if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2849  /* Detect coded field order from VideoLineMap:
2850  * (even, even) => bottom field coded first
2851  * (even, odd) => top field coded first
2852  * (odd, even) => top field coded first
2853  * (odd, odd) => bottom field coded first
2854  */
2855  if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2856  switch (descriptor->field_dominance) {
2857  case MXF_FIELD_DOMINANCE_DEFAULT:
2858  case MXF_FIELD_DOMINANCE_FF:
2859  st->codecpar->field_order = AV_FIELD_TT;
2860  break;
2861  case MXF_FIELD_DOMINANCE_FL:
2862  st->codecpar->field_order = AV_FIELD_TB;
2863  break;
2864  default:
2865  avpriv_request_sample(mxf->fc,
2866  "Field dominance %d support",
2867  descriptor->field_dominance);
2868  }
2869  } else {
2870  switch (descriptor->field_dominance) {
2871  case MXF_FIELD_DOMINANCE_DEFAULT:
2872  case MXF_FIELD_DOMINANCE_FF:
2873  st->codecpar->field_order = AV_FIELD_BB;
2874  break;
2875  case MXF_FIELD_DOMINANCE_FL:
2876  st->codecpar->field_order = AV_FIELD_BT;
2877  break;
2878  default:
2879  avpriv_request_sample(mxf->fc,
2880  "Field dominance %d support",
2881  descriptor->field_dominance);
2882  }
2883  }
2884  }
2885  /* Turn field height into frame height. */
2886  st->codecpar->height *= 2;
2887  break;
2888  default:
2889  av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2890  }
2891 
2892  if (mxf_is_st_422(essence_container_ul)) {
2893  switch ((*essence_container_ul)[14]) {
2894  case 2: /* Cn: Clip- wrapped Picture Element */
2895  case 3: /* I1: Interlaced Frame, 1 field/KLV */
2896  case 4: /* I2: Interlaced Frame, 2 fields/KLV */
2897  case 6: /* P1: Frame- wrapped Picture Element */
2898  st->avg_frame_rate = source_track->edit_rate;
2899  st->r_frame_rate = st->avg_frame_rate;
2900  break;
2901  case 5: /* F1: Field-wrapped Picture Element */
2902  st->avg_frame_rate = av_mul_q(av_make_q(2, 1), source_track->edit_rate);
2903  st->r_frame_rate = st->avg_frame_rate;
2904  break;
2905  default:
2906  break;
2907  }
2908  }
2909 
2910  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2911  switch (descriptor->essence_codec_ul[14]) {
2912  case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2913  case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2914  case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2915  case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2916  case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2917  case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2918  }
2919  }
2920 
2921  if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2922  st->codecpar->format = descriptor->pix_fmt;
2923  if (st->codecpar->format == AV_PIX_FMT_NONE) {
2924  pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2925  &descriptor->essence_codec_ul);
2926  st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2927  if (st->codecpar->format== AV_PIX_FMT_NONE) {
2928  st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2929  &descriptor->essence_codec_ul)->id;
2930  if (!st->codecpar->codec_tag) {
2931  /* support files created before RP224v10 by defaulting to UYVY422
2932  if subsampling is 4:2:2 and component depth is 8-bit */
2933  if (descriptor->horiz_subsampling == 2 &&
2934  descriptor->vert_subsampling == 1 &&
2935  descriptor->component_depth == 8) {
2936  st->codecpar->format = AV_PIX_FMT_UYVY422;
2937  }
2938  }
2939  }
2940  }
2941  }
2942  sti->need_parsing = AVSTREAM_PARSE_HEADERS;
2943  if (material_track->sequence->origin) {
2944  av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2945  }
2946  if (source_track->sequence->origin) {
2947  av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2948  }
2949  if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2950  sti->display_aspect_ratio = descriptor->aspect_ratio;
2951  st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2952  st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2953  st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2954  st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2955  if (descriptor->mastering) {
2956  if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
2957  AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2958  (uint8_t *)descriptor->mastering, sizeof(*descriptor->mastering), 0)) {
2959  ret = AVERROR(ENOMEM);
2960  goto fail_and_free;
2961  }
2962  descriptor->mastering = NULL;
2963  }
2964  if (descriptor->coll) {
2965  if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
2966  AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2967  (uint8_t *)descriptor->coll, descriptor->coll_size, 0)) {
2968  ret = AVERROR(ENOMEM);
2969  goto fail_and_free;
2970  }
2971  descriptor->coll = NULL;
2972  }
2973  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2974  container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2975  /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2976  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))
2977  st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2978  st->codecpar->ch_layout.nb_channels = descriptor->channels;
2979 
2980  if (descriptor->sample_rate.den > 0) {
2981  st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2982  avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2983  } else {
2984  av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2985  "found for stream #%d, time base forced to 1/48000\n",
2986  descriptor->sample_rate.num, descriptor->sample_rate.den,
2987  st->index);
2988  avpriv_set_pts_info(st, 64, 1, 48000);
2989  }
2990 
2991  /* if duration is set, rescale it from EditRate to SampleRate */
2992  if (st->duration != AV_NOPTS_VALUE)
2993  st->duration = av_rescale_q(st->duration,
2994  av_inv_q(material_track->edit_rate),
2995  st->time_base);
2996 
2997  /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2998  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2999  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3000  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
3001  else if (descriptor->bits_per_sample == 32)
3002  st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
3003  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
3004  if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3005  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
3006  else if (descriptor->bits_per_sample == 32)
3007  st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
3008  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
3009  sti->need_parsing = AVSTREAM_PARSE_FULL;
3010  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
3011  sti->need_parsing = AVSTREAM_PARSE_FULL;
3012  }
3013  st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
3014 
3015  if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
3016  av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
3017  return AVERROR_INVALIDDATA;
3018  }
3019 
3020  ret = parse_mca_labels(mxf, source_track, descriptor, st);
3021  if (ret < 0)
3022  return ret;
3023  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
3024  enum AVMediaType type;
3025  container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
3026  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
3027  st->codecpar->codec_id = container_ul->id;
3028  type = avcodec_get_type(st->codecpar->codec_id);
3029  if (type == AVMEDIA_TYPE_SUBTITLE)
3030  st->codecpar->codec_type = type;
3031  if (container_ul->desc)
3032  av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
3033  if (mxf->eia608_extract &&
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 
3823  while (b - a > 1) {
3824  m = (a + b) >> 1;
3825  if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3826  return -1;
3827  if (offset < current_offset)
3828  a = m;
3829  else
3830  b = m;
3831  }
3832 
3833  *edit_unit_out = b;
3834 
3835  return 0;
3836 }
3837 
3838 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3839  int64_t edit_unit)
3840 {
3841  MXFTrack *track = st->priv_data;
3842  AVRational time_base = av_inv_q(track->edit_rate);
3843  AVRational sample_rate = av_inv_q(st->time_base);
3844 
3845  // For non-audio sample_count equals current edit unit
3846  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3847  return edit_unit;
3848 
3849  if ((sample_rate.num / sample_rate.den) == 48000) {
3850  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3851  } else {
3852  int64_t remainder = (sample_rate.num * (int64_t) time_base.num) %
3853  ( time_base.den * (int64_t)sample_rate.den);
3854  if (remainder)
3855  av_log(mxf->fc, AV_LOG_WARNING,
3856  "seeking detected on stream #%d with time base (%d/%d) and "
3857  "sample rate (%d/%d), audio pts won't be accurate.\n",
3858  st->index, time_base.num, time_base.den,
3859  sample_rate.num, sample_rate.den);
3860  return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3861  }
3862 }
3863 
3864 /**
3865  * Make sure track->sample_count is correct based on what offset we're currently at.
3866  * Also determine the next edit unit (or packet) offset.
3867  * @return next_ofs if OK, <0 on error
3868  */
3869 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3870 {
3871  int64_t next_ofs = -1;
3872  MXFTrack *track = st->priv_data;
3873  int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3874  int64_t new_edit_unit;
3875  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3876 
3877  if (!t || track->wrapping == UnknownWrapped)
3878  return -1;
3879 
3880  if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3881  (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3882  av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3883  return -1;
3884  }
3885 
3886  /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3887  if (next_ofs > current_offset)
3888  return next_ofs;
3889 
3890  if (!resync) {
3891  av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3892  return -1;
3893  }
3894 
3895  if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3896  av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3897  return -1;
3898  }
3899 
3900  new_edit_unit--;
3901  track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3902  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);
3903 
3904  return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3905 }
3906 
3907 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3908  AVPacket *pkt)
3909 {
3910  AVStream *st = mxf->fc->streams[pkt->stream_index];
3911  MXFTrack *track = st->priv_data;
3912  int64_t bits_per_sample = par->bits_per_coded_sample;
3913 
3914  if (!bits_per_sample)
3915  bits_per_sample = av_get_bits_per_sample(par->codec_id);
3916 
3917  pkt->pts = track->sample_count;
3918 
3919  if (par->ch_layout.nb_channels <= 0 ||
3920  bits_per_sample <= 0 ||
3921  par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
3922  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);
3923  else
3924  track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
3925 
3926  return 0;
3927 }
3928 
3929 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3930 {
3931  AVCodecParameters *par = st->codecpar;
3932  MXFTrack *track = st->priv_data;
3933 
3934  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3935  /* see if we have an index table to derive timestamps from */
3936  MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3937 
3938  if (t && track->sample_count < t->nb_ptses) {
3939  pkt->dts = track->sample_count + t->first_dts;
3940  pkt->pts = t->ptses[track->sample_count];
3941  } else if (track->intra_only) {
3942  /* intra-only -> PTS = EditUnit.
3943  * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3944  pkt->pts = track->sample_count;
3945  }
3946  track->sample_count++;
3947  } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3948  int ret = mxf_set_audio_pts(mxf, par, pkt);
3949  if (ret < 0)
3950  return ret;
3951  } else if (track) {
3952  pkt->dts = pkt->pts = track->sample_count;
3953  pkt->duration = 1;
3954  track->sample_count++;
3955  }
3956  return 0;
3957 }
3958 
3959 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3960 {
3961  KLVPacket klv;
3962  MXFContext *mxf = s->priv_data;
3963  int ret;
3964 
3965  while (1) {
3966  int64_t max_data_size;
3967  int64_t pos = avio_tell(s->pb);
3968 
3969  if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3970  mxf->current_klv_data = (KLVPacket){{0}};
3971  ret = klv_read_packet(mxf, &klv, s->pb);
3972  if (ret < 0)
3973  break;
3974  max_data_size = klv.length;
3975  pos = klv.next_klv - klv.length;
3976  PRINT_KEY(s, "read packet", klv.key);
3977  av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3978  if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key))) {
3979  ret = mxf_decrypt_triplet(s, pkt, &klv);
3980  if (ret < 0) {
3981  av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3982  return ret;
3983  }
3984  return 0;
3985  }
3986  } else {
3987  klv = mxf->current_klv_data;
3988  max_data_size = klv.next_klv - pos;
3989  }
3990  if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3991  IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3992  IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3993  int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3994  int index = mxf_get_stream_index(s, &klv, body_sid);
3995  int64_t next_ofs;
3996  AVStream *st;
3997  MXFTrack *track;
3998 
3999  if (index < 0) {
4000  av_log(s, AV_LOG_ERROR,
4001  "error getting stream index %"PRIu32"\n",
4002  AV_RB32(klv.key + 12));
4003  goto skip;
4004  }
4005 
4006  st = s->streams[index];
4007  track = st->priv_data;
4008 
4009  if (s->streams[index]->discard == AVDISCARD_ALL)
4010  goto skip;
4011 
4012  next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
4013 
4014  if (track->wrapping != FrameWrapped) {
4015  int64_t size;
4016 
4017  if (next_ofs <= 0) {
4018  // If we have no way to packetize the data, then return it in chunks...
4019  if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
4020  ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
4021  avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
4022  }
4023  size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
4024  } else {
4025  if ((size = next_ofs - pos) <= 0) {
4026  av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
4027  mxf->current_klv_data = (KLVPacket){{0}};
4028  return AVERROR_INVALIDDATA;
4029  }
4030  // We must not overread, because the next edit unit might be in another KLV
4031  if (size > max_data_size)
4032  size = max_data_size;
4033  }
4034 
4035  mxf->current_klv_data = klv;
4036  klv.offset = pos;
4037  klv.length = size;
4038  klv.next_klv = klv.offset + klv.length;
4039  }
4040 
4041  /* check for 8 channels AES3 element */
4042  if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
4043  ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
4044  pkt, klv.length);
4045  if (ret < 0) {
4046  av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
4047  mxf->current_klv_data = (KLVPacket){{0}};
4048  return ret;
4049  }
4050  } else if (mxf->eia608_extract &&
4051  s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4052  ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4053  if (ret < 0) {
4054  mxf->current_klv_data = (KLVPacket){{0}};
4055  return ret;
4056  }
4057  } else {
4058  ret = av_get_packet(s->pb, pkt, klv.length);
4059  if (ret < 0) {
4060  mxf->current_klv_data = (KLVPacket){{0}};
4061  return ret;
4062  }
4063  }
4064  pkt->stream_index = index;
4065  pkt->pos = klv.offset;
4066 
4067  ret = mxf_set_pts(mxf, st, pkt);
4068  if (ret < 0) {
4069  mxf->current_klv_data = (KLVPacket){{0}};
4070  return ret;
4071  }
4072 
4073  /* seek for truncated packets */
4074  avio_seek(s->pb, klv.next_klv, SEEK_SET);
4075 
4076  return 0;
4077  } else {
4078  skip:
4079  avio_skip(s->pb, max_data_size);
4080  mxf->current_klv_data = (KLVPacket){{0}};
4081  }
4082  }
4083  return avio_feof(s->pb) ? AVERROR_EOF : ret;
4084 }
4085 
4086 static int mxf_read_close(AVFormatContext *s)
4087 {
4088  MXFContext *mxf = s->priv_data;
4089  int i;
4090 
4091  av_freep(&mxf->packages_refs);
4092  av_freep(&mxf->essence_container_data_refs);
4093 
4094  for (i = 0; i < s->nb_streams; i++)
4095  s->streams[i]->priv_data = NULL;
4096 
4097  for (int type = 0; type < FF_ARRAY_ELEMS(mxf->metadata_set_groups); type++) {
4098  MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
4099  for (i = 0; i < mg->metadata_sets_count; i++)
4100  mxf_free_metadataset(mg->metadata_sets + i, type);
4101  mg->metadata_sets_count = 0;
4102  av_freep(&mg->metadata_sets);
4103  }
4104  av_freep(&mxf->partitions);
4105  av_freep(&mxf->aesc);
4106  av_freep(&mxf->local_tags);
4107 
4108  if (mxf->index_tables) {
4109  for (i = 0; i < mxf->nb_index_tables; i++) {
4110  av_freep(&mxf->index_tables[i].segments);
4111  av_freep(&mxf->index_tables[i].ptses);
4112  av_freep(&mxf->index_tables[i].fake_index);
4113  av_freep(&mxf->index_tables[i].offsets);
4114  }
4115  }
4116  av_freep(&mxf->index_tables);
4117 
4118  return 0;
4119 }
4120 
4121 static int mxf_probe(const AVProbeData *p) {
4122  const uint8_t *bufp = p->buf;
4123  const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4124 
4125  if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4126  return 0;
4127 
4128  /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4129  end -= sizeof(mxf_header_partition_pack_key);
4130 
4131  for (; bufp < end;) {
4132  if (!((bufp[13] - 1) & 0xF2)){
4133  if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4134  AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4135  AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4136  AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
4137  return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4138  bufp ++;
4139  } else
4140  bufp += 10;
4141  }
4142 
4143  return 0;
4144 }
4145 
4146 /* rudimentary byte seek */
4147 /* XXX: use MXF Index */
4148 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4149 {
4150  AVStream *st = s->streams[stream_index];
4151  int64_t seconds;
4152  MXFContext* mxf = s->priv_data;
4153  int64_t seekpos;
4154  int i, ret;
4155  MXFIndexTable *t;
4156  MXFTrack *source_track = st->priv_data;
4157 
4158  if (!source_track)
4159  return 0;
4160 
4161  /* if audio then truncate sample_time to EditRate */
4162  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4163  sample_time = av_rescale_q(sample_time, st->time_base,
4164  av_inv_q(source_track->edit_rate));
4165 
4166  if (mxf->nb_index_tables <= 0) {
4167  if (!s->bit_rate)
4168  return AVERROR_INVALIDDATA;
4169  if (sample_time < 0)
4170  sample_time = 0;
4171  seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4172 
4173  seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4174  if (seekpos < 0)
4175  return seekpos;
4176 
4177  avpriv_update_cur_dts(s, st, sample_time);
4178  mxf->current_klv_data = (KLVPacket){{0}};
4179  } else {
4180  MXFPartition *partition;
4181 
4182  t = &mxf->index_tables[0];
4183  if (t->index_sid != source_track->index_sid) {
4184  /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
4185  for (i = 0; i < s->nb_streams; i++) {
4186  MXFTrack *new_source_track = s->streams[i]->priv_data;
4187  if (new_source_track && new_source_track->index_sid == t->index_sid) {
4188  sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
4189  source_track = new_source_track;
4190  st = s->streams[i];
4191  break;
4192  }
4193  }
4194  if (i == s->nb_streams)
4195  return AVERROR_INVALIDDATA;
4196  }
4197 
4198  /* clamp above zero, else ff_index_search_timestamp() returns negative
4199  * this also means we allow seeking before the start */
4200  sample_time = FFMAX(sample_time, 0);
4201 
4202  if (t->fake_index) {
4203  /* The first frames may not be keyframes in presentation order, so
4204  * we have to advance the target to be able to find the first
4205  * keyframe backwards... */
4206  if (!(flags & AVSEEK_FLAG_ANY) &&
4207  (flags & AVSEEK_FLAG_BACKWARD) &&
4208  t->ptses[0] != AV_NOPTS_VALUE &&
4209  sample_time < t->ptses[0] &&
4210  (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
4211  sample_time = t->ptses[0];
4212 
4213  /* behave as if we have a proper index */
4214  if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
4215  return sample_time;
4216  /* get the stored order index from the display order index */
4217  sample_time += t->offsets[sample_time];
4218  } else {
4219  /* no IndexEntryArray (one or more CBR segments)
4220  * make sure we don't seek past the end */
4221  sample_time = FFMIN(sample_time, source_track->original_duration - 1);
4222  }
4223 
4224  if (source_track->wrapping == UnknownWrapped)
4225  av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
4226 
4227  if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
4228  return ret;
4229 
4230  avpriv_update_cur_dts(s, st, sample_time);
4231  if (source_track->wrapping == ClipWrapped) {
4232  KLVPacket klv = partition->first_essence_klv;
4233  if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
4234  av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
4235  return AVERROR_INVALIDDATA;
4236  }
4237  mxf->current_klv_data = klv;
4238  } else {
4239  mxf->current_klv_data = (KLVPacket){{0}};
4240  }
4241  avio_seek(s->pb, seekpos, SEEK_SET);
4242  }
4243 
4244  // Update all tracks sample count
4245  for (i = 0; i < s->nb_streams; i++) {
4246  AVStream *cur_st = s->streams[i];
4247  MXFTrack *cur_track = cur_st->priv_data;
4248  if (cur_track) {
4249  int64_t track_edit_unit = sample_time;
4250  if (st != cur_st)
4251  mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
4252  cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
4253  }
4254  }
4255  return 0;
4256 }
4257 
4258 static const AVOption options[] = {
4259  { "eia608_extract", "extract eia 608 captions from s436m track",
4260  offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
4261  AV_OPT_FLAG_DECODING_PARAM },
4262  { NULL },
4263 };
4264 
4265 static const AVClass demuxer_class = {
4266  .class_name = "mxf",
4267  .item_name = av_default_item_name,
4268  .option = options,
4269  .version = LIBAVUTIL_VERSION_INT,
4270  .category = AV_CLASS_CATEGORY_DEMUXER,
4271 };
4272 
4273 const FFInputFormat ff_mxf_demuxer = {
4274  .p.name = "mxf",
4275  .p.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
4276  .p.flags = AVFMT_SEEK_TO_PTS,
4277  .p.priv_class = &demuxer_class,
4278  .priv_data_size = sizeof(MXFContext),
4279  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
4280  .read_probe = mxf_probe,
4281  .read_header = mxf_read_header,
4282  .read_packet = mxf_read_packet,
4283  .read_close = mxf_read_close,
4284  .read_seek = mxf_read_seek,
4285 };
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:1308
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:560
MXFMetadataSet::uid
UID uid
Definition: mxfdec.c:118
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
OPSONYOpt
@ OPSONYOpt
Definition: mxfdec.c:90
MXFContext::op
MXFOP op
Definition: mxfdec.c:303
MXFIndexTable::offsets
int8_t * offsets
Definition: mxfdec.c:296
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:950
mxf_sub_descriptor
static const uint8_t mxf_sub_descriptor[]
Definition: mxfdec.c:367
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:308
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:1082
av_clip
#define av_clip
Definition: common.h:99
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:3907
mxf_add_timecode_metadata
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
Definition: mxfdec.c:2216
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:2422
opt.h
mxf_ffv1_extradata
static const uint8_t mxf_ffv1_extradata[]
Definition: mxfdec.c:350
OPAtom
@ OPAtom
Definition: mxfdec.c:89
Track
Definition: ismindex.c:70
mxf_read_sequence
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1134
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
MXFTrack::edit_rate
AVRational edit_rate
Definition: mxfdec.c:184
AV_PROFILE_JPEG2000_DCINEMA_4K
#define AV_PROFILE_JPEG2000_DCINEMA_4K
Definition: defs.h:151
OP2b
@ OP2b
Definition: mxfdec.c:84
FF_MXF_MasteringDisplayMinimumLuminance
#define FF_MXF_MasteringDisplayMinimumLuminance
Definition: mxf.h:100
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
MXFContext::index_tables
MXFIndexTable * index_tables
Definition: mxfdec.c:321
mxf_parse_package_comments
static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
Definition: mxfdec.c:2314
MXFPartition::complete
int complete
Definition: mxfdec.c:101
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVStream::priv_data
void * priv_data
Definition: avformat.h: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:3759
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:4273
MXFMCASubDescriptor::soundfield_group_link_id
UID soundfield_group_link_id
Definition: mxfdec.c:238
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AV_AUDIO_SERVICE_TYPE_NB
@ AV_AUDIO_SERVICE_TYPE_NB
Not part of ABI.
Definition: defs.h: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
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:697
mxf_read_us_ascii_string
static int mxf_read_us_ascii_string(AVIOContext *pb, int size, char **str)
Definition: mxfdec.c:986
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
mxf_intra_only_picture_coded_width
static const MXFCodecUL mxf_intra_only_picture_coded_width[]
Definition: mxfdec.c:1630
avlanguage.h
AVChannelLayout::map
AVChannelCustom * map
This member must be used when the channel order is AV_CHANNEL_ORDER_CUSTOM.
Definition: channel_layout.h:354
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
MXFPartition::kag_size
int32_t kag_size
Definition: mxfdec.c:108
dict_internal.h
MXFPartition::type
MXFPartitionType type
Definition: mxfdec.c:102
OP3b
@ OP3b
Definition: mxfdec.c:87
FF_MXF_MasteringDisplayPrimaries
#define FF_MXF_MasteringDisplayPrimaries
Definition: mxf.h:97
KLVPacket::offset
int64_t offset
Definition: mxf.h:76
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:358
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
avio_get_str16be
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
KLVPacket::key
UID key
Definition: mxf.h:75
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:375
mxf_indirect_value_utf16be
static const uint8_t mxf_indirect_value_utf16be[]
Definition: mxfdec.c:354
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
MXFStructuralComponent::source_track_id
int source_track_id
Definition: mxfdec.c:139
MXFEssenceContainerData::package_ul
UID package_ul
Definition: mxfdec.c:281
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:524
SourceClip
@ SourceClip
Definition: mxf.h:35
MXFWrappingScheme
MXFWrappingScheme
Definition: mxfdec.c:93
mxf_read_pixel_layout
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
Definition: mxfdec.c:1288
AVOption
AVOption.
Definition: opt.h:357
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:1581
MXFTrack::index_sid
int index_sid
Definition: mxfdec.c:188
MXFMCASubDescriptor::language
char * language
Definition: mxfdec.c:243
mxf_data_essence_container_uls
static const MXFCodecUL mxf_data_essence_container_uls[]
Definition: mxfdec.c:1651
MXFDescriptor::video_line_map
int video_line_map[2]
Definition: mxfdec.c:204
MXFDescriptor::field_dominance
int field_dominance
Definition: mxfdec.c:208
mxf_set_pts
static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
Definition: mxfdec.c:3929
MXFContext::packages_refs
UID * packages_refs
Definition: mxfdec.c:304
MXFStructuralComponent::source_package_uid
UID source_package_uid
Definition: mxfdec.c:135
MXFPartition
Definition: mxfdec.c:99
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
OP1a
@ OP1a
Definition: mxfdec.c:80
mxf_read_content_storage
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1046
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
MXFMetadataSet
Definition: mxfdec.c:117
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
mxf_read_track
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1110
mxf_intra_only_essence_container_uls
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition: mxfdec.c:1617
MXFPartition::pack_length
int pack_length
Definition: mxfdec.c:111
MXFMCASubDescriptor::meta
MXFMetadataSet meta
Definition: mxfdec.c:235
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:261
MXFContext::current_klv_data
KLVPacket current_klv_data
Definition: mxfdec.c:314
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:280
MXFDescriptor::black_ref_level
unsigned int black_ref_level
Definition: mxfdec.c:213
MXFDescriptor::essence_container_ul
UID essence_container_ul
Definition: mxfdec.c:196
MXFPulldownComponent
Definition: mxfdec.c:159
mxf_resolve_descriptor
static MXFDescriptor * mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
Definition: mxfdec.c:2256
MXFIndexTableSegment::index_edit_rate
AVRational index_edit_rate
Definition: mxfdec.c:257
MXFDescriptor::essence_codec_ul
UID essence_codec_ul
Definition: mxfdec.c:197
MXFIndexTableSegment::index_duration
uint64_t index_duration
Definition: mxfdec.c:259
mxf_read_mca_sub_descriptor
static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1483
mxf_free_metadataset
static void mxf_free_metadataset(MXFMetadataSet **ctx, enum MXFMetadataSetType type)
Definition: mxfdec.c:379
MXFDescriptor::file_descriptors_count
int file_descriptors_count
Definition: mxfdec.c:219
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
mxf_header_partition_pack_key
static const uint8_t mxf_header_partition_pack_key[]
Definition: mxfdec.c:336
Footer
@ Footer
Definition: mxfdec.c:76
MXFPackage::comment_refs
UID * comment_refs
Definition: mxfdec.c:274
MXFContext
Definition: mxfdec.c:299
MXFTrack::sequence_ref
UID sequence_ref
Definition: mxfdec.c:180
ff_mxf_color_trc_uls
const MXFCodecUL ff_mxf_color_trc_uls[]
Definition: mxf.c:112
mxf_parse_structural_metadata
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition: mxfdec.c:2600
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
TimecodeComponent
@ TimecodeComponent
Definition: mxf.h:36
MXFDescriptor::color_range
unsigned int color_range
Definition: mxfdec.c:215
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
avpriv_update_cur_dts
void avpriv_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: seek.c:36
FF_MXF_MasteringDisplay_PREFIX
#define FF_MXF_MasteringDisplay_PREFIX
Definition: mxf.h:96
SeparateFields
@ SeparateFields
Definition: mxf.h:63
AVIndexEntry
Definition: avformat.h:602
AudioChannelLabelSubDescriptor
@ AudioChannelLabelSubDescriptor
Definition: mxf.h:53
MXFCryptoContext::source_container_ul
UID source_container_ul
Definition: mxfdec.c:129
MXFDescriptor::width
int width
Definition: mxfdec.c:201
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:204
ff_mxf_codec_tag_uls
const MXFCodecUL ff_mxf_codec_tag_uls[]
Definition: mxf.c:92
MXFEssenceGroup
Definition: mxfdec.c:164
ff_generate_avci_extradata
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition: demux_utils.c:200
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
READ_STR16
#define READ_STR16(type, big_endian)
Definition: mxfdec.c:1037
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:73
mxf_read_essence_group
static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1154
mxf_group_of_soundfield_groups_link_id
static const uint8_t mxf_group_of_soundfield_groups_link_id[]
Definition: mxfdec.c:361
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:201
MXFEssenceContainerData::meta
MXFMetadataSet meta
Definition: mxfdec.c:279
MXFIndexTableSegment::nb_index_entries
int nb_index_entries
Definition: mxfdec.c:263
MXFTrack::edit_units_per_packet
int edit_units_per_packet
Definition: mxfdec.c:191
mxf.h
mxf_set_current_edit_unit
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
Make sure track->sample_count is correct based on what offset we're currently at.
Definition: mxfdec.c:3869
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:356
MXFPartition::closed
int closed
Definition: mxfdec.c:100
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:2447
mxf_mca_rfc5646_spoken_language
static const uint8_t mxf_mca_rfc5646_spoken_language[]
Definition: mxfdec.c:365
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
MXFDescriptor::channels
int channels
Definition: mxfdec.c:209
timecode.h
mxf_get_next_track_edit_unit
static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
Definition: mxfdec.c:3812
MXFDescriptor::coll_size
size_t coll_size
Definition: mxfdec.c:231
mxf_read_random_index_pack
static void mxf_read_random_index_pack(AVFormatContext *s)
Definition: mxfdec.c:3639
MXFCodecUL::id
int id
Definition: mxf.h:108
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:103
MXFMetadataReadTableEntry::key
const UID key
Definition: mxfdec.c:329
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:2498
MXFTrack::original_duration
int64_t original_duration
Definition: mxfdec.c:187
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
mxf_handle_missing_index_segment
static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
Definition: mxfdec.c:3572
MXFSequence::structural_components_refs
UID * structural_components_refs
Definition: mxfdec.c:145
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:77
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
av_timegm
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:570
MXFDescriptor::mastering
AVMasteringDisplayMetadata * mastering
Definition: mxfdec.c:229
MXFIndexTable::first_dts
int64_t first_dts
Definition: mxfdec.c:291
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:216
MXFChannelOrderingUL
Definition: mxfdec.c:1658
MXFPackage::meta
MXFMetadataSet meta
Definition: mxfdec.c:267
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:456
AVRational::num
int num
Numerator.
Definition: rational.h:59
mxf_absolute_bodysid_offset
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
Computes the absolute file offset of the given essence container offset.
Definition: mxfdec.c:1825
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:203
MXFTrack::meta
MXFMetadataSet meta
Definition: mxfdec.c:178
MXFContext::last_forward_partition
int last_forward_partition
Definition: mxfdec.c:319
AV_CHAN_STEREO_RIGHT
@ AV_CHAN_STEREO_RIGHT
See above.
Definition: channel_layout.h:71
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
mxf_version_to_str
static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary, uint16_t patch, uint16_t release, char **str)
Definition: mxfdec.c:2197
MXFDescriptor::frame_layout
int frame_layout
Definition: mxfdec.c:203
mxf_timestamp_to_int64
static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
Definition: mxfdec.c:3083
OneField
@ OneField
Definition: mxf.h:64
MXFDescriptor::linked_track_id
int linked_track_id
Definition: mxfdec.c:222
mxf_read_identification_metadata
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
Definition: mxfdec.c:3136
MXFPackage::tracks_refs
UID * tracks_refs
Definition: mxfdec.c:270
mxf_probe
static int mxf_probe(const AVProbeData *p)
Definition: mxfdec.c:4121
MXFMetadataReadTableEntry
Definition: mxfdec.c:328
AV_CHAN_BOTTOM_FRONT_LEFT
@ AV_CHAN_BOTTOM_FRONT_LEFT
Definition: channel_layout.h:80
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1490
MXFEssenceGroup::structural_components_count
int structural_components_count
Definition: mxfdec.c:167
mxf_metadata_read_table
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
Definition: mxfdec.c: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:1936
MXFIndexTableSegment
Definition: mxfdec.c:252
MXFIndexTable::nb_segments
int nb_segments
Definition: mxfdec.c:293
PRINT_KEY
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:155
MXFDescriptor::duration
int64_t duration
Definition: mxfdec.c:211
MXFPartition::index_byte_count
int64_t index_byte_count
Definition: mxfdec.c:110
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
mxf_read_preface_metadata
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c: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:221
mxf_mca_tag_symbol
static const uint8_t mxf_mca_tag_symbol[]
Definition: mxfdec.c:359
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:905
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:347
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:1508
MXFIndexTableSegment::index_sid
int index_sid
Definition: mxfdec.c:255
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
MXFMetadataSetType
MXFMetadataSetType
Definition: mxf.h:32
MultipleDescriptor
@ MultipleDescriptor
Definition: mxf.h:39
MXFFFV1SubDescriptor::extradata_size
int extradata_size
Definition: mxfdec.c:249
MXFTimecodeComponent::drop_frame
int drop_frame
Definition: mxfdec.c:153
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
MXFTrack::track_number
uint8_t track_number[4]
Definition: mxfdec.c:183
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
op
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:76
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h: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:312
MXFSequence
Definition: mxfdec.c:142
MXFDescriptor::sub_descriptors_count
int sub_descriptors_count
Definition: mxfdec.c:221
MXFPackage::package_uid
UID package_uid
Definition: mxfdec.c:268
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:28
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
MXFPartition::essence_offset
int64_t essence_offset
absolute offset of essence
Definition: mxfdec.c:106
UID
AVUUID UID
Definition: mxf.h:30
mxf_read_seek
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition: mxfdec.c:4148
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:376
mxf_indirect_value_utf16le
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfdec.c:353
CryptoContext
Definition: crypto.c:32
MXFStructuralComponent::meta
MXFMetadataSet meta
Definition: mxfdec.c:133
ctx
AVFormatContext * ctx
Definition: movenc.c:49
MXFCodecUL::matching_len
unsigned matching_len
Definition: mxf.h:107
MXFContext::packages_count
int packages_count
Definition: mxfdec.c:305
mxf_encrypted_essence_container
static const uint8_t mxf_encrypted_essence_container[]
Definition: mxfdec.c:348
MXFIndexTableSegment::body_sid
int body_sid
Definition: mxfdec.c:256
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
FFStream::display_aspect_ratio
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition: internal.h: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:519
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:318
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:226
mxf_apple_coll_max_cll
static const uint8_t mxf_apple_coll_max_cll[]
Definition: mxfdec.c:355
klv_decode_ber_length
static int64_t klv_decode_ber_length(AVIOContext *pb)
Definition: mxfdec.c:430
MXFTimecodeComponent
Definition: mxfdec.c:151
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
mxf_mca_label_dictionary_id
static const uint8_t mxf_mca_label_dictionary_id[]
Definition: mxfdec.c:358
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:58
MXFIndexTable::fake_index
AVIndexEntry * fake_index
Definition: mxfdec.c:295
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:230
arg
const char * arg
Definition: jacosubdec.c:67
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition: log.h:33
AV_CHAN_TOP_SIDE_RIGHT
@ AV_CHAN_TOP_SIDE_RIGHT
Definition: channel_layout.h:78
if
if(ret)
Definition: filter_design.txt:179
mxf_soundfield_group_link_id
static const uint8_t mxf_soundfield_group_link_id[]
Definition: mxfdec.c:364
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: demux.h:35
OP3c
@ OP3c
Definition: mxfdec.c:88
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
mxf_seek_to_previous_partition
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition and parses it, if possible.
Definition: mxfdec.c: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:1099
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:262
FF_MXF_MASTERING_LUMA_DEN
#define FF_MXF_MASTERING_LUMA_DEN
Definition: mxf.h:103
SegmentedFrame
@ SegmentedFrame
Definition: mxf.h:66
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
Descriptor
@ Descriptor
Definition: mxf.h:40
AV_LANG_ISO639_2_BIBL
@ AV_LANG_ISO639_2_BIBL
Definition: avlanguage.h:28
AVChannelLayout::u
union AVChannelLayout::@379 u
Details about which channels are present in this layout.
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2445
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:960
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
mxf_match_uid
static int mxf_match_uid(const UID key, const uint8_t uid_prefix[], int len)
Definition: mxfdec.c:1561
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h: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:131
MaterialPackage
@ MaterialPackage
Definition: mxf.h:33
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
MXFContext::eia608_extract
int eia608_extract
Definition: mxfdec.c:322
MXFChannelOrderingUL::uid
UID uid
Definition: mxfdec.c:1659
mxf_read_tagged_value
static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1545
mxf_edit_unit_absolute_offset
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
Definition: mxfdec.c:1886
index_table
static const uint8_t index_table[8]
Definition: siren.c:35
mxf_picture_essence_container_uls
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition: mxfdec.c:1594
MXFStructuralComponent::duration
int64_t duration
Definition: mxfdec.c:137
CryptoContext
@ CryptoContext
Definition: mxf.h:42
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
MXF_MAX_CHUNK_SIZE
#define MXF_MAX_CHUNK_SIZE
Definition: mxfdec.c:70
is_pcm
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:2466
MXFCryptoContext
Definition: mxfdec.c:127
FF_MXF_MASTERING_CHROMA_DEN
#define FF_MXF_MASTERING_CHROMA_DEN
Definition: mxf.h:102
AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
#define AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
The specified retype target order is ignored and the simplest possible (canonical) order is used for ...
Definition: channel_layout.h:692
mxf_avid_project_name
static const uint8_t mxf_avid_project_name[]
Definition: mxfdec.c:351
MXFDescriptor::color_space_ul
UID color_space_ul
Definition: mxfdec.c:228
AV_CHAN_TOP_BACK_CENTER
@ AV_CHAN_TOP_BACK_CENTER
Definition: channel_layout.h:66
FullFrame
@ FullFrame
Definition: mxf.h:62
AVIndexEntry::flags
int flags
Definition: avformat.h:612
OP3a
@ OP3a
Definition: mxfdec.c:86
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:908
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h: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:109
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
av_aes_alloc
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition: aes.c:35
MXFMCASubDescriptor::mca_channel_id
int mca_channel_id
Definition: mxfdec.c:242
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:200
AV_CHAN_TOP_CENTER
@ AV_CHAN_TOP_CENTER
Definition: channel_layout.h:61
MXFEssenceGroup::duration
int64_t duration
Definition: mxfdec.c:168
MXFTrack::sample_count
uint64_t sample_count
Definition: mxfdec.c:186
mxf_umid_to_str
static void mxf_umid_to_str(const UID ul, const UID uid, char str[2+sizeof(UID) *4+1])
Definition: mxfdec.c:2189
mxf_get_sorted_table_segments
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
Definition: mxfdec.c:1742
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
SET_UID_METADATA
#define SET_UID_METADATA(pb, name, var, str)
Definition: mxfdec.c:3123
MXFEssenceContainerData::index_sid
int index_sid
Definition: mxfdec.c:282
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MXFDescriptor::height
int height
Definition: mxfdec.c:202
mxf_is_partition_pack_key
static int mxf_is_partition_pack_key(UID key)
Matches any partition pack key, in other words:
Definition: mxfdec.c: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:237
mxf_parse_physical_source_package
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
Definition: mxfdec.c:2334
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
mxf_essence_container_end
static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
Returns the end position of the essence container with given BodySID, or zero if unknown.
Definition: mxfdec.c:1868
AV_CHAN_FRONT_RIGHT
@ AV_CHAN_FRONT_RIGHT
Definition: channel_layout.h:51
AV_CHAN_FRONT_CENTER
@ AV_CHAN_FRONT_CENTER
Definition: channel_layout.h:52
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1311
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
MXFMetadataSetGroup
Definition: mxfdec.c:122
mxf_read_essence_container_data
static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1192
mxf_read_indirect_value
static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
Definition: mxfdec.c:1527
EssenceGroup
@ EssenceGroup
Definition: mxf.h:49
FF_MXF_MasteringDisplayWhitePointChromaticity
#define FF_MXF_MasteringDisplayWhitePointChromaticity
Definition: mxf.h:98
MXFPartition::index_sid
int index_sid
Definition: mxfdec.c:104
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:340
MXFChannelOrderingUL::service_type
enum AVAudioServiceType service_type
Definition: mxfdec.c:1661
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:525
MXFEssenceContainerData::body_sid
int body_sid
Definition: mxfdec.c:283
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
set_language
static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
Definition: mxfdec.c:2472
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
Header
@ Header
Definition: mxfdec.c:74
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
FFStream
Definition: internal.h:193
mxf_mastering_display_uls
static const uint8_t mxf_mastering_display_uls[4][16]
Definition: mxfdec.c:370
MXFContext::nb_index_tables
int nb_index_tables
Definition: mxfdec.c:320
mxf_read_index_entry_array
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
Definition: mxfdec.c:1211
mxf_add_metadata_stream
static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
Definition: mxfdec.c:2404
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
ff_convert_lang_to
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:741
avio_get_str
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:866
sample
#define sample
Definition: flacdsp_template.c:44
MXF_FIELD_DOMINANCE_FF
#define MXF_FIELD_DOMINANCE_FF
Definition: mxfdec.c:206
AV_CHAN_LOW_FREQUENCY
@ AV_CHAN_LOW_FREQUENCY
Definition: channel_layout.h:53
size
int size
Definition: twinvq_data.h:10344
MXFTimecodeComponent::meta
MXFMetadataSet meta
Definition: mxfdec.c:152
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_CHAN_BACK_RIGHT
@ AV_CHAN_BACK_RIGHT
Definition: channel_layout.h:55
MXFMetadataReadTableEntry::ctx_size
int ctx_size
Definition: mxfdec.c:331
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
MXFDescriptor
Definition: mxfdec.c:194
AV_CHAN_SIDE_LEFT
@ AV_CHAN_SIDE_LEFT
Definition: channel_layout.h:59
OP2c
@ OP2c
Definition: mxfdec.c:85
MXFStructuralComponent::start_position
int64_t start_position
Definition: mxfdec.c:138
MXFPackage::comment_count
int comment_count
Definition: mxfdec.c:275
J2KWrap
@ J2KWrap
Definition: mxf.h:86
mxf_mca_link_id
static const uint8_t mxf_mca_link_id[]
Definition: mxfdec.c:362
MXFPartition::pack_ofs
int64_t pack_ofs
absolute offset of pack in file, including run-in
Definition: mxfdec.c:112
mxf_get_wrapping_kind
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
Definition: mxfdec.c:1704
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
MXFMetadataSetGroup::metadata_sets_count
int metadata_sets_count
Definition: mxfdec.c:124
MXFContext::partitions
MXFPartition * partitions
Definition: mxfdec.c:301
MXFDescriptor::file_descriptors_refs
UID * file_descriptors_refs
Definition: mxfdec.c:218
mxf_is_intra_only
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition: mxfdec.c:2181
mxf_read_sync
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition: mxfdec.c:447
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
MXFStructuralComponent::data_definition_ul
UID data_definition_ul
Definition: mxfdec.c:136
MXFIndexTable
Definition: mxfdec.c:287
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
MXFIndexTableSegment::edit_unit_byte_count
unsigned edit_unit_byte_count
Definition: mxfdec.c:254
av_channel_layout_retype
int av_channel_layout_retype(AVChannelLayout *channel_layout, enum AVChannelOrder order, int flags)
Change the AVChannelOrder of a channel layout.
Definition: channel_layout.c:877
mxf_compute_sample_count
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
Definition: mxfdec.c:3838
IndexTableSegment
@ IndexTableSegment
Definition: mxf.h:47
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: packet.c: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:258
AV_CHAN_TOP_FRONT_RIGHT
@ AV_CHAN_TOP_FRONT_RIGHT
Definition: channel_layout.h:64
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
MXFMCASubDescriptor
Definition: mxfdec.c:234
mxf_mca_channel_id
static const uint8_t mxf_mca_channel_id[]
Definition: mxfdec.c:363
mxf_add_umid_metadata
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
Definition: mxfdec.c:2206
AV_CHAN_FRONT_LEFT_OF_CENTER
@ AV_CHAN_FRONT_LEFT_OF_CENTER
Definition: channel_layout.h:56
MixedFields
@ MixedFields
Definition: mxf.h:65
MXFMetadataSet::partition_score
uint64_t partition_score
Definition: mxfdec.c:119
SET_STR_METADATA
#define SET_STR_METADATA(pb, name, str)
Definition: mxfdec.c:3106
mxf_get_codec_ul
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition: mxfdec.c:1571
MXFMCASubDescriptor::group_of_soundfield_groups_link_id_count
int group_of_soundfield_groups_link_id_count
Definition: mxfdec.c:240
MXFSequence::structural_components_count
int structural_components_count
Definition: mxfdec.c:146
MXFMetadataReadFunc
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:326
mxf_klv_key
static const uint8_t mxf_klv_key[]
Definition: mxfdec.c:342
MXFContext::partitions_count
unsigned partitions_count
Definition: mxfdec.c:302
mxf_read_packet
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfdec.c:3959
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
MXFDescriptor::bits_per_sample
int bits_per_sample
Definition: mxfdec.c:210
mxf_parse_handle_partition_or_eof
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
Definition: mxfdec.c: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:223
RUN_IN_MAX
#define RUN_IN_MAX
Definition: mxfdec.c:71
MXFIndexTable::nb_ptses
int nb_ptses
Definition: mxfdec.c:290
MXFMCASubDescriptor::uid
UID uid
Definition: mxfdec.c:236
mxf_system_item_key_cp
static const uint8_t mxf_system_item_key_cp[]
Definition: mxfdec.c:340
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:343
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
MXFContext::essence_container_data_count
int essence_container_data_count
Definition: mxfdec.c:307
MXFContext::parsing_backward
int parsing_backward
Definition: mxfdec.c:317
MXFChannelOrderingUL::channel
enum AVChannel channel
Definition: mxfdec.c:1660
MXFIndexTable::segments
MXFIndexTableSegment ** segments
Definition: mxfdec.c:294
container_ul
const UID container_ul
Definition: mxfenc.c:2335
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition: pixfmt.h:525
MXFIndexTableSegment::meta
MXFMetadataSet meta
Definition: mxfdec.c:253
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:1010
MXFStructuralComponent
Definition: mxfdec.c:132
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
MXF_FIELD_DOMINANCE_FL
#define MXF_FIELD_DOMINANCE_FL
Definition: mxfdec.c:207
mxf_resolve_source_package
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
Definition: mxfdec.c:2240
MXFTrack::body_sid
int body_sid
Definition: mxfdec.c:189
MXFDescriptor::sub_descriptors_refs
UID * sub_descriptors_refs
Definition: mxfdec.c:220
codec_ul
UID codec_ul
Definition: mxfenc.c:2228
MXFIndexTable::ptses
int64_t * ptses
Definition: mxfdec.c:292
AVCodecParameters::height
int height
Definition: codec_par.h:135
resync
static int resync(AVFormatContext *s)
Definition: flvdec.c:1053
AV_CODEC_ID_TTML
@ AV_CODEC_ID_TTML
Definition: codec_id.h:574
MXFContext::essence_container_data_refs
UID * essence_container_data_refs
Definition: mxfdec.c:306
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
MXFDescriptor::vert_subsampling
unsigned int vert_subsampling
Definition: mxfdec.c:217
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:202
MXF_FIELD_DOMINANCE_DEFAULT
#define MXF_FIELD_DOMINANCE_DEFAULT
Definition: mxfdec.c:205
MXFSequence::duration
int64_t duration
Definition: mxfdec.c:147
ff_mxf_pixel_format_uls
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition: mxf.c:86
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
mxf_read_source_clip
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:1060
MXFDescriptor::color_trc_ul
UID color_trc_ul
Definition: mxfdec.c:227
mxf_get_color_range
static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
Definition: mxfdec.c:2442
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
mxf_mca_tag_name
static const uint8_t mxf_mca_tag_name[]
Definition: mxfdec.c:360
MXFTrack::wrapping
MXFWrappingScheme wrapping
Definition: mxfdec.c:190
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:76
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:337
EssenceContainerData
@ EssenceContainerData
Definition: mxf.h:48
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition: defs.h: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:256
MXFEssenceGroup::structural_components_refs
UID * structural_components_refs
Definition: mxfdec.c:166
MXFPackage::tracks_count
int tracks_count
Definition: mxfdec.c:271
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:628
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
MXFTrack::name
char * name
Definition: mxfdec.c:182
MXFDescriptor::pix_fmt
enum AVPixelFormat pix_fmt
Definition: mxfdec.c:225
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
MXFTrack::track_id
int track_id
Definition: mxfdec.c:181
MXFStructuralComponent::source_package_ul
UID source_package_ul
Definition: mxfdec.c:134
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
AV_CHAN_STEREO_LEFT
@ AV_CHAN_STEREO_LEFT
Stereo downmix.
Definition: channel_layout.h:69
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
SET_VERSION_METADATA
#define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str)
Definition: mxfdec.c:3112
mxf_crypto_source_container_ul
static const uint8_t mxf_crypto_source_container_ul[]
Definition: mxfdec.c:346
MXFMCASubDescriptor::group_of_soundfield_groups_link_id_refs
UID * group_of_soundfield_groups_link_id_refs
Definition: mxfdec.c:239
MXFTrack::sequence
MXFSequence * sequence
Definition: mxfdec.c:179
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
MXFPackage
Definition: mxfdec.c:266
MXFMetadataReadTableEntry::type
enum MXFMetadataSetType type
Definition: mxfdec.c:332
MXFTrack
Definition: mxfdec.c:177
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:104
mxf_compute_index_tables
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
Definition: mxfdec.c:2068
mxf_resolve_timecode_component
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:2224
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:315
tag
uint32_t tag
Definition: movenc.c:1788
MXFTimecodeComponent::start_frame
int start_frame
Definition: mxfdec.c:154
MXFPartition::essence_length
int64_t essence_length
Definition: mxfdec.c:107
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h: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:128
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
MXFEssenceContainerData
Definition: mxfdec.c:278
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:1623
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
AVAES
Definition: aes_internal.h:34
find_body_sid_by_absolute_offset
static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
Definition: mxfdec.c:496
klv_read_packet
static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
Definition: mxfdec.c:460
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
FrameWrapped
@ FrameWrapped
Definition: mxfdec.c:95
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: packet.c: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:1248
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:2487
MXFTimecodeComponent::tc
AVTimecode tc
Definition: mxfdec.c:156
KLVPacket::length
uint64_t length
Definition: mxf.h:77
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:315
BodyPartition
@ BodyPartition
Definition: mxfdec.c:75
mxf_metadataset_init
static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
Definition: mxfdec.c:3239
MXFDescriptor::white_ref_level
unsigned int white_ref_level
Definition: mxfdec.c:214
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
MXFContext::fc
AVFormatContext * fc
Definition: mxfdec.c:309
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
OP2a
@ OP2a
Definition: mxfdec.c:83
MXFFFV1SubDescriptor::meta
MXFMetadataSet meta
Definition: mxfdec.c:247
MXFDescriptor::extradata
uint8_t * extradata
Definition: mxfdec.c:223
channel_layout.h
ff_mxf_decode_pixel_layout
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition: mxf.c:177
MXFDescriptor::sample_rate
AVRational sample_rate
Definition: mxfdec.c:199
AV_CHAN_LOW_FREQUENCY_2
@ AV_CHAN_LOW_FREQUENCY_2
Definition: channel_layout.h:76
AV_CHAN_TOP_BACK_LEFT
@ AV_CHAN_TOP_BACK_LEFT
Definition: channel_layout.h:65
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
OP1b
@ OP1b
Definition: mxfdec.c:81
SoundfieldGroupLabelSubDescriptor
@ SoundfieldGroupLabelSubDescriptor
Definition: mxf.h:54
MXFOP
MXFOP
Definition: mxfdec.c:79
MXFDescriptor::extradata_size
int extradata_size
Definition: mxfdec.c:224
FF_MXF_MasteringDisplayMaximumLuminance
#define FF_MXF_MasteringDisplayMaximumLuminance
Definition: mxf.h:99
AVRational::den
int den
Denominator.
Definition: rational.h:60
mxf_resolve_sourceclip
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition: mxfdec.c:2280
MXFTaggedValue::name
char * name
Definition: mxfdec.c:173
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
MXFContext::local_tags
uint8_t * local_tags
Definition: mxfdec.c:311
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:433
MXFSequence::origin
uint8_t origin
Definition: mxfdec.c:148
MXFTaggedValue::meta
MXFMetadataSet meta
Definition: mxfdec.c:172
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
mxf_system_item_key_gc
static const uint8_t mxf_system_item_key_gc[]
Definition: mxfdec.c:341
AV_CHAN_BACK_LEFT
@ AV_CHAN_BACK_LEFT
Definition: channel_layout.h:54
MXFFFV1SubDescriptor::extradata
uint8_t * extradata
Definition: mxfdec.c:248
MXFDescriptor::codec_ul
UID codec_ul
Definition: mxfdec.c:198
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:310
mxf_jp2k_rsiz
static const uint8_t mxf_jp2k_rsiz[]
Definition: mxfdec.c:352
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:337
parse_mca_labels
static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
Definition: mxfdec.c:2513
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:526
segment
Definition: hls.c:77
MXFFFV1SubDescriptor
Definition: mxfdec.c:246
AV_CHAN_BOTTOM_FRONT_CENTER
@ AV_CHAN_BOTTOM_FRONT_CENTER
Definition: channel_layout.h:79
MXFPackage::package_ul
UID package_ul
Definition: mxfdec.c:269
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
MXFContext::current_partition
MXFPartition * current_partition
Definition: mxfdec.c:316
MXFTrack::intra_only
int intra_only
Definition: mxfdec.c:185
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
Definition: dict.c:167
demuxer_class
static const AVClass demuxer_class
Definition: mxfdec.c:4265
options
static const AVOption options[]
Definition: mxfdec.c:4258
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:284
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:369
mem.h
mxf_channel_ordering
static const MXFChannelOrderingUL mxf_channel_ordering[]
Definition: mxfdec.c:1664
OP1c
@ OP1c
Definition: mxfdec.c:82
MXFPackage::descriptor_ref
UID descriptor_ref
Definition: mxfdec.c:272
MXFMetadataSetGroup::metadata_sets
MXFMetadataSet ** metadata_sets
Definition: mxfdec.c:123
MXFSequence::data_definition_ul
UID data_definition_ul
Definition: mxfdec.c:144
mastering_display_metadata.h
KLVPacket::next_klv
int64_t next_klv
Definition: mxf.h:78
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVCodecParameters::format
int format
Definition: codec_par.h:92
AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_PCM_S24DAUD
Definition: codec_id.h:344
MXFCodecUL
Definition: mxf.h:105
IS_KLV_KEY
#define IS_KLV_KEY(x, y)
Definition: mxfdec.c:377
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:2174
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
MXFTaggedValue
Definition: mxfdec.c:171
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
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:544
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:1168
MXFIndexTableSegment::temporal_offset_entries
int8_t * temporal_offset_entries
Definition: mxfdec.c:260
mxf_read_close
static int mxf_read_close(AVFormatContext *s)
Definition: mxfdec.c:4086
MXFEssenceGroup::meta
MXFMetadataSet meta
Definition: mxfdec.c:165
MXFDescriptor::component_depth
unsigned int component_depth
Definition: mxfdec.c:212
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
mxf_get_stream_index
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
Definition: mxfdec.c:482
UnknownWrapped
@ UnknownWrapped
Definition: mxfdec.c:94
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
MXFMetadataReadTableEntry::read
MXFMetadataReadFunc * read
Definition: mxfdec.c:330
MXFPartition::first_essence_klv
KLVPacket first_essence_klv
Definition: mxfdec.c:114
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MXFPulldownComponent::input_segment_ref
UID input_segment_ref
Definition: mxfdec.c:161
ClipWrapped
@ ClipWrapped
Definition: mxfdec.c:96
MXFTimecodeComponent::rate
struct AVRational rate
Definition: mxfdec.c:155
MXFIndexTable::index_sid
int index_sid
Definition: mxfdec.c:288
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:241
MXFPartition::previous_partition
uint64_t previous_partition
Definition: mxfdec.c:103
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
D10D11Wrap
@ D10D11Wrap
Definition: mxf.h:83
Sequence
@ Sequence
Definition: mxf.h:38
MXFPulldownComponent::meta
MXFMetadataSet meta
Definition: mxfdec.c:160
AV_CODEC_ID_TIFF
@ AV_CODEC_ID_TIFF
Definition: codec_id.h:148
AV_CHAN_FRONT_LEFT
@ AV_CHAN_FRONT_LEFT
Definition: channel_layout.h:50
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
avstring.h
MXFTaggedValue::value
char * value
Definition: mxfdec.c:174
MXFIndexTable::body_sid
int body_sid
Definition: mxfdec.c:289
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:349
mxf_add_metadata_set
static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set, enum MXFMetadataSetType type)
Definition: mxfdec.c:921
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:37
AVTimecode
Definition: timecode.h:41
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:651
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
snprintf
#define snprintf
Definition: snprintf.h:34
ff_mxf_codec_uls
const MXFCodecUL ff_mxf_codec_uls[]
Definition: mxf.c:40
mxf_read_partition_pack
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition: mxfdec.c:723
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:595
mxf_canopus_essence_element_key
static const uint8_t mxf_canopus_essence_element_key[]
Definition: mxfdec.c:339
MXFCodecUL::uid
UID uid
Definition: mxf.h:106
MXFDescriptor::meta
MXFMetadataSet meta
Definition: mxfdec.c:195
AVChannelCustom::id
enum AVChannel id
Definition: channel_layout.h: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:1638
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:151
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:231
AV_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:273
mxf_avid_essence_element_key
static const uint8_t mxf_avid_essence_element_key[]
Definition: mxfdec.c:338
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:200
MXFContext::footer_partition
uint64_t footer_partition
Definition: mxfdec.c:313
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
MXFPartition::body_sid
int body_sid
Definition: mxfdec.c:105
MXFSequence::meta
MXFMetadataSet meta
Definition: mxfdec.c:143
MXFPartition::body_offset
int64_t body_offset
Definition: mxfdec.c:113
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:240
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346
Generated on Mon May 13 2024 19:22:43 for FFmpeg by   doxygen 1.8.17