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  FFStream *sti;
108  i = ff_find_stream_index(s, id);
109  if (i >= 0)
110  return i;
111  st = avformat_new_stream(s, NULL);
112  if (!st)
113  return AVERROR(ENOMEM);
114  sti = ffstream(st);
115  st->id = id;
116  switch (format) {
117  case 3:
118  case 4:
119  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
120  st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
121  break;
122  case 13:
123  case 14:
124  case 15:
125  case 16:
126  case 25:
127  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
128  st->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
129  break;
130  case 11:
131  case 12:
132  case 20:
133  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
134  st->codecpar->codec_id = AV_CODEC_ID_MPEG2VIDEO;
135  sti->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
136  break;
137  case 22:
138  case 23:
139  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
140  st->codecpar->codec_id = AV_CODEC_ID_MPEG1VIDEO;
141  sti->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
142  break;
143  case 9:
144  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
145  st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
146  st->codecpar->channels = 1;
147  st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
148  st->codecpar->sample_rate = 48000;
149  st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
150  st->codecpar->block_align = 3 * 1;
151  st->codecpar->bits_per_coded_sample = 24;
152  break;
153  case 10:
154  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
155  st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
156  st->codecpar->channels = 1;
157  st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
158  st->codecpar->sample_rate = 48000;
159  st->codecpar->bit_rate = 2 * 1 * 48000 * 8;
160  st->codecpar->block_align = 2 * 1;
161  st->codecpar->bits_per_coded_sample = 16;
162  break;
163  case 17:
164  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
165  st->codecpar->codec_id = AV_CODEC_ID_AC3;
166  st->codecpar->channels = 2;
167  st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
168  st->codecpar->sample_rate = 48000;
169  break;
170  case 26: /* AVCi50 / AVCi100 (AVC Intra) */
171  case 29: /* AVCHD */
172  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
173  st->codecpar->codec_id = AV_CODEC_ID_H264;
174  sti->need_parsing = AVSTREAM_PARSE_HEADERS;
175  break;
176  // timecode tracks:
177  case 7:
178  case 8:
179  case 24:
180  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
181  st->codecpar->codec_id = AV_CODEC_ID_NONE;
182  break;
183  case 30:
184  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
185  st->codecpar->codec_id = AV_CODEC_ID_DNXHD;
186  break;
187  default:
188  st->codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
189  st->codecpar->codec_id = AV_CODEC_ID_NONE;
190  break;
191  }
192  return s->nb_streams - 1;
193 }
194 
195 /**
196  * @brief filters out interesting tags from material information.
197  * @param len length of tag section, will be adjusted to contain remaining bytes
198  * @param si struct to store collected information into
199  */
200 static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
201  si->first_field = AV_NOPTS_VALUE;
202  si->last_field = AV_NOPTS_VALUE;
203  while (*len >= 2) {
204  GXFMatTag tag = avio_r8(pb);
205  int tlen = avio_r8(pb);
206  *len -= 2;
207  if (tlen > *len)
208  return;
209  *len -= tlen;
210  if (tlen == 4) {
211  uint32_t value = avio_rb32(pb);
212  if (tag == MAT_FIRST_FIELD)
213  si->first_field = value;
214  else if (tag == MAT_LAST_FIELD)
215  si->last_field = value;
216  } else
217  avio_skip(pb, tlen);
218  }
219 }
220 
221 static const AVRational frame_rate_tab[] = {
222  { 60, 1},
223  {60000, 1001},
224  { 50, 1},
225  { 30, 1},
226  {30000, 1001},
227  { 25, 1},
228  { 24, 1},
229  {24000, 1001},
230  { 0, 0},
231 };
232 
233 /**
234  * @brief convert fps tag value to AVRational fps
235  * @param fps fps value from tag
236  * @return fps as AVRational, or 0 / 0 if unknown
237  */
238 static AVRational fps_tag2avr(int32_t fps) {
239  if (fps < 1 || fps > 9) fps = 9;
240  return frame_rate_tab[fps - 1];
241 }
242 
243 /**
244  * @brief convert UMF attributes flags to AVRational fps
245  * @param flags UMF flags to convert
246  * @return fps as AVRational, or 0 / 0 if unknown
247  */
248 static AVRational fps_umf2avr(uint32_t flags) {
249  static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
250  {25, 1}, {30000, 1001}};
251  int idx = av_log2((flags & 0x7c0) >> 6);
252  return map[idx];
253 }
254 
255 /**
256  * @brief filters out interesting tags from track information.
257  * @param len length of tag section, will be adjusted to contain remaining bytes
258  * @param si struct to store collected information into
259  */
260 static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
261  si->frames_per_second = (AVRational){0, 0};
262  si->fields_per_frame = 0;
263  si->track_aux_data = 0x80000000;
264  while (*len >= 2) {
265  GXFTrackTag tag = avio_r8(pb);
266  int tlen = avio_r8(pb);
267  *len -= 2;
268  if (tlen > *len)
269  return;
270  *len -= tlen;
271  if (tlen == 4) {
272  uint32_t value = avio_rb32(pb);
273  if (tag == TRACK_FPS)
274  si->frames_per_second = fps_tag2avr(value);
275  else if (tag == TRACK_FPF && (value == 1 || value == 2))
276  si->fields_per_frame = value;
277  } else if (tlen == 8 && tag == TRACK_AUX)
278  si->track_aux_data = avio_rl64(pb);
279  else
280  avio_skip(pb, tlen);
281  }
282 }
283 
284 /**
285  * @brief read index from FLT packet into stream 0 av_index
286  */
287 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
288  AVIOContext *pb = s->pb;
289  AVStream *st;
290  uint32_t fields_per_map, map_cnt;
291  int i;
292  if (pkt_len < 8)
293  return;
294  fields_per_map = avio_rl32(pb);
295  map_cnt = avio_rl32(pb);
296  pkt_len -= 8;
297  if ((s->flags & AVFMT_FLAG_IGNIDX) || !s->streams) {
298  avio_skip(pb, pkt_len);
299  return;
300  }
301  st = s->streams[0];
302  if (map_cnt > 1000) {
303  av_log(s, AV_LOG_ERROR,
304  "too many index entries %"PRIu32" (%"PRIx32")\n",
305  map_cnt, map_cnt);
306  map_cnt = 1000;
307  }
308  if (pkt_len < 4 * map_cnt) {
309  av_log(s, AV_LOG_ERROR, "invalid index length\n");
310  avio_skip(pb, pkt_len);
311  return;
312  }
313  pkt_len -= 4 * map_cnt;
314  av_add_index_entry(st, 0, 0, 0, 0, 0);
315  for (i = 0; i < map_cnt; i++)
316  av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
317  i * (uint64_t)fields_per_map + 1, 0, 0, 0);
318  avio_skip(pb, pkt_len);
319 }
320 
321 static int gxf_header(AVFormatContext *s) {
322  AVIOContext *pb = s->pb;
323  GXFPktType pkt_type;
324  int map_len;
325  int len;
326  AVRational main_timebase = {0, 0};
327  struct gxf_stream_info *si = s->priv_data;
328  int i;
329  if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
330  av_log(s, AV_LOG_ERROR, "map packet not found\n");
331  return 0;
332  }
333  map_len -= 2;
334  if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
335  av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
336  return 0;
337  }
338  map_len -= 2;
339  len = avio_rb16(pb); // length of material data section
340  if (len > map_len) {
341  av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
342  return 0;
343  }
344  map_len -= len;
345  gxf_material_tags(pb, &len, si);
346  avio_skip(pb, len);
347  map_len -= 2;
348  len = avio_rb16(pb); // length of track description
349  if (len > map_len) {
350  av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
351  return 0;
352  }
353  map_len -= len;
354  while (len > 0) {
355  int track_type, track_id, track_len;
356  AVStream *st;
357  int idx;
358  len -= 4;
359  track_type = avio_r8(pb);
360  track_id = avio_r8(pb);
361  track_len = avio_rb16(pb);
362  len -= track_len;
363  if (!(track_type & 0x80)) {
364  av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
365  continue;
366  }
367  track_type &= 0x7f;
368  if ((track_id & 0xc0) != 0xc0) {
369  av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
370  continue;
371  }
372  track_id &= 0x3f;
373  gxf_track_tags(pb, &track_len, si);
374  // check for timecode tracks
375  if (track_type == 7 || track_type == 8 || track_type == 24) {
376  add_timecode_metadata(&s->metadata, "timecode",
377  si->track_aux_data & 0xffffffff,
378  si->fields_per_frame);
379 
380  }
381  avio_skip(pb, track_len);
382 
383  idx = get_sindex(s, track_id, track_type);
384  if (idx < 0) continue;
385  st = s->streams[idx];
386  if (!main_timebase.num || !main_timebase.den) {
387  main_timebase.num = si->frames_per_second.den;
388  main_timebase.den = si->frames_per_second.num * 2;
389  }
390  st->start_time = si->first_field;
391  if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)
392  st->duration = si->last_field - si->first_field;
393  }
394  if (len < 0)
395  av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
396  if (map_len)
397  avio_skip(pb, map_len);
398  if (!parse_packet_header(pb, &pkt_type, &len)) {
399  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
400  return -1;
401  }
402  if (pkt_type == PKT_FLT) {
403  gxf_read_index(s, len);
404  if (!parse_packet_header(pb, &pkt_type, &len)) {
405  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
406  return -1;
407  }
408  }
409  if (pkt_type == PKT_UMF) {
410  if (len >= 0x39) {
411  AVRational fps;
412  len -= 0x39;
413  avio_skip(pb, 5); // preamble
414  avio_skip(pb, 0x30); // payload description
415  fps = fps_umf2avr(avio_rl32(pb));
416  if (!main_timebase.num || !main_timebase.den) {
417  av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."
418  " This might give wrong results.\n");
419  // this may not always be correct, but simply the best we can get
420  main_timebase.num = fps.den;
421  main_timebase.den = fps.num * 2;
422  }
423 
424  if (len >= 0x18) {
425  len -= 0x18;
426  avio_skip(pb, 0x10);
427  add_timecode_metadata(&s->metadata, "timecode_at_mark_in",
428  avio_rl32(pb), si->fields_per_frame);
429  add_timecode_metadata(&s->metadata, "timecode_at_mark_out",
430  avio_rl32(pb), si->fields_per_frame);
431  }
432  } else
433  av_log(s, AV_LOG_INFO, "UMF packet too short\n");
434  } else
435  av_log(s, AV_LOG_INFO, "UMF packet missing\n");
436  avio_skip(pb, len);
437  // set a fallback value, 60000/1001 is specified for audio-only files
438  // so use that regardless of why we do not know the video frame rate.
439  if (!main_timebase.num || !main_timebase.den)
440  main_timebase = (AVRational){1001, 60000};
441  for (i = 0; i < s->nb_streams; i++) {
442  AVStream *st = s->streams[i];
443  avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
444  }
445  return 0;
446 }
447 
448 #define READ_ONE() \
449  { \
450  if (!max_interval-- || avio_feof(pb)) \
451  goto out; \
452  tmp = tmp << 8 | avio_r8(pb); \
453  }
454 
455 /**
456  * @brief resync the stream on the next media packet with specified properties
457  * @param max_interval how many bytes to search for matching packet at most
458  * @param track track id the media packet must belong to, -1 for any
459  * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
460  * @return timestamp of packet found
461  */
462 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
463  uint32_t tmp;
464  uint64_t last_pos;
465  uint64_t last_found_pos = 0;
466  int cur_track;
467  int64_t cur_timestamp = AV_NOPTS_VALUE;
468  int len;
469  AVIOContext *pb = s->pb;
470  GXFPktType type;
471  tmp = avio_rb32(pb);
472 start:
473  while (tmp)
474  READ_ONE();
475  READ_ONE();
476  if (tmp != 1)
477  goto start;
478  last_pos = avio_tell(pb);
479  if (avio_seek(pb, -5, SEEK_CUR) < 0)
480  goto out;
481  if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
482  if (avio_seek(pb, last_pos, SEEK_SET) < 0)
483  goto out;
484  goto start;
485  }
486  avio_r8(pb);
487  cur_track = avio_r8(pb);
488  cur_timestamp = avio_rb32(pb);
489  last_found_pos = avio_tell(pb) - 16 - 6;
490  if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
491  if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
492  goto start;
493  }
494 out:
495  if (last_found_pos)
496  avio_seek(pb, last_found_pos, SEEK_SET);
497  return cur_timestamp;
498 }
499 
500 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
501  AVIOContext *pb = s->pb;
502  GXFPktType pkt_type;
503  int pkt_len;
504  struct gxf_stream_info *si = s->priv_data;
505 
506  while (!pb->eof_reached) {
507  AVStream *st;
508  int track_type, track_id, ret;
509  int field_nr, field_info, skip = 0;
510  int stream_index;
511  if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
512  if (!avio_feof(pb))
513  av_log(s, AV_LOG_ERROR, "sync lost\n");
514  return -1;
515  }
516  if (pkt_type == PKT_FLT) {
517  gxf_read_index(s, pkt_len);
518  continue;
519  }
520  if (pkt_type != PKT_MEDIA) {
521  avio_skip(pb, pkt_len);
522  continue;
523  }
524  if (pkt_len < 16) {
525  av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
526  continue;
527  }
528  pkt_len -= 16;
529  track_type = avio_r8(pb);
530  track_id = avio_r8(pb);
531  stream_index = get_sindex(s, track_id, track_type);
532  if (stream_index < 0)
533  return stream_index;
534  st = s->streams[stream_index];
535  field_nr = avio_rb32(pb);
536  field_info = avio_rb32(pb);
537  avio_rb32(pb); // "timeline" field number
538  avio_r8(pb); // flags
539  avio_r8(pb); // reserved
540  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE ||
541  st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
542  int first = field_info >> 16;
543  int last = field_info & 0xffff; // last is exclusive
544  int bps = av_get_bits_per_sample(st->codecpar->codec_id)>>3;
545  if (first <= last && last*bps <= pkt_len) {
546  avio_skip(pb, first*bps);
547  skip = pkt_len - last*bps;
548  pkt_len = (last-first)*bps;
549  } else
550  av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
551  }
552  ret = av_get_packet(pb, pkt, pkt_len);
553  if (skip)
554  avio_skip(pb, skip);
555  pkt->stream_index = stream_index;
556  pkt->dts = field_nr;
557 
558  //set duration manually for DV or else lavf misdetects the frame rate
559  if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)
560  pkt->duration = si->fields_per_frame;
561 
562  return ret;
563  }
564  return AVERROR_EOF;
565 }
566 
567 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
568  int64_t res = 0;
569  uint64_t pos;
570  uint64_t maxlen = 100 * 1024 * 1024;
571  AVStream *st = s->streams[0];
572  FFStream *const sti = ffstream(st);
573  int64_t start_time = s->streams[stream_index]->start_time;
574  int64_t found;
575  int idx;
576  if (timestamp < start_time) timestamp = start_time;
577  idx = av_index_search_timestamp(st, timestamp - start_time,
578  AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
579  if (idx < 0)
580  return -1;
581  pos = sti->index_entries[idx].pos;
582  if (idx < sti->nb_index_entries - 2)
583  maxlen = sti->index_entries[idx + 2].pos - pos;
584  maxlen = FFMAX(maxlen, 200 * 1024);
585  res = avio_seek(s->pb, pos, SEEK_SET);
586  if (res < 0)
587  return res;
588  found = gxf_resync_media(s, maxlen, -1, timestamp);
589  if (FFABS(found - timestamp) > 4)
590  return -1;
591  return 0;
592 }
593 
594 static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
595  int64_t *pos, int64_t pos_limit) {
596  AVIOContext *pb = s->pb;
597  int64_t res;
598  if (avio_seek(pb, *pos, SEEK_SET) < 0)
599  return AV_NOPTS_VALUE;
600  res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
601  *pos = avio_tell(pb);
602  return res;
603 }
604 
605 const AVInputFormat ff_gxf_demuxer = {
606  .name = "gxf",
607  .long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
608  .priv_data_size = sizeof(struct gxf_stream_info),
609  .read_probe = gxf_probe,
610  .read_header = gxf_header,
611  .read_packet = gxf_packet,
612  .read_seek = gxf_seek,
613  .read_timestamp = gxf_read_timestamp,
614 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:426
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:724
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:1229
READ_ONE
#define READ_ONE()
Definition: gxf.c:448
frame_rate_tab
static const AVRational frame_rate_tab[]
Definition: gxf.c:221
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
TRACK_FPF
@ TRACK_FPF
Definition: gxf.h:49
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
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:391
gxf_stream_info::fields_per_frame
int32_t fields_per_frame
Definition: gxf.c:35
AVDictionary
Definition: dict.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
fps_umf2avr
static AVRational fps_umf2avr(uint32_t flags)
convert UMF attributes flags to AVRational fps
Definition: gxf.c:248
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
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
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:429
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2165
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: seek.c:117
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:486
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:900
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:591
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:773
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:638
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
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:643
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
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:77
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:65
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:402
gxf_stream_info
Definition: gxf.c:31
AVFormatContext
Format I/O context.
Definition: avformat.h:1109
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1004
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2163
gxf_packet
static int gxf_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxf.c:500
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:446
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:238
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:260
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:51
gxf_seek
static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: gxf.c:567
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:742
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:326
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:117
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:325
GXFMatTag
GXFMatTag
Definition: gxf.h:33
FFStream
Definition: internal.h:191
start_time
static int64_t start_time
Definition: ffplay.c:330
bps
unsigned bps
Definition: movenc.c:1596
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:372
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:191
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:57
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:200
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:74
gxf_read_timestamp
static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Definition: gxf.c:594
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:287
len
int len
Definition: vorbis_enc_data.h:426
gxf_header
static int gxf_header(AVFormatContext *s)
Definition: gxf.c:321
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:196
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:1595
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:864
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:857
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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:758
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:781
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
mpeg12data.h
ff_gxf_demuxer
const AVInputFormat ff_gxf_demuxer
Definition: gxf.c:605
channel_layout.h
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:790
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, 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:1146
AVPacket::stream_index
int stream_index
Definition: packet.h:375
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:333
gxf_stream_info::frames_per_second
AVRational frames_per_second
Definition: gxf.c:34
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:274
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:71
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:350
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:1226
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
format
fg outputs[0] format
Definition: ffmpeg_filter.c:175
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:750
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
int32_t
int32_t
Definition: audioconvert.c:56
GXFPktType
GXFPktType
Definition: gxf.h:25
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:890
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
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:462
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:149
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: seek.c:237
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:360
Generated on Mon Oct 18 2021 19:22:22 for FFmpeg by   doxygen 1.8.17