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