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