FFmpeg
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(const 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:2511
#define NULL
Definition: coverity.c:32
GXFPktType
Definition: gxf.h:25
static int gxf_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxf.c:495
Bytestream IO Context.
Definition: avio.h:161
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:2039
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:4882
int64_t pos
Definition: avformat.h:810
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2513
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
int num
Numerator.
Definition: rational.h:59
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1110
int av_log2(unsigned v)
Definition: intmath.c:26
Definition: gxf.h:29
GLint GLenum type
Definition: opengl_enc.c:104
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
const char * key
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:786
static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: gxf.c:562
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 format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
Format I/O context.
Definition: avformat.h:1358
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1491
static int64_t start_time
Definition: ffplay.c:331
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:203
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:801
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
int id
Format-specific stream ID.
Definition: avformat.h:888
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: gxf.h:49
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4455
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int64_t first_field
Definition: gxf.c:32
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
uint32_t tag
Definition: movenc.c:1496
#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:310
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4055
#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:3982
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#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:1506
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2148
int64_t last_field
Definition: gxf.c:33
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:770
Definition: gxf.h:44
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 field
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVInputFormat ff_gxf_demuxer
Definition: gxf.c:599
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
GLsizei GLsizei * length
Definition: opengl_enc.c:114
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:801
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:639
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int block_align
Audio only.
Definition: avcodec.h:4070
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4966
audio channel layout utility functions
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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
GXFTrackTag
Definition: gxf.h:42
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
int32_t fields_per_frame
Definition: gxf.c:35
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
Stream structure.
Definition: avformat.h:881
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
GXFMatTag
Definition: gxf.h:33
MPEG-1/2 tables.
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
static int gxf_probe(const AVProbeData *p)
check if file starts with a PKT_MAP header
Definition: gxf.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
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:446
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:4063
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
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:920
int den
Denominator.
Definition: rational.h:60
unsigned bps
Definition: movenc.c:1497
static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Definition: gxf.c:588
Definition: gxf.h:30
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
int len
void * priv_data
Format private data.
Definition: avformat.h:1386
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3995
int channels
Audio only.
Definition: avcodec.h:4059
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
Definition: gxf.h:47
FILE * out
Definition: movenc.c:54
void INT64 start
Definition: avisynth_c.h:766
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:358
int stream_index
Definition: avcodec.h:1479
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
#define AV_CH_LAYOUT_MONO
enum AVCodecID id
This structure stores compressed data.
Definition: avcodec.h:1454
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:778
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static uint8_t tmp[11]
Definition: aes_ctr.c:26