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 "demux.h"
28 #include "internal.h"
29 #include "gxf.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->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
147  st->codecpar->sample_rate = 48000;
148  st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
149  st->codecpar->block_align = 3 * 1;
150  st->codecpar->bits_per_coded_sample = 24;
151  break;
152  case 10:
153  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
154  st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
155  st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_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->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
165  st->codecpar->sample_rate = 48000;
166  break;
167  case 26: /* AVCi50 / AVCi100 (AVC Intra) */
168  case 29: /* AVCHD */
169  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
170  st->codecpar->codec_id = AV_CODEC_ID_H264;
171  sti->need_parsing = AVSTREAM_PARSE_HEADERS;
172  break;
173  // timecode tracks:
174  case 7:
175  case 8:
176  case 24:
177  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
178  st->codecpar->codec_id = AV_CODEC_ID_NONE;
179  break;
180  case 30:
181  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
182  st->codecpar->codec_id = AV_CODEC_ID_DNXHD;
183  break;
184  default:
185  st->codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
186  st->codecpar->codec_id = AV_CODEC_ID_NONE;
187  break;
188  }
189  return s->nb_streams - 1;
190 }
191 
192 /**
193  * @brief filters out interesting tags from material information.
194  * @param len length of tag section, will be adjusted to contain remaining bytes
195  * @param si struct to store collected information into
196  */
197 static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
198  si->first_field = AV_NOPTS_VALUE;
199  si->last_field = AV_NOPTS_VALUE;
200  while (*len >= 2) {
201  GXFMatTag tag = avio_r8(pb);
202  int tlen = avio_r8(pb);
203  *len -= 2;
204  if (tlen > *len)
205  return;
206  *len -= tlen;
207  if (tlen == 4) {
208  uint32_t value = avio_rb32(pb);
209  if (tag == MAT_FIRST_FIELD)
210  si->first_field = value;
211  else if (tag == MAT_LAST_FIELD)
212  si->last_field = value;
213  } else
214  avio_skip(pb, tlen);
215  }
216 }
217 
218 static const AVRational frame_rate_tab[] = {
219  { 60, 1},
220  {60000, 1001},
221  { 50, 1},
222  { 30, 1},
223  {30000, 1001},
224  { 25, 1},
225  { 24, 1},
226  {24000, 1001},
227  { 0, 0},
228 };
229 
230 /**
231  * @brief convert fps tag value to AVRational fps
232  * @param fps fps value from tag
233  * @return fps as AVRational, or 0 / 0 if unknown
234  */
235 static AVRational fps_tag2avr(int32_t fps) {
236  if (fps < 1 || fps > 9) fps = 9;
237  return frame_rate_tab[fps - 1];
238 }
239 
240 /**
241  * @brief convert UMF attributes flags to AVRational fps
242  * @param flags UMF flags to convert
243  * @return fps as AVRational, or 0 / 0 if unknown
244  */
245 static AVRational fps_umf2avr(uint32_t flags) {
246  static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
247  {25, 1}, {30000, 1001}};
248  int idx = av_log2((flags & 0x7c0) >> 6);
249  return map[idx];
250 }
251 
252 /**
253  * @brief filters out interesting tags from track information.
254  * @param len length of tag section, will be adjusted to contain remaining bytes
255  * @param si struct to store collected information into
256  */
257 static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
258  si->frames_per_second = (AVRational){0, 0};
259  si->fields_per_frame = 0;
260  si->track_aux_data = 0x80000000;
261  while (*len >= 2) {
262  GXFTrackTag tag = avio_r8(pb);
263  int tlen = avio_r8(pb);
264  *len -= 2;
265  if (tlen > *len)
266  return;
267  *len -= tlen;
268  if (tlen == 4) {
269  uint32_t value = avio_rb32(pb);
270  if (tag == TRACK_FPS)
271  si->frames_per_second = fps_tag2avr(value);
272  else if (tag == TRACK_FPF && (value == 1 || value == 2))
273  si->fields_per_frame = value;
274  } else if (tlen == 8 && tag == TRACK_AUX)
275  si->track_aux_data = avio_rl64(pb);
276  else
277  avio_skip(pb, tlen);
278  }
279 }
280 
281 /**
282  * @brief read index from FLT packet into stream 0 av_index
283  */
284 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
285  AVIOContext *pb = s->pb;
286  AVStream *st;
287  uint32_t fields_per_map, map_cnt;
288  int i;
289  if (pkt_len < 8)
290  return;
291  fields_per_map = avio_rl32(pb);
292  map_cnt = avio_rl32(pb);
293  pkt_len -= 8;
294  if ((s->flags & AVFMT_FLAG_IGNIDX) || !s->streams) {
295  avio_skip(pb, pkt_len);
296  return;
297  }
298  st = s->streams[0];
299  if (map_cnt > 1000) {
300  av_log(s, AV_LOG_ERROR,
301  "too many index entries %"PRIu32" (%"PRIx32")\n",
302  map_cnt, map_cnt);
303  map_cnt = 1000;
304  }
305  if (pkt_len < 4 * map_cnt) {
306  av_log(s, AV_LOG_ERROR, "invalid index length\n");
307  avio_skip(pb, pkt_len);
308  return;
309  }
310  pkt_len -= 4 * map_cnt;
311  av_add_index_entry(st, 0, 0, 0, 0, 0);
312  for (i = 0; i < map_cnt; i++)
313  av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
314  i * (uint64_t)fields_per_map + 1, 0, 0, 0);
315  avio_skip(pb, pkt_len);
316 }
317 
318 static int gxf_header(AVFormatContext *s) {
319  AVIOContext *pb = s->pb;
320  GXFPktType pkt_type;
321  int map_len;
322  int len;
323  AVRational main_timebase = {0, 0};
324  struct gxf_stream_info *si = s->priv_data;
325  int i;
326  if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
327  av_log(s, AV_LOG_ERROR, "map packet not found\n");
328  return 0;
329  }
330  map_len -= 2;
331  if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
332  av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
333  return 0;
334  }
335  map_len -= 2;
336  len = avio_rb16(pb); // length of material data section
337  if (len > map_len) {
338  av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
339  return 0;
340  }
341  map_len -= len;
342  gxf_material_tags(pb, &len, si);
343  avio_skip(pb, len);
344  map_len -= 2;
345  len = avio_rb16(pb); // length of track description
346  if (len > map_len) {
347  av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
348  return 0;
349  }
350  map_len -= len;
351  while (len > 0) {
352  int track_type, track_id, track_len;
353  AVStream *st;
354  int idx;
355  len -= 4;
356  track_type = avio_r8(pb);
357  track_id = avio_r8(pb);
358  track_len = avio_rb16(pb);
359  len -= track_len;
360  if (!(track_type & 0x80)) {
361  av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
362  continue;
363  }
364  track_type &= 0x7f;
365  if ((track_id & 0xc0) != 0xc0) {
366  av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
367  continue;
368  }
369  track_id &= 0x3f;
370  gxf_track_tags(pb, &track_len, si);
371  // check for timecode tracks
372  if (track_type == 7 || track_type == 8 || track_type == 24) {
373  add_timecode_metadata(&s->metadata, "timecode",
374  si->track_aux_data & 0xffffffff,
375  si->fields_per_frame);
376 
377  }
378  avio_skip(pb, track_len);
379 
380  idx = get_sindex(s, track_id, track_type);
381  if (idx < 0) continue;
382  st = s->streams[idx];
383  if (!main_timebase.num || !main_timebase.den) {
384  main_timebase.num = si->frames_per_second.den;
385  main_timebase.den = si->frames_per_second.num * 2;
386  }
387  st->start_time = si->first_field;
388  if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)
389  st->duration = si->last_field - si->first_field;
390  }
391  if (len < 0)
392  av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
393  if (map_len)
394  avio_skip(pb, map_len);
395  if (!parse_packet_header(pb, &pkt_type, &len)) {
396  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
397  return -1;
398  }
399  if (pkt_type == PKT_FLT) {
400  gxf_read_index(s, len);
401  if (!parse_packet_header(pb, &pkt_type, &len)) {
402  av_log(s, AV_LOG_ERROR, "sync lost in header\n");
403  return -1;
404  }
405  }
406  if (pkt_type == PKT_UMF) {
407  if (len >= 0x39) {
408  AVRational fps;
409  len -= 0x39;
410  avio_skip(pb, 5); // preamble
411  avio_skip(pb, 0x30); // payload description
412  fps = fps_umf2avr(avio_rl32(pb));
413  if (!main_timebase.num || !main_timebase.den) {
414  av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."
415  " This might give wrong results.\n");
416  // this may not always be correct, but simply the best we can get
417  main_timebase.num = fps.den;
418  main_timebase.den = fps.num * 2;
419  }
420 
421  if (len >= 0x18) {
422  len -= 0x18;
423  avio_skip(pb, 0x10);
424  add_timecode_metadata(&s->metadata, "timecode_at_mark_in",
425  avio_rl32(pb), si->fields_per_frame);
426  add_timecode_metadata(&s->metadata, "timecode_at_mark_out",
427  avio_rl32(pb), si->fields_per_frame);
428  }
429  } else
430  av_log(s, AV_LOG_INFO, "UMF packet too short\n");
431  } else
432  av_log(s, AV_LOG_INFO, "UMF packet missing\n");
433  avio_skip(pb, len);
434  // set a fallback value, 60000/1001 is specified for audio-only files
435  // so use that regardless of why we do not know the video frame rate.
436  if (!main_timebase.num || !main_timebase.den)
437  main_timebase = (AVRational){1001, 60000};
438  for (i = 0; i < s->nb_streams; i++) {
439  AVStream *st = s->streams[i];
440  avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
441  }
442  return 0;
443 }
444 
445 #define READ_ONE() \
446  { \
447  if (!max_interval-- || avio_feof(pb)) \
448  goto out; \
449  tmp = tmp << 8 | avio_r8(pb); \
450  }
451 
452 /**
453  * @brief resync the stream on the next media packet with specified properties
454  * @param max_interval how many bytes to search for matching packet at most
455  * @param track track id the media packet must belong to, -1 for any
456  * @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
457  * @return timestamp of packet found
458  */
459 static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
460  uint32_t tmp;
461  uint64_t last_pos;
462  uint64_t last_found_pos = 0;
463  int cur_track;
464  int64_t cur_timestamp = AV_NOPTS_VALUE;
465  int len;
466  AVIOContext *pb = s->pb;
467  GXFPktType type;
468  tmp = avio_rb32(pb);
469 start:
470  while (tmp)
471  READ_ONE();
472  READ_ONE();
473  if (tmp != 1)
474  goto start;
475  last_pos = avio_tell(pb);
476  if (avio_seek(pb, -5, SEEK_CUR) < 0)
477  goto out;
478  if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
479  if (avio_seek(pb, last_pos, SEEK_SET) < 0)
480  goto out;
481  goto start;
482  }
483  avio_r8(pb);
484  cur_track = avio_r8(pb);
485  cur_timestamp = avio_rb32(pb);
486  last_found_pos = avio_tell(pb) - 16 - 6;
487  if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
488  if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
489  goto start;
490  }
491 out:
492  if (last_found_pos)
493  avio_seek(pb, last_found_pos, SEEK_SET);
494  return cur_timestamp;
495 }
496 
497 static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
498  AVIOContext *pb = s->pb;
499  GXFPktType pkt_type;
500  int pkt_len;
501  struct gxf_stream_info *si = s->priv_data;
502 
503  while (!pb->eof_reached) {
504  AVStream *st;
505  int track_type, track_id, ret;
506  int field_nr, field_info, skip = 0;
507  int stream_index;
508  if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
509  if (!avio_feof(pb))
510  av_log(s, AV_LOG_ERROR, "sync lost\n");
511  return -1;
512  }
513  if (pkt_type == PKT_FLT) {
514  gxf_read_index(s, pkt_len);
515  continue;
516  }
517  if (pkt_type != PKT_MEDIA) {
518  avio_skip(pb, pkt_len);
519  continue;
520  }
521  if (pkt_len < 16) {
522  av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
523  continue;
524  }
525  pkt_len -= 16;
526  track_type = avio_r8(pb);
527  track_id = avio_r8(pb);
528  stream_index = get_sindex(s, track_id, track_type);
529  if (stream_index < 0)
530  return stream_index;
531  st = s->streams[stream_index];
532  field_nr = avio_rb32(pb);
533  field_info = avio_rb32(pb);
534  avio_rb32(pb); // "timeline" field number
535  avio_r8(pb); // flags
536  avio_r8(pb); // reserved
537  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE ||
538  st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
539  int first = field_info >> 16;
540  int last = field_info & 0xffff; // last is exclusive
541  int bps = av_get_bits_per_sample(st->codecpar->codec_id)>>3;
542  if (first <= last && last*bps <= pkt_len) {
543  avio_skip(pb, first*bps);
544  skip = pkt_len - last*bps;
545  pkt_len = (last-first)*bps;
546  } else
547  av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
548  }
549  ret = av_get_packet(pb, pkt, pkt_len);
550  if (skip)
551  avio_skip(pb, skip);
552  pkt->stream_index = stream_index;
553  pkt->dts = field_nr;
554 
555  //set duration manually for DV or else lavf misdetects the frame rate
556  if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)
557  pkt->duration = si->fields_per_frame;
558 
559  return ret;
560  }
561  return AVERROR_EOF;
562 }
563 
564 static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
565  int64_t res = 0;
566  uint64_t pos;
567  uint64_t maxlen = 100 * 1024 * 1024;
568  AVStream *st = s->streams[0];
569  FFStream *const sti = ffstream(st);
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 = sti->index_entries[idx].pos;
579  if (idx < sti->nb_index_entries - 2)
580  maxlen = sti->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 const 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 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:318
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:430
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: options.c:237
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
out
FILE * out
Definition: movenc.c:54
AVFMT_FLAG_IGNIDX
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1333
READ_ONE
#define READ_ONE()
Definition: gxf.c:445
frame_rate_tab
static const AVRational frame_rate_tab[]
Definition: gxf.c:218
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
TRACK_FPF
@ TRACK_FPF
Definition: gxf.h:49
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
TRACK_FPS
@ TRACK_FPS
Definition: gxf.h:47
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:354
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:245
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:465
gxf_probe
static int gxf_probe(const AVProbeData *p)
check if file starts with a PKT_MAP header
Definition: gxf.c:89
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: avformat.c:697
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:407
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2291
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:118
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
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:998
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:586
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:790
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:656
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:256
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:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
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:174
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:64
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:380
gxf_stream_info
Definition: gxf.c:31
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2289
gxf_packet
static int gxf_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxf.c:497
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:453
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:235
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
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:257
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
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:564
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:330
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:324
GXFMatTag
GXFMatTag
Definition: gxf.h:33
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
FFStream
Definition: internal.h:197
start_time
static int64_t start_time
Definition: ffplay.c:331
bps
unsigned bps
Definition: movenc.c:1647
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
ff_find_stream_index
int ff_find_stream_index(const AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: demux_utils.c:371
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
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: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:197
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:184
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:591
demux.h
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:284
len
int len
Definition: vorbis_enc_data.h:426
gxf_header
static int gxf_header(AVFormatContext *s)
Definition: gxf.c:318
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:102
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:1646
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:962
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
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:775
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:799
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
ff_gxf_demuxer
const AVInputFormat ff_gxf_demuxer
Definition: gxf.c:602
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:808
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:240
AVPacket::stream_index
int stream_index
Definition: packet.h:376
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
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:252
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:103
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:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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:767
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:90
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:988
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:459
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:238
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375
Generated on Tue Jul 5 2022 19:22:03 for FFmpeg by   doxygen 1.8.17