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