FFmpeg
gxf.c
Go to the documentation of this file.
1 /*
2  * GXF demuxer.
3  * Copyright (c) 2006 Reimar Doeffinger
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <inttypes.h>
23 
25 #include "libavutil/common.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "gxf.h"
29 #include "libavcodec/mpeg12data.h"
30 
32  int64_t first_field;
33  int64_t last_field;
36  int64_t track_aux_data;
37 };
38 
39 /**
40  * @brief parse gxf timecode and add it to metadata
41  */
42 static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)
43 {
44  char tmp[128];
45  int field = timecode & 0xff;
46  int frame = fields_per_frame ? field / fields_per_frame : field;
47  int second = (timecode >> 8) & 0xff;
48  int minute = (timecode >> 16) & 0xff;
49  int hour = (timecode >> 24) & 0x1f;
50  int drop = (timecode >> 29) & 1;
51  // bit 30: color_frame, unused
52  // ignore invalid time code
53  if (timecode >> 31)
54  return 0;
55  snprintf(tmp, sizeof(tmp), "%02d:%02d:%02d%c%02d",
56  hour, minute, second, drop ? ';' : ':', frame);
57  return av_dict_set(pm, key, tmp, 0);
58 }
59 
60 /**
61  * @brief parses a packet header, extracting type and length
62  * @param pb AVIOContext to read header from
63  * @param type detected packet type is stored here
64  * @param length detected packet length, excluding header is stored here
65  * @return 0 if header not found or contains invalid data, 1 otherwise
66  */
68  if (avio_rb32(pb))
69  return 0;
70  if (avio_r8(pb) != 1)
71  return 0;
72  *type = avio_r8(pb);
73  *length = avio_rb32(pb);
74  if ((*length >> 24) || *length < 16)
75  return 0;
76  *length -= 16;
77  if (avio_rb32(pb))
78  return 0;
79  if (avio_r8(pb) != 0xe1)
80  return 0;
81  if (avio_r8(pb) != 0xe2)
82  return 0;
83  return 1;
84 }
85 
86 /**
87  * @brief check if file starts with a PKT_MAP header
88  */
89 static int gxf_probe(const AVProbeData *p) {
90  static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
91  static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
92  if (!memcmp(p->buf, startcode, sizeof(startcode)) &&
93  !memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))
94  return AVPROBE_SCORE_MAX;
95  return 0;
96 }
97 
98 /**
99  * @brief gets the stream index for the track with the specified id, creates new
100  * stream if not found
101  * @param id id of stream to find / add
102  * @param format stream format identifier
103  */
104 static int get_sindex(AVFormatContext *s, int id, int format) {
105  int i;
106  AVStream *st = NULL;
107  i = ff_find_stream_index(s, id);
108  if (i >= 0)
109  return i;
110  st = avformat_new_stream(s, NULL);
111  if (!st)
112  return AVERROR(ENOMEM);
113  st->id = id;
114  switch (format) {
115  case 3:
116  case 4:
119  break;
120  case 13:
121  case 14:
122  case 15:
123  case 16:
124  case 25:
127  break;
128  case 11:
129  case 12:
130  case 20:
133  st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
134  break;
135  case 22:
136  case 23:
139  st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
140  break;
141  case 9:
144  st->codecpar->channels = 1;
146  st->codecpar->sample_rate = 48000;
147  st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
148  st->codecpar->block_align = 3 * 1;
150  break;
151  case 10:
154  st->codecpar->channels = 1;
156  st->codecpar->sample_rate = 48000;
157  st->codecpar->bit_rate = 2 * 1 * 48000 * 8;
158  st->codecpar->block_align = 2 * 1;
160  break;
161  case 17:
164  st->codecpar->channels = 2;
166  st->codecpar->sample_rate = 48000;
167  break;
168  case 26: /* AVCi50 / AVCi100 (AVC Intra) */
169  case 29: /* AVCHD */
173  break;
174  // timecode tracks:
175  case 7:
176  case 8:
177  case 24:
180  break;
181  case 30:
184  break;
185  default:
188  break;
189  }
190  return s->nb_streams - 1;
191 }
192 
193 /**
194  * @brief filters out interesting tags from material information.
195  * @param len length of tag section, will be adjusted to contain remaining bytes
196  * @param si struct to store collected information into
197  */
198 static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
201  while (*len >= 2) {
202  GXFMatTag tag = avio_r8(pb);
203  int tlen = avio_r8(pb);
204  *len -= 2;
205  if (tlen > *len)
206  return;
207  *len -= tlen;
208  if (tlen == 4) {
209  uint32_t value = avio_rb32(pb);
210  if (tag == MAT_FIRST_FIELD)
211  si->first_field = value;
212  else if (tag == MAT_LAST_FIELD)
213  si->last_field = value;
214  } else
215  avio_skip(pb, tlen);
216  }
217 }
218 
219 static const AVRational frame_rate_tab[] = {
220  { 60, 1},
221  {60000, 1001},
222  { 50, 1},
223  { 30, 1},
224  {30000, 1001},
225  { 25, 1},
226  { 24, 1},
227  {24000, 1001},
228  { 0, 0},
229 };
230 
231 /**
232  * @brief convert fps tag value to AVRational fps
233  * @param fps fps value from tag
234  * @return fps as AVRational, or 0 / 0 if unknown
235  */
237  if (fps < 1 || fps > 9) fps = 9;
238  return frame_rate_tab[fps - 1];
239 }
240 
241 /**
242  * @brief convert UMF attributes flags to AVRational fps
243  * @param flags UMF flags to convert
244  * @return fps as AVRational, or 0 / 0 if unknown
245  */
246 static AVRational fps_umf2avr(uint32_t flags) {
247  static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
248  {25, 1}, {30000, 1001}};
249  int idx = av_log2((flags & 0x7c0) >> 6);
250  return map[idx];
251 }
252 
253 /**
254  * @brief filters out interesting tags from track information.
255  * @param len length of tag section, will be adjusted to contain remaining bytes
256  * @param si struct to store collected information into
257  */
258 static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
259  si->frames_per_second = (AVRational){0, 0};
260  si->fields_per_frame = 0;
261  si->track_aux_data = 0x80000000;
262  while (*len >= 2) {
263  GXFTrackTag tag = avio_r8(pb);
264  int tlen = avio_r8(pb);
265  *len -= 2;
266  if (tlen > *len)
267  return;
268  *len -= tlen;
269  if (tlen == 4) {
270  uint32_t value = avio_rb32(pb);
271  if (tag == TRACK_FPS)
272  si->frames_per_second = fps_tag2avr(value);
273  else if (tag == TRACK_FPF && (value == 1 || value == 2))
274  si->fields_per_frame = value;
275  } else if (tlen == 8 && tag == TRACK_AUX)
276  si->track_aux_data = avio_rl64(pb);
277  else
278  avio_skip(pb, tlen);
279  }
280 }
281 
282 /**
283  * @brief read index from FLT packet into stream 0 av_index
284  */
285 static void gxf_read_index(AVFormatContext *s, int pkt_len) {
286  AVIOContext *pb = s->pb;
287  AVStream *st;
288  uint32_t fields_per_map, 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 
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;
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;
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 
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
540  int first = field_info >> 16;
541  int last = field_info & 0xffff; // last is exclusive
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
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,
576  if (idx < 0)
577  return -1;
578  pos = st->internal->index_entries[idx].pos;
579  if (idx < st->internal->nb_index_entries - 2)
580  maxlen = st->internal->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 
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 };
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2407
#define NULL
Definition: coverity.c:32
GXFPktType
Definition: gxf.h:25
static int gxf_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxf.c:498
Bytestream IO Context.
Definition: avio.h:161
static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si)
filters out interesting tags from track information.
Definition: gxf.c:258
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:1984
static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si)
filters out interesting tags from material information.
Definition: gxf.c:198
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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:4871
int64_t pos
Definition: avformat.h:809
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2409
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
int av_log2(unsigned v)
Definition: intmath.c:26
Definition: gxf.h:29
GLint GLenum type
Definition: opengl_enc.c:104
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
const char * key
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
static void gxf_read_index(AVFormatContext *s, int pkt_len)
read index from FLT packet into stream 0 av_index
Definition: gxf.c:285
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:770
static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: gxf.c:565
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
Format I/O context.
Definition: avformat.h:1239
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1372
static int64_t start_time
Definition: ffplay.c:332
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:203
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:785
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
enum AVStreamParseType need_parsing
Definition: avformat.h:1088
int id
Format-specific stream ID.
Definition: avformat.h:887
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: gxf.h:49
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
int64_t first_field
Definition: gxf.c:32
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1370
uint32_t tag
Definition: movenc.c:1597
#define AVERROR_EOF
End of file.
Definition: error.h:55
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:305
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length)
parses a packet header, extracting type and length
Definition: gxf.c:67
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
static AVRational fps_umf2avr(uint32_t flags)
convert UMF attributes flags to AVRational fps
Definition: gxf.c:246
#define READ_ONE()
Definition: gxf.c:446
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1600
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2101
int64_t last_field
Definition: gxf.c:33
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:754
Definition: gxf.h:44
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
unsigned int pos
Definition: spdifenc.c:410
AVInputFormat ff_gxf_demuxer
Definition: gxf.c:602
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
GLsizei GLsizei * length
Definition: opengl_enc.c:114
Definition: gxf.h:27
int64_t track_aux_data
Definition: gxf.c:36
#define FFMAX(a, b)
Definition: common.h:94
Only parse headers, do not repack.
Definition: avformat.h:800
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:228
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
int block_align
Audio only.
Definition: codec_par.h:177
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:4955
audio channel layout utility functions
static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)
parse gxf timecode and add it to metadata
Definition: gxf.c:42
static AVRational fps_tag2avr(int32_t fps)
convert fps tag value to AVRational fps
Definition: gxf.c:236
int32_t
static int get_sindex(AVFormatContext *s, int id, int format)
gets the stream index for the track with the specified id, creates new stream if not found ...
Definition: gxf.c:104
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
GXFTrackTag
Definition: gxf.h:42
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
int32_t fields_per_frame
Definition: gxf.c:35
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
Stream structure.
Definition: avformat.h:880
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1119
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
GXFMatTag
Definition: gxf.h:33
MPEG-1/2 tables.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
static int gxf_probe(const AVProbeData *p)
check if file starts with a PKT_MAP header
Definition: gxf.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Definition: gxf.h:26
const VDPAUPixFmtMap * map
#define snprintf
Definition: snprintf.h:34
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
#define flags(name, subs,...)
Definition: cbs_av1.c:560
static int gxf_header(AVFormatContext *s)
Definition: gxf.c:319
static const AVRational frame_rate_tab[]
Definition: gxf.c:219
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:929
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
Main libavformat public API header.
AVRational frames_per_second
Definition: gxf.c:34
common internal and external API header
static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp)
resync the stream on the next media packet with specified properties
Definition: gxf.c:460
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:919
int den
Denominator.
Definition: rational.h:60
unsigned bps
Definition: movenc.c:1598
static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos, int64_t pos_limit)
Definition: gxf.c:591
Definition: gxf.h:30
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
int len
void * priv_data
Format private data.
Definition: avformat.h:1267
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int channels
Audio only.
Definition: codec_par.h:166
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
Definition: gxf.h:47
FILE * out
Definition: movenc.c:54
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
int stream_index
Definition: packet.h:365
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define AV_CH_LAYOUT_MONO
enum AVCodecID id
This structure stores compressed data.
Definition: packet.h:340
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:762
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static uint8_t tmp[11]
Definition: aes_ctr.c:26