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