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