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