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