FFmpeg
argo_brp.c
Go to the documentation of this file.
1 /*
2  * Argonaut Games BRP Demuxer
3  *
4  * Copyright (C) 2020 Zane van Iperen (zane@zanevaniperen.com)
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "avformat.h"
24 #include "internal.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/avassert.h"
27 #include "libavutil/internal.h"
28 #include "argo_asf.h"
29 
30 #define BRP_TAG MKTAG('B', 'R', 'P', 'P')
31 #define BRP_FILE_HEADER_SIZE 12
32 #define BRP_BLOCK_HEADER_SIZE 12
33 #define BRP_STREAM_HEADER_SIZE 20
34 #define BRP_MAX_STREAMS 32 /* Soft cap, but even this is overkill. */
35 #define BRP_BASF_LOOKAHEAD 10 /* How many blocks to search for the first BASF one. */
36 #define BVID_HEADER_SIZE 16
37 #define MASK_HEADER_SIZE 12
38 #define BRP_MIN_BUFFER_SIZE FFMAX3(FFMAX3(BRP_FILE_HEADER_SIZE, \
39  BRP_BLOCK_HEADER_SIZE, \
40  BRP_STREAM_HEADER_SIZE), \
41  BVID_HEADER_SIZE, \
42  MASK_HEADER_SIZE)
43 
44 #define BRP_CODEC_ID_BVID MKTAG('B', 'V', 'I', 'D')
45 #define BRP_CODEC_ID_BASF MKTAG('B', 'A', 'S', 'F')
46 #define BRP_CODEC_ID_MASK MKTAG('M', 'A', 'S', 'K')
47 
48 typedef struct ArgoBRPFileHeader {
49  uint32_t magic;
50  uint32_t num_streams;
51  uint32_t byte_rate;
53 
54 typedef struct ArgoBRPBlockHeader {
56  uint32_t start_ms;
57  uint32_t size;
59 
60 typedef struct ArgoBVIDHeader {
61  uint32_t num_frames;
62  uint32_t width;
63  uint32_t height;
64  uint32_t depth;
66 
67 typedef struct ArgoMASKHeader {
68  uint32_t num_frames;
69  uint32_t width;
70  uint32_t height;
72 
73 typedef struct ArgoBRPStreamHeader {
74  uint32_t codec_id;
75  uint32_t id;
76  uint32_t duration_ms;
77  uint32_t byte_rate;
78  uint32_t extradata_size;
79  union
80  {
81  /* If codec_id == BRP_CODEC_ID_BVID */
83  /* If codec_id == BRP_CODEC_ID_BASF */
85  /* If codec_id == BRP_CODEC_ID_MASK */
87  } extradata;
89 
90 typedef struct ArgoBRPDemuxContext {
93 
94  struct {
95  int index;
97  } basf;
99 
100 static int argo_brp_probe(const AVProbeData *p)
101 {
102  if (AV_RL32(p->buf) != BRP_TAG)
103  return 0;
104 
105  return AVPROBE_SCORE_EXTENSION + 1;
106 }
107 
109  void *buf, size_t bufsz)
110 {
111  const char *name;
112  uint32_t size;
113  int64_t ret;
114 
115  if (hdr->codec_id == BRP_CODEC_ID_BVID) {
116  name = "BVID";
117  size = BVID_HEADER_SIZE;
118  } else if (hdr->codec_id == BRP_CODEC_ID_BASF) {
119  name = "BASF";
120  size = ASF_FILE_HEADER_SIZE;
121  } else if (hdr->codec_id == BRP_CODEC_ID_MASK) {
122  name = "MASK";
123  size = MASK_HEADER_SIZE;
124  } else {
125  avpriv_request_sample(s, "BRP codec id 0x%x", hdr->codec_id);
126 
127  if ((ret = avio_skip(s->pb, hdr->extradata_size)) < 0)
128  return ret;
129 
130  return 1;
131  }
132 
133  if (hdr->extradata_size != size) {
134  av_log(s, AV_LOG_ERROR, "Invalid %s extradata size %u, expected %u\n",
135  name, hdr->extradata_size, size);
136  return AVERROR_INVALIDDATA;
137  }
138 
139  av_assert0(bufsz >= size);
140 
141  if ((ret = avio_read(s->pb, buf, size)) < 0)
142  return ret;
143 
144  if (ret != size)
145  return AVERROR(EIO);
146 
147  return 0;
148 }
149 
151 {
152  int64_t ret;
153  AVIOContext *pb = s->pb;
154  ArgoBRPDemuxContext *brp = s->priv_data;
156 
157  if ((ret = avio_read(pb, buf, BRP_FILE_HEADER_SIZE)) < 0)
158  return ret;
159  else if (ret != BRP_FILE_HEADER_SIZE)
160  return AVERROR(EIO);
161 
162  brp->fhdr.magic = AV_RL32(buf + 0);
163  brp->fhdr.num_streams = AV_RL32(buf + 4);
164  brp->fhdr.byte_rate = AV_RL32(buf + 8);
165 
166  if (brp->fhdr.magic != BRP_TAG)
167  return AVERROR_INVALIDDATA;
168 
169  if (brp->fhdr.num_streams > BRP_MAX_STREAMS) {
170  avpriv_request_sample(s, ">%d streams", BRP_MAX_STREAMS);
171  return AVERROR_PATCHWELCOME;
172  }
173 
174  /* Build the stream info. */
175  brp->basf.index = -1;
176  for (uint32_t i = 0; i < brp->fhdr.num_streams; i++) {
177  ArgoBRPStreamHeader *hdr = brp->streams + i;
178  AVStream *st;
179 
180  if (!(st = avformat_new_stream(s, NULL)))
181  return AVERROR(ENOMEM);
182 
183  if ((ret = avio_read(pb, buf, BRP_STREAM_HEADER_SIZE)) < 0)
184  return ret;
185  else if (ret != BRP_STREAM_HEADER_SIZE)
186  return AVERROR(EIO);
187 
188  hdr->codec_id = AV_RL32(buf + 0);
189  hdr->id = AV_RL32(buf + 4);
190  hdr->duration_ms = AV_RL32(buf + 8);
191  hdr->byte_rate = AV_RL32(buf + 12);
192  hdr->extradata_size = AV_RL32(buf + 16);
193 
194  /* This should always be the case. */
195  if (hdr->id != i)
196  return AVERROR_INVALIDDATA;
197 
198  /* Timestamps are in milliseconds. */
199  avpriv_set_pts_info(st, 64, 1, 1000);
200  st->duration = hdr->duration_ms;
201  st->codecpar->bit_rate = hdr->byte_rate * 8;
202 
203  if ((ret = read_extradata(s, hdr, buf, sizeof(buf))) < 0) {
204  return ret;
205  } else if (ret > 0) {
207  continue;
208  }
209 
210  if (hdr->codec_id == BRP_CODEC_ID_BVID) {
211  ArgoBVIDHeader *bvid = &hdr->extradata.bvid;
212 
215 
216  bvid->num_frames = AV_RL32(buf + 0);
217  bvid->width = AV_RL32(buf + 4);
218  bvid->height = AV_RL32(buf + 8);
219  bvid->depth = AV_RL32(buf + 12);
220 
221  /* These are from 1990's games, sanity check this. */
222  if (bvid->width >= 65536 || bvid->height >= 65536 ||
223  bvid->depth > 24 || bvid->depth % 8 != 0) {
224  return AVERROR_INVALIDDATA;
225  }
226 
227  st->codecpar->width = bvid->width;
228  st->codecpar->height = bvid->height;
229  st->nb_frames = bvid->num_frames;
230  st->codecpar->bits_per_raw_sample = bvid->depth;
231  } else if (hdr->codec_id == BRP_CODEC_ID_BASF) {
232  /*
233  * It would make the demuxer significantly more complicated
234  * to support multiple BASF streams. I've never seen a file
235  * with more than one.
236  */
237  if (brp->basf.index >= 0) {
238  avpriv_request_sample(s, "Multiple BASF streams");
239  return AVERROR_PATCHWELCOME;
240  }
241 
244  brp->basf.index = i;
246 
247  if ((ret = ff_argo_asf_validate_file_header(s, &hdr->extradata.basf)) < 0)
248  return ret;
249 
250  st->nb_frames = hdr->extradata.basf.num_chunks;
251  } else if (hdr->codec_id == BRP_CODEC_ID_MASK) {
253 
255 
256  mask->num_frames = AV_RL32(buf + 0);
257  mask->width = AV_RL32(buf + 4);
258  mask->height = AV_RL32(buf + 8);
259 
260  st->nb_frames = mask->num_frames;
261  } else {
262  av_assert0(0); /* Caught above, should never happen. */
263  }
264  }
265 
266  /* Try to find the first BASF chunk. */
267  if (brp->basf.index >= 0) {
268  AVStream *st = s->streams[brp->basf.index];
269  ArgoBRPStreamHeader *hdr = brp->streams + brp->basf.index;
271  int64_t offset;
272  int i;
273 
276 
277  if ((ret = avio_tell(s->pb)) < 0)
278  return ret;
279 
280  offset = ret;
281 
282  av_log(s, AV_LOG_TRACE, "Searching %d blocks for BASF...", BRP_BASF_LOOKAHEAD);
283 
284  for (i = 0; i < BRP_BASF_LOOKAHEAD; i++) {
285  if ((ret = avio_read(pb, buf, BRP_BLOCK_HEADER_SIZE)) < 0)
286  return ret;
287  else if (ret != BRP_BLOCK_HEADER_SIZE)
288  return AVERROR(EIO);
289 
290  blk.stream_id = AV_RL32(buf + 0);
291  blk.start_ms = AV_RL32(buf + 4);
292  blk.size = AV_RL32(buf + 8);
293 
294  if (blk.stream_id == brp->basf.index || blk.stream_id == -1)
295  break;
296 
297  if ((ret = avio_skip(pb, blk.size)) < 0)
298  return ret;
299  }
300 
301  if (i == BRP_BASF_LOOKAHEAD || blk.stream_id == -1) {
302  /* Don't error here, as there may still be a valid video stream. */
303  av_log(s, AV_LOG_TRACE, "not found\n");
304  goto done;
305  }
306 
307  av_log(s, AV_LOG_TRACE, "found at index %d\n", i);
308 
309  if (blk.size < ASF_CHUNK_HEADER_SIZE)
310  return AVERROR_INVALIDDATA;
311 
312  if ((ret = avio_read(pb, buf, ASF_CHUNK_HEADER_SIZE)) < 0)
313  return ret;
314  else if (ret != ASF_CHUNK_HEADER_SIZE)
315  return AVERROR(EIO);
316 
318 
319  /*
320  * Special Case Hack. It seems that in files where the BASF block isn't first,
321  * v1.1 streams are allowed to be non-22050...
322  * Bump the version to 1.2 so ff_argo_asf_fill_stream() doesn't "correct" it.
323  *
324  * Found in Alien Odyssey games files in:
325  * ./GRAPHICS/COMMBUNK/{{COMADD1,COMM2_{1,2,3E},COMM3_{2,3,4,5,6}},FADE{1,2}}.BRP
326  *
327  * Either this format really inconsistent, or FX Fighter and Croc just ignored the
328  * sample rate field...
329  */
330  if (i != 0 && hdr->extradata.basf.version_major == 1 && hdr->extradata.basf.version_minor == 1)
331  hdr->extradata.basf.version_minor = 2;
332 
333  if ((ret = ff_argo_asf_fill_stream(s, st, &hdr->extradata.basf, &brp->basf.ckhdr)) < 0)
334  return ret;
335 
336  /* Convert ms to samples. */
339 
340 done:
341  if ((ret = avio_seek(s->pb, offset, SEEK_SET)) < 0)
342  return ret;
343  }
344  return 0;
345 }
346 
348 {
349  ArgoBRPDemuxContext *brp = s->priv_data;
351  const ArgoBRPStreamHeader *shdr;
352  AVStream *st;
354  ArgoASFChunkHeader ckhdr;
355  int ret;
356 
357  if ((ret = avio_read(s->pb, buf, BRP_BLOCK_HEADER_SIZE)) < 0)
358  return ret;
359  else if (ret != BRP_BLOCK_HEADER_SIZE)
360  return AVERROR(EIO);
361 
362  blk.stream_id = AV_RL32(buf + 0);
363  blk.start_ms = AV_RL32(buf + 4);
364  blk.size = AV_RL32(buf + 8);
365 
366  if (blk.stream_id == -1)
367  return AVERROR_EOF;
368 
369  if (blk.stream_id < -1 || blk.stream_id >= s->nb_streams)
370  return AVERROR_INVALIDDATA;
371 
372  st = s->streams[blk.stream_id];
373  shdr = brp->streams + blk.stream_id;
374 
375  if (blk.stream_id == brp->basf.index) {
376  if (blk.size < ASF_CHUNK_HEADER_SIZE)
377  return AVERROR_INVALIDDATA;
378 
379  if ((ret = avio_read(s->pb, buf, ASF_CHUNK_HEADER_SIZE)) < 0)
380  return ret;
381 
382  ff_argo_asf_parse_chunk_header(&ckhdr, buf);
383 
384  /* Ensure the chunk attributes are the same. */
385  if (ckhdr.sample_rate != brp->basf.ckhdr.sample_rate ||
386  ckhdr.flags != brp->basf.ckhdr.flags ||
387  ckhdr.unk1 != brp->basf.ckhdr.unk1 ||
388  ckhdr.unk2 != brp->basf.ckhdr.unk2)
389  return AVERROR_INVALIDDATA;
390 
392 
393  if (blk.size % st->codecpar->block_align != 0)
394  return AVERROR_INVALIDDATA;
395  }
396 
397  if ((ret = av_get_packet(s->pb, pkt, blk.size)) < 0)
398  return ret;
399  else if (ret != blk.size)
400  return AVERROR_INVALIDDATA;
401 
402  if (blk.stream_id == brp->basf.index) {
403  pkt->duration = ckhdr.num_samples * ckhdr.num_blocks;
404  pkt->pts = av_rescale_rnd(blk.start_ms, ckhdr.sample_rate, 1000, AV_ROUND_UP);
405  } else if (shdr->codec_id == BRP_CODEC_ID_BVID) {
407  pkt->pts = blk.start_ms;
408  } else {
409  pkt->pts = blk.start_ms;
410  }
411 
412  pkt->stream_index = blk.stream_id;
413  return 0;
414 }
415 
417  .name = "argo_brp",
418  .long_name = NULL_IF_CONFIG_SMALL("Argonaut Games BRP"),
419  .priv_data_size = sizeof(ArgoBRPDemuxContext),
423 };
#define NULL
Definition: coverity.c:32
void ff_argo_asf_parse_chunk_header(ArgoASFChunkHeader *hdr, const uint8_t *buf)
Definition: argo_asf.c:68
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
uint32_t byte_rate
Definition: argo_brp.c:51
#define MASK_HEADER_SIZE
Definition: argo_brp.c:37
int32_t stream_id
Definition: argo_brp.c:55
uint32_t flags
Definition: argo_asf.h:52
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
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
uint32_t duration_ms
Definition: argo_brp.c:76
#define BVID_HEADER_SIZE
Definition: argo_brp.c:36
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
static AVPacket pkt
#define blk(i)
Definition: sha.c:185
static int read_extradata(AVFormatContext *s, const ArgoBRPStreamHeader *hdr, void *buf, size_t bufsz)
Definition: argo_brp.c:108
uint32_t byte_rate
Definition: argo_brp.c:77
ArgoASFFileHeader basf
Definition: argo_brp.c:84
Format I/O context.
Definition: avformat.h:1239
static int argo_brp_probe(const AVProbeData *p)
Definition: argo_brp.c:100
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: codec_par.h:126
#define BRP_FILE_HEADER_SIZE
Definition: argo_brp.c:31
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
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 offset
uint32_t num_samples
Definition: argo_asf.h:48
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
uint32_t height
Definition: argo_brp.c:63
#define BRP_CODEC_ID_BASF
Definition: argo_brp.c:45
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
static int argo_brp_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: argo_brp.c:347
#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
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
uint32_t size
Definition: argo_brp.c:57
#define ASF_MIN_BUFFER_SIZE
Definition: argo_asf.h:35
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
uint16_t version_major
Definition: argo_asf.h:39
#define BRP_STREAM_HEADER_SIZE
Definition: argo_brp.c:33
uint32_t width
Definition: argo_brp.c:69
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define BRP_MAX_STREAMS
Definition: argo_brp.c:34
static const uint16_t mask[17]
Definition: lzw.c:38
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
simple assert() macros that are a bit more flexible than ISO C assert().
uint32_t width
Definition: argo_brp.c:62
uint16_t version_minor
Definition: argo_asf.h:40
#define FFMAX(a, b)
Definition: common.h:94
#define BRP_CODEC_ID_MASK
Definition: argo_brp.c:46
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
int block_align
Audio only.
Definition: codec_par.h:177
#define BRP_TAG
Definition: argo_brp.c:30
#define BRP_BASF_LOOKAHEAD
Definition: argo_brp.c:35
uint32_t num_chunks
Definition: argo_asf.h:41
struct ArgoBRPDemuxContext::@245 basf
int ff_argo_asf_validate_file_header(AVFormatContext *s, const ArgoASFFileHeader *hdr)
Definition: argo_asf.c:57
ArgoBVIDHeader bvid
Definition: argo_brp.c:82
int32_t
#define s(width, name)
Definition: cbs_vp9.c:257
#define BRP_BLOCK_HEADER_SIZE
Definition: argo_brp.c:32
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
void ff_argo_asf_parse_file_header(ArgoASFFileHeader *hdr, const uint8_t *buf)
Definition: argo_asf.c:46
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
uint32_t magic
Definition: argo_brp.c:49
Stream structure.
Definition: avformat.h:880
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
uint32_t depth
Definition: argo_brp.c:64
uint32_t num_frames
Definition: argo_brp.c:61
#define ASF_CHUNK_HEADER_SIZE
Definition: argo_asf.h:33
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
uint32_t start_ms
Definition: argo_brp.c:56
uint32_t num_frames
Definition: argo_brp.c:68
#define BRP_CODEC_ID_BVID
Definition: argo_brp.c:44
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
uint32_t unk1
Definition: argo_asf.h:49
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: codec_par.h:115
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:929
uint32_t extradata_size
Definition: argo_brp.c:78
int sample_rate
Audio only.
Definition: codec_par.h:170
AVInputFormat ff_argo_brp_demuxer
Definition: argo_brp.c:416
Main libavformat public API header.
#define BRP_MIN_BUFFER_SIZE
Definition: argo_brp.c:38
uint32_t codec_id
Definition: argo_brp.c:74
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:919
uint32_t height
Definition: argo_brp.c:70
uint32_t num_blocks
Definition: argo_asf.h:47
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:931
uint16_t sample_rate
Definition: argo_asf.h:50
uint32_t num_streams
Definition: argo_brp.c:50
ArgoBRPStreamHeader streams[BRP_MAX_STREAMS]
Definition: argo_brp.c:92
static int argo_brp_read_header(AVFormatContext *s)
Definition: argo_brp.c:150
void * priv_data
Format private data.
Definition: avformat.h:1267
union ArgoBRPStreamHeader::@244 extradata
ArgoMASKHeader mask
Definition: argo_brp.c:86
#define ASF_FILE_HEADER_SIZE
Definition: argo_asf.h:32
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 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
int ff_argo_asf_fill_stream(AVFormatContext *s, AVStream *st, const ArgoASFFileHeader *fhdr, const ArgoASFChunkHeader *ckhdr)
Definition: argo_asf.c:78
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
ArgoASFChunkHeader ckhdr
Definition: argo_brp.c:96
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
uint16_t unk2
Definition: argo_asf.h:51
ArgoBRPFileHeader fhdr
Definition: argo_brp.c:91
const char * name
Definition: opengl_enc.c:102