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 
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/common.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "gxf.h"
29 #include "libavcodec/mpeg12data.h"
30 
31 struct gxf_stream_info {
32  int64_t first_field;
33  int64_t last_field;
34  AVRational frames_per_second;
35  int32_t fields_per_frame;
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:
117  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
118  st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
119  break;
120  case 13:
121  case 14:
122  case 15:
123  case 16:
124  case 25:
125  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
126  st->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
127  break;
128  case 11:
129  case 12:
130  case 20:
131  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
132  st->codecpar->codec_id = AV_CODEC_ID_MPEG2VIDEO;
133  st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
134  break;
135  case 22:
136  case 23:
137  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
138  st->codecpar->codec_id = AV_CODEC_ID_MPEG1VIDEO;
139  st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
140  break;
141  case 9:
142  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
143  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
144  st->codecpar->channels = 1;
145  st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
146  st->codecpar->sample_rate = 48000;
147  st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
148  st->codecpar->block_align = 3 * 1;
149  st->codecpar->bits_per_coded_sample = 24;
150  break;
151  case 10:
152  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
153  st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
154  st->codecpar->channels = 1;
155  st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
156  st->codecpar->sample_rate = 48000;
157  st->codecpar->bit_rate = 2 * 1 * 48000 * 8;
158  st->codecpar->block_align = 2 * 1;
159  st->codecpar->bits_per_coded_sample = 16;
160  break;
161  case 17:
162  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
163  st->codecpar->codec_id = AV_CODEC_ID_AC3;
164  st->codecpar->channels = 2;
165  st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
166  st->codecpar->sample_rate = 48000;
167  break;
168  case 26: /* AVCi50 / AVCi100 (AVC Intra) */
169  case 29: /* AVCHD */
170  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
171  st->codecpar->codec_id = AV_CODEC_ID_H264;
172  st->need_parsing = AVSTREAM_PARSE_HEADERS;
173  break;
174  // timecode tracks:
175  case 7:
176  case 8:
177  case 24:
178  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
179  st->codecpar->codec_id = AV_CODEC_ID_NONE;
180  break;
181  case 30:
182  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
183  st->codecpar->codec_id = AV_CODEC_ID_DNXHD;
184  break;
185  default:
186  st->codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
187  st->codecpar->codec_id = AV_CODEC_ID_NONE;
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) {
199  si->first_field = AV_NOPTS_VALUE;
200  si->last_field = AV_NOPTS_VALUE;
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  */
236 static AVRational fps_tag2avr(int32_t fps) {
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, map_cnt;
289  int i;
290  if (pkt_len < 8)
291  return;
292  fields_per_map = avio_rl32(pb);
293  map_cnt = avio_rl32(pb);
294  pkt_len -= 8;
295  if ((s->flags & AVFMT_FLAG_IGNIDX) || !s->streams) {
296  avio_skip(pb, pkt_len);
297  return;
298  }
299  st = s->streams[0];
300  if (map_cnt > 1000) {
301  av_log(s, AV_LOG_ERROR,
302  "too many index entries %"PRIu32" (%"PRIx32")\n",
303  map_cnt, map_cnt);
304  map_cnt = 1000;
305  }
306  if (pkt_len < 4 * map_cnt) {
307  av_log(s, AV_LOG_ERROR, "invalid index length\n");
308  avio_skip(pb, pkt_len);
309  return;
310  }
311  pkt_len -= 4 * map_cnt;
312  av_add_index_entry(st, 0, 0, 0, 0, 0);
313  for (i = 0; i < map_cnt; i++)
314  av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
315  i * (uint64_t)fields_per_map + 1, 0, 0, 0);
316  avio_skip(pb, pkt_len);
317 }
318 
319 static int gxf_header(AVFormatContext *s) {
320  AVIOContext *pb = s->pb;
321  GXFPktType pkt_type;
322  int map_len;
323  int len;
324  AVRational main_timebase = {0, 0};
325  struct gxf_stream_info *si = s->priv_data;
326  int i;
327  if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
328  av_log(s, AV_LOG_ERROR, "map packet not found\n");
329  return 0;
330  }
331  map_len -= 2;
332  if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
333  av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
334  return 0;
335  }
336  map_len -= 2;
337  len = avio_rb16(pb); // length of material data section
338  if (len > map_len) {
339  av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
340  return 0;
341  }
342  map_len -= len;
343  gxf_material_tags(pb, &len, si);
344  avio_skip(pb, len);
345  map_len -= 2;
346  len = avio_rb16(pb); // length of track description
347  if (len > map_len) {
348  av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
349  return 0;
350  }
351  map_len -= len;
352  while (len > 0) {
353  int track_type, track_id, track_len;
354  AVStream *st;
355  int idx;
356  len -= 4;
357  track_type = avio_r8(pb);
358  track_id = avio_r8(pb);
359  track_len = avio_rb16(pb);
360  len -= track_len;
361  if (!(track_type & 0x80)) {
362  av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
363  continue;
364  }
365  track_type &= 0x7f;
366  if ((track_id & 0xc0) != 0xc0) {
367  av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
368  continue;
369  }
370  track_id &= 0x3f;
371  gxf_track_tags(pb, &track_len, si);
372  // check for timecode tracks
373  if (track_type == 7 || track_type == 8 || track_type == 24) {
374  add_timecode_metadata(&s->metadata, "timecode",
375  si->track_aux_data & 0xffffffff,
376  si->fields_per_frame);
377 
378  }
379  avio_skip(pb, track_len);
380 
381  idx = get_sindex(s, track_id, track_type);
382  if (idx < 0) continue;
383  st = s->streams[idx];
384  if (!main_timebase.num || !main_timebase.den) {
385  main_timebase.num = si->frames_per_second.den;
386  main_timebase.den = si->frames_per_second.num * 2;
387  }
388  st->start_time = si->first_field;
389  if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)
390  st->duration = si->last_field - si->first_field;
391  }
392  if (len < 0)
393  av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
394  if (map_len)
395  avio_skip(pb, map_len);
396  if (!parse_packet_header(pb, &pkt_type, &len)) {
397  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
398  return -1;
399  }
400  if (pkt_type == PKT_FLT) {
401  gxf_read_index(s, len);
402  if (!parse_packet_header(pb, &pkt_type, &len)) {
403  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
404  return -1;
405  }
406  }
407  if (pkt_type == PKT_UMF) {
408  if (len >= 0x39) {
409  AVRational fps;
410  len -= 0x39;
411  avio_skip(pb, 5); // preamble
412  avio_skip(pb, 0x30); // payload description
413  fps = fps_umf2avr(avio_rl32(pb));
414  if (!main_timebase.num || !main_timebase.den) {
415  av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."
416  " This might give wrong results.\n");
417  // this may not always be correct, but simply the best we can get
418  main_timebase.num = fps.den;
419  main_timebase.den = fps.num * 2;
420  }
421 
422  if (len >= 0x18) {
423  len -= 0x18;
424  avio_skip(pb, 0x10);
425  add_timecode_metadata(&s->metadata, "timecode_at_mark_in",
426  avio_rl32(pb), si->fields_per_frame);
427  add_timecode_metadata(&s->metadata, "timecode_at_mark_out",
428  avio_rl32(pb), si->fields_per_frame);
429  }
430  } else
431  av_log(s, AV_LOG_INFO, "UMF packet too short\n");
432  } else
433  av_log(s, AV_LOG_INFO, "UMF packet missing\n");
434  avio_skip(pb, len);
435  // set a fallback value, 60000/1001 is specified for audio-only files
436  // so use that regardless of why we do not know the video frame rate.
437  if (!main_timebase.num || !main_timebase.den)
438  main_timebase = (AVRational){1001, 60000};
439  for (i = 0; i < s->nb_streams; i++) {
440  AVStream *st = s->streams[i];
441  avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
442  }
443  return 0;
444 }
445 
446 #define READ_ONE() \
447  { \
448  if (!max_interval-- || avio_feof(pb)) \
449  goto out; \
450  tmp = tmp << 8 | avio_r8(pb); \
451  }
452 
453 /**
454  * @brief resync the stream on the next media packet with specified properties
455  * @param max_interval how many bytes to search for matching packet at most
456  * @param track track id the media packet must belong to, -1 for any
457  * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
458  * @return timestamp of packet found
459  */
460 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
461  uint32_t tmp;
462  uint64_t last_pos;
463  uint64_t last_found_pos = 0;
464  int cur_track;
465  int64_t cur_timestamp = AV_NOPTS_VALUE;
466  int len;
467  AVIOContext *pb = s->pb;
468  GXFPktType type;
469  tmp = avio_rb32(pb);
470 start:
471  while (tmp)
472  READ_ONE();
473  READ_ONE();
474  if (tmp != 1)
475  goto start;
476  last_pos = avio_tell(pb);
477  if (avio_seek(pb, -5, SEEK_CUR) < 0)
478  goto out;
479  if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
480  if (avio_seek(pb, last_pos, SEEK_SET) < 0)
481  goto out;
482  goto start;
483  }
484  avio_r8(pb);
485  cur_track = avio_r8(pb);
486  cur_timestamp = avio_rb32(pb);
487  last_found_pos = avio_tell(pb) - 16 - 6;
488  if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
489  if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
490  goto start;
491  }
492 out:
493  if (last_found_pos)
494  avio_seek(pb, last_found_pos, SEEK_SET);
495  return cur_timestamp;
496 }
497 
498 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
499  AVIOContext *pb = s->pb;
500  GXFPktType pkt_type;
501  int pkt_len;
502  struct gxf_stream_info *si = s->priv_data;
503 
504  while (!pb->eof_reached) {
505  AVStream *st;
506  int track_type, track_id, ret;
507  int field_nr, field_info, skip = 0;
508  int stream_index;
509  if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
510  if (!avio_feof(pb))
511  av_log(s, AV_LOG_ERROR, "sync lost\n");
512  return -1;
513  }
514  if (pkt_type == PKT_FLT) {
515  gxf_read_index(s, pkt_len);
516  continue;
517  }
518  if (pkt_type != PKT_MEDIA) {
519  avio_skip(pb, pkt_len);
520  continue;
521  }
522  if (pkt_len < 16) {
523  av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
524  continue;
525  }
526  pkt_len -= 16;
527  track_type = avio_r8(pb);
528  track_id = avio_r8(pb);
529  stream_index = get_sindex(s, track_id, track_type);
530  if (stream_index < 0)
531  return stream_index;
532  st = s->streams[stream_index];
533  field_nr = avio_rb32(pb);
534  field_info = avio_rb32(pb);
535  avio_rb32(pb); // "timeline" field number
536  avio_r8(pb); // flags
537  avio_r8(pb); // reserved
538  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE ||
539  st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
540  int first = field_info >> 16;
541  int last = field_info & 0xffff; // last is exclusive
542  int bps = av_get_bits_per_sample(st->codecpar->codec_id)>>3;
543  if (first <= last && last*bps <= pkt_len) {
544  avio_skip(pb, first*bps);
545  skip = pkt_len - last*bps;
546  pkt_len = (last-first)*bps;
547  } else
548  av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
549  }
550  ret = av_get_packet(pb, pkt, pkt_len);
551  if (skip)
552  avio_skip(pb, skip);
553  pkt->stream_index = stream_index;
554  pkt->dts = field_nr;
555 
556  //set duration manually for DV or else lavf misdetects the frame rate
557  if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)
558  pkt->duration = si->fields_per_frame;
559 
560  return ret;
561  }
562  return AVERROR_EOF;
563 }
564 
565 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
566  int64_t res = 0;
567  uint64_t pos;
568  uint64_t maxlen = 100 * 1024 * 1024;
569  AVStream *st = s->streams[0];
570  int64_t start_time = s->streams[stream_index]->start_time;
571  int64_t found;
572  int idx;
573  if (timestamp < start_time) timestamp = start_time;
574  idx = av_index_search_timestamp(st, timestamp - start_time,
575  AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
576  if (idx < 0)
577  return -1;
578  pos = st->index_entries[idx].pos;
579  if (idx < st->nb_index_entries - 2)
580  maxlen = st->index_entries[idx + 2].pos - pos;
581  maxlen = FFMAX(maxlen, 200 * 1024);
582  res = avio_seek(s->pb, pos, SEEK_SET);
583  if (res < 0)
584  return res;
585  found = gxf_resync_media(s, maxlen, -1, timestamp);
586  if (FFABS(found - timestamp) > 4)
587  return -1;
588  return 0;
589 }
590 
591 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
592  int64_t *pos, int64_t pos_limit) {
593  AVIOContext *pb = s->pb;
594  int64_t res;
595  if (avio_seek(pb, *pos, SEEK_SET) < 0)
596  return AV_NOPTS_VALUE;
597  res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
598  *pos = avio_tell(pb);
599  return res;
600 }
601 
602 AVInputFormat ff_gxf_demuxer = {
603  .name = "gxf",
604  .long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
605  .priv_data_size = sizeof(struct gxf_stream_info),
606  .read_probe = gxf_probe,
607  .read_header = gxf_header,
608  .read_packet = gxf_packet,
609  .read_seek = gxf_seek,
610  .read_timestamp = gxf_read_timestamp,
611 };
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:4526
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:446
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:2052
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:498
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:565
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1574
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:188
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:4948
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_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:591
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:319
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:307
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:412
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:5032
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:565
ff_gxf_demuxer
AVInputFormat ff_gxf_demuxer
Definition: gxf.c:602
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
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
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:460
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:2169
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356
Generated on Wed Aug 24 2022 21:31:59 for FFmpeg by   doxygen 1.8.17