FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gxf.c
Go to the documentation of this file.
1 /*
2  * GXF demuxer.
3  * Copyright (c) 2006 Reimar Doeffinger
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 #include <inttypes.h>
23 
25 #include "libavutil/common.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "gxf.h"
29 #include "libavcodec/mpeg12data.h"
30 
32  int64_t first_field;
33  int64_t last_field;
36  int64_t track_aux_data;
37 };
38 
39 /**
40  * @brief parse gxf timecode and add it to metadata
41  */
42 static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)
43 {
44  char tmp[128];
45  int field = timecode & 0xff;
46  int frame = fields_per_frame ? field / fields_per_frame : field;
47  int second = (timecode >> 8) & 0xff;
48  int minute = (timecode >> 16) & 0xff;
49  int hour = (timecode >> 24) & 0x1f;
50  int drop = (timecode >> 29) & 1;
51  // bit 30: color_frame, unused
52  // ignore invalid time code
53  if (timecode >> 31)
54  return 0;
55  snprintf(tmp, sizeof(tmp), "%02d:%02d:%02d%c%02d",
56  hour, minute, second, drop ? ';' : ':', frame);
57  return av_dict_set(pm, key, tmp, 0);
58 }
59 
60 /**
61  * @brief parses a packet header, extracting type and length
62  * @param pb AVIOContext to read header from
63  * @param type detected packet type is stored here
64  * @param length detected packet length, excluding header is stored here
65  * @return 0 if header not found or contains invalid data, 1 otherwise
66  */
68  if (avio_rb32(pb))
69  return 0;
70  if (avio_r8(pb) != 1)
71  return 0;
72  *type = avio_r8(pb);
73  *length = avio_rb32(pb);
74  if ((*length >> 24) || *length < 16)
75  return 0;
76  *length -= 16;
77  if (avio_rb32(pb))
78  return 0;
79  if (avio_r8(pb) != 0xe1)
80  return 0;
81  if (avio_r8(pb) != 0xe2)
82  return 0;
83  return 1;
84 }
85 
86 /**
87  * @brief check if file starts with a PKT_MAP header
88  */
89 static int gxf_probe(AVProbeData *p) {
90  static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
91  static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
92  if (!memcmp(p->buf, startcode, sizeof(startcode)) &&
93  !memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))
94  return AVPROBE_SCORE_MAX;
95  return 0;
96 }
97 
98 /**
99  * @brief gets the stream index for the track with the specified id, creates new
100  * stream if not found
101  * @param id id of stream to find / add
102  * @param format stream format identifier
103  */
104 static int get_sindex(AVFormatContext *s, int id, int format) {
105  int i;
106  AVStream *st = NULL;
107  i = ff_find_stream_index(s, id);
108  if (i >= 0)
109  return i;
110  st = avformat_new_stream(s, NULL);
111  if (!st)
112  return AVERROR(ENOMEM);
113  st->id = id;
114  switch (format) {
115  case 3:
116  case 4:
119  break;
120  case 13:
121  case 14:
122  case 15:
123  case 16:
124  case 25:
127  break;
128  case 11:
129  case 12:
130  case 20:
133  st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
134  break;
135  case 22:
136  case 23:
139  st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
140  break;
141  case 9:
144  st->codecpar->channels = 1;
146  st->codecpar->sample_rate = 48000;
147  st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
148  st->codecpar->block_align = 3 * 1;
150  break;
151  case 10:
154  st->codecpar->channels = 1;
156  st->codecpar->sample_rate = 48000;
157  st->codecpar->bit_rate = 2 * 1 * 48000 * 8;
158  st->codecpar->block_align = 2 * 1;
160  break;
161  case 17:
164  st->codecpar->channels = 2;
166  st->codecpar->sample_rate = 48000;
167  break;
168  case 26: /* AVCi50 / AVCi100 (AVC Intra) */
169  case 29: /* AVCHD */
173  break;
174  // timecode tracks:
175  case 7:
176  case 8:
177  case 24:
180  break;
181  case 30:
184  break;
185  default:
188  break;
189  }
190  return s->nb_streams - 1;
191 }
192 
193 /**
194  * @brief filters out interesting tags from material information.
195  * @param len length of tag section, will be adjusted to contain remaining bytes
196  * @param si struct to store collected information into
197  */
198 static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
201  while (*len >= 2) {
202  GXFMatTag tag = avio_r8(pb);
203  int tlen = avio_r8(pb);
204  *len -= 2;
205  if (tlen > *len)
206  return;
207  *len -= tlen;
208  if (tlen == 4) {
209  uint32_t value = avio_rb32(pb);
210  if (tag == MAT_FIRST_FIELD)
211  si->first_field = value;
212  else if (tag == MAT_LAST_FIELD)
213  si->last_field = value;
214  } else
215  avio_skip(pb, tlen);
216  }
217 }
218 
219 static const AVRational frame_rate_tab[] = {
220  { 60, 1},
221  {60000, 1001},
222  { 50, 1},
223  { 30, 1},
224  {30000, 1001},
225  { 25, 1},
226  { 24, 1},
227  {24000, 1001},
228  { 0, 0},
229 };
230 
231 /**
232  * @brief convert fps tag value to AVRational fps
233  * @param fps fps value from tag
234  * @return fps as AVRational, or 0 / 0 if unknown
235  */
237  if (fps < 1 || fps > 9) fps = 9;
238  return frame_rate_tab[fps - 1];
239 }
240 
241 /**
242  * @brief convert UMF attributes flags to AVRational fps
243  * @param flags UMF flags to convert
244  * @return fps as AVRational, or 0 / 0 if unknown
245  */
246 static AVRational fps_umf2avr(uint32_t flags) {
247  static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
248  {25, 1}, {30000, 1001}};
249  int idx = av_log2((flags & 0x7c0) >> 6);
250  return map[idx];
251 }
252 
253 /**
254  * @brief filters out interesting tags from track information.
255  * @param len length of tag section, will be adjusted to contain remaining bytes
256  * @param si struct to store collected information into
257  */
258 static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
259  si->frames_per_second = (AVRational){0, 0};
260  si->fields_per_frame = 0;
261  si->track_aux_data = 0x80000000;
262  while (*len >= 2) {
263  GXFTrackTag tag = avio_r8(pb);
264  int tlen = avio_r8(pb);
265  *len -= 2;
266  if (tlen > *len)
267  return;
268  *len -= tlen;
269  if (tlen == 4) {
270  uint32_t value = avio_rb32(pb);
271  if (tag == TRACK_FPS)
272  si->frames_per_second = fps_tag2avr(value);
273  else if (tag == TRACK_FPF && (value == 1 || value == 2))
274  si->fields_per_frame = value;
275  } else if (tlen == 8 && tag == TRACK_AUX)
276  si->track_aux_data = avio_rl64(pb);
277  else
278  avio_skip(pb, tlen);
279  }
280 }
281 
282 /**
283  * @brief read index from FLT packet into stream 0 av_index
284  */
285 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
286  AVIOContext *pb = s->pb;
287  AVStream *st;
288  uint32_t fields_per_map = avio_rl32(pb);
289  uint32_t map_cnt = avio_rl32(pb);
290  int i;
291  pkt_len -= 8;
292  if ((s->flags & AVFMT_FLAG_IGNIDX) || !s->streams) {
293  avio_skip(pb, pkt_len);
294  return;
295  }
296  st = s->streams[0];
297  if (map_cnt > 1000) {
298  av_log(s, AV_LOG_ERROR,
299  "too many index entries %"PRIu32" (%"PRIx32")\n",
300  map_cnt, map_cnt);
301  map_cnt = 1000;
302  }
303  if (pkt_len < 4 * map_cnt) {
304  av_log(s, AV_LOG_ERROR, "invalid index length\n");
305  avio_skip(pb, pkt_len);
306  return;
307  }
308  pkt_len -= 4 * map_cnt;
309  av_add_index_entry(st, 0, 0, 0, 0, 0);
310  for (i = 0; i < map_cnt; i++)
311  av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
312  i * (uint64_t)fields_per_map + 1, 0, 0, 0);
313  avio_skip(pb, pkt_len);
314 }
315 
317  AVIOContext *pb = s->pb;
318  GXFPktType pkt_type;
319  int map_len;
320  int len;
321  AVRational main_timebase = {0, 0};
322  struct gxf_stream_info *si = s->priv_data;
323  int i;
324  if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
325  av_log(s, AV_LOG_ERROR, "map packet not found\n");
326  return 0;
327  }
328  map_len -= 2;
329  if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
330  av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
331  return 0;
332  }
333  map_len -= 2;
334  len = avio_rb16(pb); // length of material data section
335  if (len > map_len) {
336  av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
337  return 0;
338  }
339  map_len -= len;
340  gxf_material_tags(pb, &len, si);
341  avio_skip(pb, len);
342  map_len -= 2;
343  len = avio_rb16(pb); // length of track description
344  if (len > map_len) {
345  av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
346  return 0;
347  }
348  map_len -= len;
349  while (len > 0) {
350  int track_type, track_id, track_len;
351  AVStream *st;
352  int idx;
353  len -= 4;
354  track_type = avio_r8(pb);
355  track_id = avio_r8(pb);
356  track_len = avio_rb16(pb);
357  len -= track_len;
358  if (!(track_type & 0x80)) {
359  av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
360  continue;
361  }
362  track_type &= 0x7f;
363  if ((track_id & 0xc0) != 0xc0) {
364  av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
365  continue;
366  }
367  track_id &= 0x3f;
368  gxf_track_tags(pb, &track_len, si);
369  // check for timecode tracks
370  if (track_type == 7 || track_type == 8 || track_type == 24) {
371  add_timecode_metadata(&s->metadata, "timecode",
372  si->track_aux_data & 0xffffffff,
373  si->fields_per_frame);
374 
375  }
376  avio_skip(pb, track_len);
377 
378  idx = get_sindex(s, track_id, track_type);
379  if (idx < 0) continue;
380  st = s->streams[idx];
381  if (!main_timebase.num || !main_timebase.den) {
382  main_timebase.num = si->frames_per_second.den;
383  main_timebase.den = si->frames_per_second.num * 2;
384  }
385  st->start_time = si->first_field;
387  st->duration = si->last_field - si->first_field;
388  }
389  if (len < 0)
390  av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
391  if (map_len)
392  avio_skip(pb, map_len);
393  if (!parse_packet_header(pb, &pkt_type, &len)) {
394  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
395  return -1;
396  }
397  if (pkt_type == PKT_FLT) {
398  gxf_read_index(s, len);
399  if (!parse_packet_header(pb, &pkt_type, &len)) {
400  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
401  return -1;
402  }
403  }
404  if (pkt_type == PKT_UMF) {
405  if (len >= 0x39) {
406  AVRational fps;
407  len -= 0x39;
408  avio_skip(pb, 5); // preamble
409  avio_skip(pb, 0x30); // payload description
410  fps = fps_umf2avr(avio_rl32(pb));
411  if (!main_timebase.num || !main_timebase.den) {
412  av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."
413  " This might give wrong results.\n");
414  // this may not always be correct, but simply the best we can get
415  main_timebase.num = fps.den;
416  main_timebase.den = fps.num * 2;
417  }
418 
419  if (len >= 0x18) {
420  len -= 0x18;
421  avio_skip(pb, 0x10);
422  add_timecode_metadata(&s->metadata, "timecode_at_mark_in",
423  avio_rl32(pb), si->fields_per_frame);
424  add_timecode_metadata(&s->metadata, "timecode_at_mark_out",
425  avio_rl32(pb), si->fields_per_frame);
426  }
427  } else
428  av_log(s, AV_LOG_INFO, "UMF packet too short\n");
429  } else
430  av_log(s, AV_LOG_INFO, "UMF packet missing\n");
431  avio_skip(pb, len);
432  // set a fallback value, 60000/1001 is specified for audio-only files
433  // so use that regardless of why we do not know the video frame rate.
434  if (!main_timebase.num || !main_timebase.den)
435  main_timebase = (AVRational){1001, 60000};
436  for (i = 0; i < s->nb_streams; i++) {
437  AVStream *st = s->streams[i];
438  avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
439  }
440  return 0;
441 }
442 
443 #define READ_ONE() \
444  { \
445  if (!max_interval-- || avio_feof(pb)) \
446  goto out; \
447  tmp = tmp << 8 | avio_r8(pb); \
448  }
449 
450 /**
451  * @brief resync the stream on the next media packet with specified properties
452  * @param max_interval how many bytes to search for matching packet at most
453  * @param track track id the media packet must belong to, -1 for any
454  * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
455  * @return timestamp of packet found
456  */
457 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
458  uint32_t tmp;
459  uint64_t last_pos;
460  uint64_t last_found_pos = 0;
461  int cur_track;
462  int64_t cur_timestamp = AV_NOPTS_VALUE;
463  int len;
464  AVIOContext *pb = s->pb;
466  tmp = avio_rb32(pb);
467 start:
468  while (tmp)
469  READ_ONE();
470  READ_ONE();
471  if (tmp != 1)
472  goto start;
473  last_pos = avio_tell(pb);
474  if (avio_seek(pb, -5, SEEK_CUR) < 0)
475  goto out;
476  if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
477  if (avio_seek(pb, last_pos, SEEK_SET) < 0)
478  goto out;
479  goto start;
480  }
481  avio_r8(pb);
482  cur_track = avio_r8(pb);
483  cur_timestamp = avio_rb32(pb);
484  last_found_pos = avio_tell(pb) - 16 - 6;
485  if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
486  if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
487  goto start;
488  }
489 out:
490  if (last_found_pos)
491  avio_seek(pb, last_found_pos, SEEK_SET);
492  return cur_timestamp;
493 }
494 
496  AVIOContext *pb = s->pb;
497  GXFPktType pkt_type;
498  int pkt_len;
499  struct gxf_stream_info *si = s->priv_data;
500 
501  while (!pb->eof_reached) {
502  AVStream *st;
503  int track_type, track_id, ret;
504  int field_nr, field_info, skip = 0;
505  int stream_index;
506  if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
507  if (!avio_feof(pb))
508  av_log(s, AV_LOG_ERROR, "sync lost\n");
509  return -1;
510  }
511  if (pkt_type == PKT_FLT) {
512  gxf_read_index(s, pkt_len);
513  continue;
514  }
515  if (pkt_type != PKT_MEDIA) {
516  avio_skip(pb, pkt_len);
517  continue;
518  }
519  if (pkt_len < 16) {
520  av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
521  continue;
522  }
523  pkt_len -= 16;
524  track_type = avio_r8(pb);
525  track_id = avio_r8(pb);
526  stream_index = get_sindex(s, track_id, track_type);
527  if (stream_index < 0)
528  return stream_index;
529  st = s->streams[stream_index];
530  field_nr = avio_rb32(pb);
531  field_info = avio_rb32(pb);
532  avio_rb32(pb); // "timeline" field number
533  avio_r8(pb); // flags
534  avio_r8(pb); // reserved
537  int first = field_info >> 16;
538  int last = field_info & 0xffff; // last is exclusive
540  if (first <= last && last*bps <= pkt_len) {
541  avio_skip(pb, first*bps);
542  skip = pkt_len - last*bps;
543  pkt_len = (last-first)*bps;
544  } else
545  av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
546  }
547  ret = av_get_packet(pb, pkt, pkt_len);
548  if (skip)
549  avio_skip(pb, skip);
550  pkt->stream_index = stream_index;
551  pkt->dts = field_nr;
552 
553  //set duration manually for DV or else lavf misdetects the frame rate
555  pkt->duration = si->fields_per_frame;
556 
557  return ret;
558  }
559  return AVERROR_EOF;
560 }
561 
562 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
563  int64_t res = 0;
564  uint64_t pos;
565  uint64_t maxlen = 100 * 1024 * 1024;
566  AVStream *st = s->streams[0];
567  int64_t start_time = s->streams[stream_index]->start_time;
568  int64_t found;
569  int idx;
570  if (timestamp < start_time) timestamp = start_time;
571  idx = av_index_search_timestamp(st, timestamp - start_time,
573  if (idx < 0)
574  return -1;
575  pos = st->index_entries[idx].pos;
576  if (idx < st->nb_index_entries - 2)
577  maxlen = st->index_entries[idx + 2].pos - pos;
578  maxlen = FFMAX(maxlen, 200 * 1024);
579  res = avio_seek(s->pb, pos, SEEK_SET);
580  if (res < 0)
581  return res;
582  found = gxf_resync_media(s, maxlen, -1, timestamp);
583  if (FFABS(found - timestamp) > 4)
584  return -1;
585  return 0;
586 }
587 
588 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
589  int64_t *pos, int64_t pos_limit) {
590  AVIOContext *pb = s->pb;
591  int64_t res;
592  if (avio_seek(pb, *pos, SEEK_SET) < 0)
593  return AV_NOPTS_VALUE;
594  res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
595  *pos = avio_tell(pb);
596  return res;
597 }
598 
600  .name = "gxf",
601  .long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
602  .priv_data_size = sizeof(struct gxf_stream_info),
603  .read_probe = gxf_probe,
604  .read_header = gxf_header,
605  .read_packet = gxf_packet,
606  .read_seek = gxf_seek,
607  .read_timestamp = gxf_read_timestamp,
608 };
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2360
#define NULL
Definition: coverity.c:32
GXFPktType
Definition: gxf.h:25
static int gxf_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxf.c:495
const char * s
Definition: avisynth_c.h:631
Bytestream IO Context.
Definition: avio.h:111
static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si)
filters out interesting tags from track information.
Definition: gxf.c:258
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:1897
enum AVCodecID id
Definition: mxfenc.c:104
static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si)
filters out interesting tags from material information.
Definition: gxf.c:198
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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:4399
int64_t pos
Definition: avformat.h:816
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2362
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3911
int num
numerator
Definition: rational.h:44
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:213
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1085
int av_log2(unsigned v)
Definition: intmath.c:26
Definition: gxf.h:29
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:287
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
static void gxf_read_index(AVFormatContext *s, int pkt_len)
read index from FLT packet into stream 0 av_index
Definition: gxf.c:285
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:688
static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: gxf.c:562
Format I/O context.
Definition: avformat.h:1319
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1432
static int64_t start_time
Definition: ffplay.c:329
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:195
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:703
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1592
enum AVStreamParseType need_parsing
Definition: avformat.h:1074
int id
Format-specific stream ID.
Definition: avformat.h:883
Definition: gxf.h:49
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4037
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1387
static AVFrame * frame
int64_t first_field
Definition: gxf.c:32
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1430
uint32_t tag
Definition: movenc.c:1353
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:260
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:447
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4013
#define av_log(a,...)
static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length)
parses a packet header, extracting type and length
Definition: gxf.c:67
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3940
static AVRational fps_umf2avr(uint32_t flags)
convert UMF attributes flags to AVRational fps
Definition: gxf.c:246
#define READ_ONE()
Definition: gxf.c:443
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:3438
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1533
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:1996
int64_t last_field
Definition: gxf.c:33
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:672
#define AVERROR(e)
Definition: error.h:43
Definition: gxf.h:44
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
AVInputFormat ff_gxf_demuxer
Definition: gxf.c:599
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3907
GLsizei GLsizei * length
Definition: opengl_enc.c:115
Definition: gxf.h:27
int64_t track_aux_data
Definition: gxf.c:36
#define FFMAX(a, b)
Definition: common.h:94
Only parse headers, do not repack.
Definition: avformat.h:807
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:541
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:461
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1375
int block_align
Audio only.
Definition: avcodec.h:4028
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4483
audio channel layout utility functions
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)
parse gxf timecode and add it to metadata
Definition: gxf.c:42
static AVRational fps_tag2avr(int32_t fps)
convert fps tag value to AVRational fps
Definition: gxf.c:236
int32_t
static int get_sindex(AVFormatContext *s, int id, int format)
gets the stream index for the track with the specified id, creates new stream if not found ...
Definition: gxf.c:104
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
GXFTrackTag
Definition: gxf.h:42
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:192
int32_t fields_per_frame
Definition: gxf.c:35
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:194
FILE * out
Definition: movenc-test.c:54
Stream structure.
Definition: avformat.h:876
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVIOContext * pb
I/O context.
Definition: avformat.h:1361
GXFMatTag
Definition: gxf.h:33
static const char * format
Definition: movenc-test.c:47
MPEG1/2 tables.
GLint GLenum type
Definition: opengl_enc.c:105
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:69
rational number numerator/denominator
Definition: rational.h:43
Definition: gxf.h:26
const VDPAUPixFmtMap * map
#define snprintf
Definition: snprintf.h:34
This structure contains the data a format has to probe a file.
Definition: avformat.h:459
static int flags
Definition: cpu.c:47
static int gxf_header(AVFormatContext *s)
Definition: gxf.c:316
static const AVRational frame_rate_tab[]
Definition: gxf.c:219
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
int sample_rate
Audio only.
Definition: avcodec.h:4021
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:471
Main libavformat public API header.
AVRational frames_per_second
Definition: gxf.c:34
common internal and external API header
static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp)
resync the stream on the next media packet with specified properties
Definition: gxf.c:457
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:923
int den
denominator
Definition: rational.h:45
unsigned bps
Definition: movenc.c:1354
static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Definition: gxf.c:588
static int gxf_probe(AVProbeData *p)
check if file starts with a PKT_MAP header
Definition: gxf.c:89
Definition: gxf.h:30
int eof_reached
true if eof reached
Definition: avio.h:186
int len
void * priv_data
Format private data.
Definition: avformat.h:1347
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3953
int channels
Audio only.
Definition: avcodec.h:4017
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1573
Definition: gxf.h:47
void INT64 start
Definition: avisynth_c.h:553
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:660
AVCodecParameters * codecpar
Definition: avformat.h:1006
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:311
int stream_index
Definition: avcodec.h:1576
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:1551
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:680
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:240