FFmpeg  4.3
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  */
67 static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
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)
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) {
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
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),
604  .read_header = gxf_header,
605  .read_packet = gxf_packet,
606  .read_seek = gxf_seek,
607  .read_timestamp = gxf_read_timestamp,
608 };
AVStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1094
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:301
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:413
gxf_stream_info::track_aux_data
int64_t track_aux_data
Definition: gxf.c:36
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
out
FILE * out
Definition: movenc.c:54
AVFMT_FLAG_IGNIDX
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1468
READ_ONE
#define READ_ONE()
Definition: gxf.c:443
frame_rate_tab
static const AVRational frame_rate_tab[]
Definition: gxf.c:219
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
TRACK_FPF
@ TRACK_FPF
Definition: gxf.h:49
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
TRACK_FPS
@ TRACK_FPS
Definition: gxf.h:47
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
gxf_stream_info::fields_per_frame
int32_t fields_per_frame
Definition: gxf.c:35
AVDictionary
Definition: dict.c:30
fps_umf2avr
static AVRational fps_umf2avr(uint32_t flags)
convert UMF attributes flags to AVRational fps
Definition: gxf.c:246
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
gxf_probe
static int gxf_probe(const AVProbeData *p)
check if file starts with a PKT_MAP header
Definition: gxf.c:89
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2498
av_add_index_entry
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:2045
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
PKT_MAP
@ PKT_MAP
Definition: gxf.h:26
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
TRACK_AUX
@ TRACK_AUX
Definition: gxf.h:44
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:914
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
PKT_UMF
@ PKT_UMF
Definition: gxf.h:30
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat
Definition: avformat.h:636
parse_packet_header
static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length)
parses a packet header, extracting type and length
Definition: gxf.c:67
s
#define s(width, name)
Definition: cbs_vp9.c:257
format
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
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1083
field
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
Definition: writing_filters.txt:78
key
const char * key
Definition: hwcontext_opencl.c:168
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
int32_t
int32_t
Definition: audio_convert.c:194
MAT_FIRST_FIELD
@ MAT_FIRST_FIELD
Definition: gxf.h:35
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
gxf_stream_info
Definition: gxf.c:31
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2496
gxf_packet
static int gxf_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxf.c:495
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
MAT_LAST_FIELD
@ MAT_LAST_FIELD
Definition: gxf.h:36
fps_tag2avr
static AVRational fps_tag2avr(int32_t fps)
convert fps tag value to AVRational fps
Definition: gxf.c:236
gxf_track_tags
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
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
gxf_seek
static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: gxf.c:562
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1552
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:747
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:313
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:186
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:332
GXFMatTag
GXFMatTag
Definition: gxf.h:33
start_time
static int64_t start_time
Definition: ffplay.c:332
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:4938
bps
unsigned bps
Definition: movenc.c:1533
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
gxf.h
PKT_FLT
@ PKT_FLT
Definition: gxf.h:29
av_log2
#define av_log2
Definition: intmath.h:83
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
gxf_stream_info::first_field
int64_t first_field
Definition: gxf.c:32
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
gxf_material_tags
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
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
GXFTrackTag
GXFTrackTag
Definition: gxf.h:42
common.h
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
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:73
uint8_t
uint8_t
Definition: audio_convert.c:194
gxf_read_timestamp
static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Definition: gxf.c:588
gxf_read_index
static void gxf_read_index(AVFormatContext *s, int pkt_len)
read index from FLT packet into stream 0 av_index
Definition: gxf.c:285
len
int len
Definition: vorbis_enc_data.h:452
gxf_header
static int gxf_header(AVFormatContext *s)
Definition: gxf.c:316
get_sindex
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
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:304
add_timecode_metadata
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
tag
uint32_t tag
Definition: movenc.c:1532
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:872
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
frame
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
Definition: filter_design.txt:264
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:763
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:787
pos
unsigned int pos
Definition: spdifenc.c:410
avformat.h
mpeg12data.h
channel_layout.h
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVRational::den
int den
Denominator.
Definition: rational.h:60
PKT_MEDIA
@ PKT_MEDIA
Definition: gxf.h:27
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:796
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
AVPacket::stream_index
int stream_index
Definition: packet.h:357
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
gxf_stream_info::frames_per_second
AVRational frames_per_second
Definition: gxf.c:34
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:85
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:332
ff_find_stream_index
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:5022
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
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:755
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
GXFPktType
GXFPktType
Definition: gxf.h:25
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
ff_gxf_demuxer
AVInputFormat ff_gxf_demuxer
Definition: gxf.c:599
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:904
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
snprintf
#define snprintf
Definition: snprintf.h:34
gxf_resync_media
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
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:148
gxf_stream_info::last_field
int64_t last_field
Definition: gxf.c:33
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2162
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356