FFmpeg  4.4.4
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 */
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";
118  } else if (hdr->codec_id == BRP_CODEC_ID_BASF) {
119  name = "BASF";
121  } else if (hdr->codec_id == BRP_CODEC_ID_MASK) {
122  name = "MASK";
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  if (bvid->num_frames == 0)
222  return AVERROR_INVALIDDATA;
223 
224  /* These are from 1990's games, sanity check this. */
225  if (bvid->width >= 65536 || bvid->height >= 65536 ||
226  bvid->depth > 24 || bvid->depth % 8 != 0) {
227  return AVERROR_INVALIDDATA;
228  }
229 
230  st->codecpar->width = bvid->width;
231  st->codecpar->height = bvid->height;
232  st->nb_frames = bvid->num_frames;
233  st->codecpar->bits_per_raw_sample = bvid->depth;
234  } else if (hdr->codec_id == BRP_CODEC_ID_BASF) {
235  /*
236  * It would make the demuxer significantly more complicated
237  * to support multiple BASF streams. I've never seen a file
238  * with more than one.
239  */
240  if (brp->basf.index >= 0) {
241  avpriv_request_sample(s, "Multiple BASF streams");
242  return AVERROR_PATCHWELCOME;
243  }
244 
247  brp->basf.index = i;
249 
250  if ((ret = ff_argo_asf_validate_file_header(s, &hdr->extradata.basf)) < 0)
251  return ret;
252 
253  st->nb_frames = hdr->extradata.basf.num_chunks;
254  } else if (hdr->codec_id == BRP_CODEC_ID_MASK) {
256 
258 
259  mask->num_frames = AV_RL32(buf + 0);
260  mask->width = AV_RL32(buf + 4);
261  mask->height = AV_RL32(buf + 8);
262 
263  st->nb_frames = mask->num_frames;
264  } else {
265  av_assert0(0); /* Caught above, should never happen. */
266  }
267  }
268 
269  /* Try to find the first BASF chunk. */
270  if (brp->basf.index >= 0) {
271  AVStream *st = s->streams[brp->basf.index];
272  ArgoBRPStreamHeader *hdr = brp->streams + brp->basf.index;
274  int64_t offset;
275  int i;
276 
279 
280  if ((ret = avio_tell(s->pb)) < 0)
281  return ret;
282 
283  offset = ret;
284 
285  av_log(s, AV_LOG_TRACE, "Searching %d blocks for BASF...", BRP_BASF_LOOKAHEAD);
286 
287  for (i = 0; i < BRP_BASF_LOOKAHEAD; i++) {
288  if ((ret = avio_read(pb, buf, BRP_BLOCK_HEADER_SIZE)) < 0)
289  return ret;
290  else if (ret != BRP_BLOCK_HEADER_SIZE)
291  return AVERROR(EIO);
292 
293  blk.stream_id = AV_RL32(buf + 0);
294  blk.start_ms = AV_RL32(buf + 4);
295  blk.size = AV_RL32(buf + 8);
296 
297  if (blk.stream_id == brp->basf.index || blk.stream_id == -1)
298  break;
299 
300  if ((ret = avio_skip(pb, blk.size)) < 0)
301  return ret;
302  }
303 
304  if (i == BRP_BASF_LOOKAHEAD || blk.stream_id == -1) {
305  /* Don't error here, as there may still be a valid video stream. */
306  av_log(s, AV_LOG_TRACE, "not found\n");
307  goto done;
308  }
309 
310  av_log(s, AV_LOG_TRACE, "found at index %d\n", i);
311 
312  if (blk.size < ASF_CHUNK_HEADER_SIZE)
313  return AVERROR_INVALIDDATA;
314 
315  if ((ret = avio_read(pb, buf, ASF_CHUNK_HEADER_SIZE)) < 0)
316  return ret;
317  else if (ret != ASF_CHUNK_HEADER_SIZE)
318  return AVERROR(EIO);
319 
321 
322  /*
323  * Special Case Hack. It seems that in files where the BASF block isn't first,
324  * v1.1 streams are allowed to be non-22050...
325  * Bump the version to 1.2 so ff_argo_asf_fill_stream() doesn't "correct" it.
326  *
327  * Found in Alien Odyssey games files in:
328  * ./GRAPHICS/COMMBUNK/{{COMADD1,COMM2_{1,2,3E},COMM3_{2,3,4,5,6}},FADE{1,2}}.BRP
329  *
330  * Either this format really inconsistent, or FX Fighter and Croc just ignored the
331  * sample rate field...
332  */
333  if (i != 0 && hdr->extradata.basf.version_major == 1 && hdr->extradata.basf.version_minor == 1)
334  hdr->extradata.basf.version_minor = 2;
335 
336  if ((ret = ff_argo_asf_fill_stream(s, st, &hdr->extradata.basf, &brp->basf.ckhdr)) < 0)
337  return ret;
338 
339  /* Convert ms to samples. */
340  st->start_time = av_rescale_rnd(blk.start_ms, st->codecpar->sample_rate, 1000, AV_ROUND_UP);
342 
343 done:
344  if ((ret = avio_seek(s->pb, offset, SEEK_SET)) < 0)
345  return ret;
346  }
347  return 0;
348 }
349 
351 {
352  ArgoBRPDemuxContext *brp = s->priv_data;
354  const ArgoBRPStreamHeader *shdr;
355  AVStream *st;
357  ArgoASFChunkHeader ckhdr;
358  int ret;
359 
360  if ((ret = avio_read(s->pb, buf, BRP_BLOCK_HEADER_SIZE)) < 0)
361  return ret;
362  else if (ret != BRP_BLOCK_HEADER_SIZE)
363  return AVERROR(EIO);
364 
365  blk.stream_id = AV_RL32(buf + 0);
366  blk.start_ms = AV_RL32(buf + 4);
367  blk.size = AV_RL32(buf + 8);
368 
369  if (blk.stream_id == -1)
370  return AVERROR_EOF;
371 
372  if (blk.stream_id < -1 || blk.stream_id >= s->nb_streams)
373  return AVERROR_INVALIDDATA;
374 
375  st = s->streams[blk.stream_id];
376  shdr = brp->streams + blk.stream_id;
377 
378  if (blk.stream_id == brp->basf.index) {
379  if (blk.size < ASF_CHUNK_HEADER_SIZE)
380  return AVERROR_INVALIDDATA;
381 
382  if ((ret = avio_read(s->pb, buf, ASF_CHUNK_HEADER_SIZE)) < 0)
383  return ret;
384 
385  ff_argo_asf_parse_chunk_header(&ckhdr, buf);
386 
387  /* Ensure the chunk attributes are the same. */
388  if (ckhdr.sample_rate != brp->basf.ckhdr.sample_rate ||
389  ckhdr.flags != brp->basf.ckhdr.flags ||
390  ckhdr.unk1 != brp->basf.ckhdr.unk1 ||
391  ckhdr.unk2 != brp->basf.ckhdr.unk2)
392  return AVERROR_INVALIDDATA;
393 
394  blk.size -= ASF_CHUNK_HEADER_SIZE;
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 };
int ff_argo_asf_validate_file_header(AVFormatContext *s, const ArgoASFFileHeader *hdr)
Definition: argo_asf.c:57
void ff_argo_asf_parse_file_header(ArgoASFFileHeader *hdr, const uint8_t *buf)
Definition: argo_asf.c:46
int ff_argo_asf_fill_stream(AVFormatContext *s, AVStream *st, const ArgoASFFileHeader *fhdr, const ArgoASFChunkHeader *ckhdr)
Definition: argo_asf.c:78
void ff_argo_asf_parse_chunk_header(ArgoASFChunkHeader *hdr, const uint8_t *buf)
Definition: argo_asf.c:68
#define ASF_CHUNK_HEADER_SIZE
Definition: argo_asf.h:33
#define ASF_FILE_HEADER_SIZE
Definition: argo_asf.h:32
#define ASF_MIN_BUFFER_SIZE
Definition: argo_asf.h:35
#define BRP_CODEC_ID_MASK
Definition: argo_brp.c:46
#define BRP_STREAM_HEADER_SIZE
Definition: argo_brp.c:33
#define BRP_CODEC_ID_BASF
Definition: argo_brp.c:45
#define BRP_TAG
Definition: argo_brp.c:30
#define BRP_MAX_STREAMS
Definition: argo_brp.c:34
#define BRP_CODEC_ID_BVID
Definition: argo_brp.c:44
#define BVID_HEADER_SIZE
Definition: argo_brp.c:36
static int read_extradata(AVFormatContext *s, const ArgoBRPStreamHeader *hdr, void *buf, size_t bufsz)
Definition: argo_brp.c:108
#define BRP_FILE_HEADER_SIZE
Definition: argo_brp.c:31
static int argo_brp_read_header(AVFormatContext *s)
Definition: argo_brp.c:150
#define BRP_BLOCK_HEADER_SIZE
Definition: argo_brp.c:32
static int argo_brp_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: argo_brp.c:350
static int argo_brp_probe(const AVProbeData *p)
Definition: argo_brp.c:100
#define BRP_BASF_LOOKAHEAD
Definition: argo_brp.c:35
#define MASK_HEADER_SIZE
Definition: argo_brp.c:37
AVInputFormat ff_argo_brp_demuxer
Definition: argo_brp.c:416
#define BRP_MIN_BUFFER_SIZE
Definition: argo_brp.c:38
uint8_t
int32_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Main libavformat public API header.
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
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:310
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:337
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define AV_RL32
Definition: intreadwrite.h:146
#define s(width, name)
Definition: cbs_vp9.c:257
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:545
@ AV_CODEC_ID_ADPCM_ARGO
Definition: codec_id.h:396
@ AV_CODEC_ID_ARGO
Definition: codec_id.h:306
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4509
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
int i
Definition: input.c:407
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:4945
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static const uint16_t mask[17]
Definition: lzw.c:38
const char * name
Definition: qsvenc.c:46
#define blk(i)
Definition: sha.c:185
int width
Video only.
Definition: codec_par.h:126
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: codec_par.h:115
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
Format I/O context.
Definition: avformat.h:1232
Bytestream IO Context.
Definition: avio.h:161
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:924
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:912
uint32_t num_blocks
Definition: argo_asf.h:47
uint16_t unk2
Definition: argo_asf.h:51
uint16_t sample_rate
Definition: argo_asf.h:50
uint32_t unk1
Definition: argo_asf.h:49
uint32_t num_samples
Definition: argo_asf.h:48
uint32_t flags
Definition: argo_asf.h:52
uint32_t num_chunks
Definition: argo_asf.h:41
uint16_t version_minor
Definition: argo_asf.h:40
uint16_t version_major
Definition: argo_asf.h:39
uint32_t start_ms
Definition: argo_brp.c:56
int32_t stream_id
Definition: argo_brp.c:55
uint32_t size
Definition: argo_brp.c:57
ArgoBRPStreamHeader streams[BRP_MAX_STREAMS]
Definition: argo_brp.c:92
ArgoBRPFileHeader fhdr
Definition: argo_brp.c:91
ArgoASFChunkHeader ckhdr
Definition: argo_brp.c:96
struct ArgoBRPDemuxContext::@242 basf
uint32_t num_streams
Definition: argo_brp.c:50
uint32_t byte_rate
Definition: argo_brp.c:51
uint32_t magic
Definition: argo_brp.c:49
uint32_t codec_id
Definition: argo_brp.c:74
ArgoASFFileHeader basf
Definition: argo_brp.c:84
ArgoBVIDHeader bvid
Definition: argo_brp.c:82
uint32_t extradata_size
Definition: argo_brp.c:78
union ArgoBRPStreamHeader::@241 extradata
uint32_t duration_ms
Definition: argo_brp.c:76
ArgoMASKHeader mask
Definition: argo_brp.c:86
uint32_t byte_rate
Definition: argo_brp.c:77
uint32_t width
Definition: argo_brp.c:62
uint32_t depth
Definition: argo_brp.c:64
uint32_t height
Definition: argo_brp.c:63
uint32_t num_frames
Definition: argo_brp.c:61
uint32_t num_frames
Definition: argo_brp.c:68
uint32_t height
Definition: argo_brp.c:70
uint32_t width
Definition: argo_brp.c:69
#define avpriv_request_sample(...)
#define av_log(a,...)
AVPacket * pkt
Definition: movenc.c:59
int size
static const uint8_t offset[127][2]
Definition: vf_spp.c:107