FFmpeg
rpl.c
Go to the documentation of this file.
1 /*
2  * ARMovie/RPL demuxer
3  * Copyright (c) 2007 Christian Ohm, 2008 Eli Friedman
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 #include <stdlib.h>
24 
25 #include "libavutil/avstring.h"
26 #include "libavutil/dict.h"
27 #include "avformat.h"
28 #include "demux.h"
29 #include "internal.h"
30 
31 #define RPL_SIGNATURE "ARMovie\x0A"
32 #define RPL_SIGNATURE_SIZE 8
33 
34 /** 256 is arbitrary, but should be big enough for any reasonable file. */
35 #define RPL_LINE_LENGTH 256
36 
37 static int rpl_probe(const AVProbeData *p)
38 {
39  if (memcmp(p->buf, RPL_SIGNATURE, RPL_SIGNATURE_SIZE))
40  return 0;
41 
42  return AVPROBE_SCORE_MAX;
43 }
44 
45 typedef struct RPLContext {
46  // RPL header data
48 
49  // Stream position data
50  uint32_t chunk_number;
51  uint32_t chunk_part;
52  uint32_t frame_in_part;
53 } RPLContext;
54 
55 static int read_line(AVIOContext * pb, char* line, int bufsize)
56 {
57  int i;
58  for (i = 0; i < bufsize - 1; i++) {
59  int b = avio_r8(pb);
60  if (b == 0)
61  break;
62  if (b == '\n') {
63  line[i] = '\0';
64  return avio_feof(pb) ? -1 : 0;
65  }
66  line[i] = b;
67  }
68  line[i] = '\0';
69  return -1;
70 }
71 
72 static int32_t read_int(const char* line, const char** endptr, int* error)
73 {
74  unsigned long result = 0;
75  for (; *line>='0' && *line<='9'; line++) {
76  if (result > (0x7FFFFFFF - 9) / 10)
77  *error = -1;
78  result = 10 * result + *line - '0';
79  }
80  *endptr = line;
81  return result;
82 }
83 
85 {
86  char line[RPL_LINE_LENGTH];
87  const char *endptr;
88  *error |= read_line(pb, line, sizeof(line));
89  return read_int(line, &endptr, error);
90 }
91 
92 /** Parsing for fps, which can be a fraction. Unfortunately,
93  * the spec for the header leaves out a lot of details,
94  * so this is mostly guessing.
95  */
96 static AVRational read_fps(const char* line, int* error)
97 {
98  int64_t num, den = 1;
100  num = read_int(line, &line, error);
101  if (*line == '.')
102  line++;
103  for (; *line>='0' && *line<='9'; line++) {
104  // Truncate any numerator too large to fit into an int64_t
105  if (num > (INT64_MAX - 9) / 10 || den > INT64_MAX / 10)
106  break;
107  num = 10 * num + (*line - '0');
108  den *= 10;
109  }
110  if (!num)
111  *error = -1;
112  av_reduce(&result.num, &result.den, num, den, 0x7FFFFFFF);
113  return result;
114 }
115 
117 {
118  AVIOContext *pb = s->pb;
119  RPLContext *rpl = s->priv_data;
120  AVStream *vst = NULL, *ast = NULL;
121  int64_t total_audio_size;
122  int error = 0;
123  const char *endptr;
124  char audio_type[RPL_LINE_LENGTH];
125  char audio_codec[RPL_LINE_LENGTH];
126 
127  uint32_t i;
128 
129  int32_t video_format, audio_format, chunk_catalog_offset, number_of_chunks;
130  AVRational fps;
131 
132  char line[RPL_LINE_LENGTH];
133 
134  // The header for RPL/ARMovie files is 21 lines of text
135  // containing the various header fields. The fields are always
136  // in the same order, and other text besides the first
137  // number usually isn't important.
138  // (The spec says that there exists some significance
139  // for the text in a few cases; samples needed.)
140  error |= read_line(pb, line, sizeof(line)); // ARMovie
141  error |= read_line(pb, line, sizeof(line)); // movie name
142  av_dict_set(&s->metadata, "title" , line, 0);
143  error |= read_line(pb, line, sizeof(line)); // date/copyright
144  av_dict_set(&s->metadata, "copyright", line, 0);
145  error |= read_line(pb, line, sizeof(line)); // author and other
146  av_dict_set(&s->metadata, "author" , line, 0);
147 
148  // video headers
149  video_format = read_line_and_int(pb, &error);
150  if (video_format) {
151  vst = avformat_new_stream(s, NULL);
152  if (!vst)
153  return AVERROR(ENOMEM);
155  vst->codecpar->codec_tag = video_format;
156  vst->codecpar->width = read_line_and_int(pb, &error); // video width
157  vst->codecpar->height = read_line_and_int(pb, &error); // video height
158  vst->codecpar->bits_per_coded_sample = read_line_and_int(pb, &error); // video bits per sample
159 
160  // Figure out the video codec
161  switch (vst->codecpar->codec_tag) {
162 #if 0
163  case 122:
164  vst->codecpar->codec_id = AV_CODEC_ID_ESCAPE122;
165  break;
166 #endif
167  case 124:
169  // The header is wrong here, at least sometimes
170  vst->codecpar->bits_per_coded_sample = 16;
171  break;
172  case 130:
174  break;
175  default:
176  avpriv_report_missing_feature(s, "Video format %s",
179  }
180  } else {
181  for (i = 0; i < 3; i++)
182  error |= read_line(pb, line, sizeof(line));
183  }
184 
185  error |= read_line(pb, line, sizeof(line)); // video frames per second
186  fps = read_fps(line, &error);
187  if (vst)
188  avpriv_set_pts_info(vst, 32, fps.den, fps.num);
189 
190  // Audio headers
191 
192  // ARMovie supports multiple audio tracks; I don't have any
193  // samples, though. This code will ignore additional tracks.
194  error |= read_line(pb, line, sizeof(line));
195  audio_format = read_int(line, &endptr, &error); // audio format ID
196  av_strlcpy(audio_codec, endptr, RPL_LINE_LENGTH);
197  if (audio_format) {
198  int channels;
199  ast = avformat_new_stream(s, NULL);
200  if (!ast)
201  return AVERROR(ENOMEM);
202  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
203  ast->codecpar->codec_tag = audio_format;
204  ast->codecpar->sample_rate = read_line_and_int(pb, &error); // audio bitrate
205  channels = read_line_and_int(pb, &error); // number of audio channels
206  error |= read_line(pb, line, sizeof(line));
207  ast->codecpar->bits_per_coded_sample = read_int(line, &endptr, &error); // audio bits per sample
208  av_strlcpy(audio_type, endptr, RPL_LINE_LENGTH);
209  ast->codecpar->ch_layout.nb_channels = channels;
210  // At least one sample uses 0 for ADPCM, which is really 4 bits
211  // per sample.
212  if (ast->codecpar->bits_per_coded_sample == 0)
213  ast->codecpar->bits_per_coded_sample = 4;
214 
215  ast->codecpar->bit_rate = ast->codecpar->sample_rate *
216  (int64_t)ast->codecpar->ch_layout.nb_channels;
217  if (ast->codecpar->bit_rate > INT64_MAX / ast->codecpar->bits_per_coded_sample)
218  return AVERROR_INVALIDDATA;
219  ast->codecpar->bit_rate *= ast->codecpar->bits_per_coded_sample;
220 
221  ast->codecpar->codec_id = AV_CODEC_ID_NONE;
222  switch (audio_format) {
223  case 1:
224  if (ast->codecpar->bits_per_coded_sample == 16) {
225  // 16-bit audio is always signed
226  ast->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
227  } else if (ast->codecpar->bits_per_coded_sample == 8) {
228  if (av_stristr(audio_type, "unsigned") != NULL)
229  ast->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
230  else if (av_stristr(audio_type, "linear") != NULL)
231  ast->codecpar->codec_id = AV_CODEC_ID_PCM_S8;
232  else
233  ast->codecpar->codec_id = AV_CODEC_ID_PCM_VIDC;
234  }
235  // There are some other formats listed as legal per the spec;
236  // samples needed.
237  break;
238  case 2:
239  if (av_stristr(audio_codec, "adpcm") != NULL) {
240  ast->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_ACORN;
241  }
242  break;
243  case 101:
244  if (ast->codecpar->bits_per_coded_sample == 8) {
245  // The samples with this kind of audio that I have
246  // are all unsigned.
247  ast->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
248  } else if (ast->codecpar->bits_per_coded_sample == 4) {
249  ast->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;
250  }
251  break;
252  }
253  if (ast->codecpar->codec_id == AV_CODEC_ID_NONE)
254  avpriv_request_sample(s, "Audio format %"PRId32" (%s)",
255  audio_format, audio_codec);
256  avpriv_set_pts_info(ast, 32, 1, ast->codecpar->bit_rate);
257  } else {
258  for (i = 0; i < 3; i++)
259  error |= read_line(pb, line, sizeof(line));
260  }
261 
262  if (s->nb_streams == 0)
263  return AVERROR_INVALIDDATA;
264 
265  rpl->frames_per_chunk = read_line_and_int(pb, &error); // video frames per chunk
266  if (vst && rpl->frames_per_chunk > 1 && vst->codecpar->codec_tag != 124)
268  "Don't know how to split frames for video format %s. "
269  "Video stream will be broken!\n", av_fourcc2str(vst->codecpar->codec_tag));
270 
271  number_of_chunks = read_line_and_int(pb, &error); // number of chunks in the file
272  if (number_of_chunks == INT_MAX)
273  return AVERROR_INVALIDDATA;
274 
275  // The number in the header is actually the index of the last chunk.
276  number_of_chunks++;
277 
278  error |= read_line(pb, line, sizeof(line)); // "even" chunk size in bytes
279  error |= read_line(pb, line, sizeof(line)); // "odd" chunk size in bytes
280  chunk_catalog_offset = // offset of the "chunk catalog"
281  read_line_and_int(pb, &error); // (file index)
282  error |= read_line(pb, line, sizeof(line)); // offset to "helpful" sprite
283  error |= read_line(pb, line, sizeof(line)); // size of "helpful" sprite
284  if (vst) {
285  error |= read_line(pb, line, sizeof(line)); // offset to key frame list
286  vst->duration = number_of_chunks * (int64_t)rpl->frames_per_chunk;
287  }
288 
289  // Read the index
290  avio_seek(pb, chunk_catalog_offset, SEEK_SET);
291  total_audio_size = 0;
292  for (i = 0; !error && i < number_of_chunks; i++) {
293  int64_t offset, video_size, audio_size;
294  error |= read_line(pb, line, sizeof(line));
295  if (3 != sscanf(line, "%"SCNd64" , %"SCNd64" ; %"SCNd64,
296  &offset, &video_size, &audio_size)) {
297  error = -1;
298  continue;
299  }
300  if (vst)
302  video_size, rpl->frames_per_chunk, 0);
303  if (ast)
304  av_add_index_entry(ast, offset + video_size, total_audio_size,
305  audio_size, audio_size * 8, 0);
306  if (total_audio_size/8 + (uint64_t)audio_size >= INT64_MAX/8)
307  return AVERROR_INVALIDDATA;
308  total_audio_size += audio_size * 8;
309  }
310 
311  if (error)
312  return AVERROR(EIO);
313 
314  return 0;
315 }
316 
318 {
319  RPLContext *rpl = s->priv_data;
320  AVIOContext *pb = s->pb;
321  AVStream* stream;
322  FFStream *sti;
323  AVIndexEntry* index_entry;
324  int ret;
325 
326  if (rpl->chunk_part == s->nb_streams) {
327  rpl->chunk_number++;
328  rpl->chunk_part = 0;
329  }
330 
331  stream = s->streams[rpl->chunk_part];
332  sti = ffstream(stream);
333 
334  if (rpl->chunk_number >= sti->nb_index_entries)
335  return AVERROR_EOF;
336 
337  index_entry = &sti->index_entries[rpl->chunk_number];
338 
339  if (rpl->frame_in_part == 0) {
340  if (avio_seek(pb, index_entry->pos, SEEK_SET) < 0)
341  return AVERROR(EIO);
342  }
343 
344  if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
345  stream->codecpar->codec_tag == 124) {
346  // We have to split Escape 124 frames because there are
347  // multiple frames per chunk in Escape 124 samples.
348  uint32_t frame_size;
349 
350  avio_skip(pb, 4); /* flags */
351  frame_size = avio_rl32(pb);
352  if (avio_feof(pb) || avio_seek(pb, -8, SEEK_CUR) < 0 || !frame_size)
353  return AVERROR(EIO);
354 
356  if (ret < 0)
357  return ret;
358  if (ret != frame_size)
359  return AVERROR(EIO);
360 
361  pkt->duration = 1;
362  pkt->pts = index_entry->timestamp + rpl->frame_in_part;
363  pkt->stream_index = rpl->chunk_part;
364 
365  rpl->frame_in_part++;
366  if (rpl->frame_in_part == rpl->frames_per_chunk) {
367  rpl->frame_in_part = 0;
368  rpl->chunk_part++;
369  }
370  } else {
371  ret = av_get_packet(pb, pkt, index_entry->size);
372  if (ret < 0)
373  return ret;
374  if (ret != index_entry->size)
375  return AVERROR(EIO);
376 
377  if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
378  // frames_per_chunk should always be one here; the header
379  // parsing will warn if it isn't.
380  pkt->duration = rpl->frames_per_chunk;
381  } else {
382  // All the audio codecs supported in this container
383  // (at least so far) are constant-bitrate.
384  pkt->duration = ret * 8;
385  }
386  pkt->pts = index_entry->timestamp;
387  pkt->stream_index = rpl->chunk_part;
388  rpl->chunk_part++;
389  }
390 
391  // None of the Escape formats have keyframes, and the ADPCM
392  // format used doesn't have keyframes.
393  if (rpl->chunk_number == 0 && rpl->frame_in_part == 0)
395 
396  return ret;
397 }
398 
400  .p.name = "rpl",
401  .p.long_name = NULL_IF_CONFIG_SMALL("RPL / ARMovie"),
402  .priv_data_size = sizeof(RPLContext),
406 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
RPLContext::chunk_number
uint32_t chunk_number
Definition: rpl.c:50
AV_CODEC_ID_ESCAPE130
@ AV_CODEC_ID_ESCAPE130
Definition: codec_id.h:222
RPLContext
Definition: rpl.c:45
av_stristr
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
Definition: avstring.c:58
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
RPL_SIGNATURE_SIZE
#define RPL_SIGNATURE_SIZE
Definition: rpl.c:32
b
#define b
Definition: input.c:41
RPLContext::chunk_part
uint32_t chunk_part
Definition: rpl.c:51
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:542
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
AVIndexEntry
Definition: avformat.h:602
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
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:853
RPL_LINE_LENGTH
#define RPL_LINE_LENGTH
256 is arbitrary, but should be big enough for any reasonable file.
Definition: rpl.c:35
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
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:121
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:332
pkt
AVPacket * pkt
Definition: movenc.c:60
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
read_int
static int32_t read_int(const char *line, const char **endptr, int *error)
Definition: rpl.c:72
AV_CODEC_ID_ADPCM_IMA_ACORN
@ AV_CODEC_ID_ADPCM_IMA_ACORN
Definition: codec_id.h:417
read_line
static int read_line(AVIOContext *pb, char *line, int bufsize)
Definition: rpl.c:55
s
#define s(width, name)
Definition: cbs_vp9.c:198
read_fps
static AVRational read_fps(const char *line, int *error)
Parsing for fps, which can be a fraction.
Definition: rpl.c:96
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition: codec_id.h:390
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
frame_size
int frame_size
Definition: mxfenc.c:2423
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AVIndexEntry::size
int size
Definition: avformat.h:613
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:604
channels
channels
Definition: aptx.h:31
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FFStream::nb_index_entries
int nb_index_entries
Definition: internal.h:251
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
rpl_read_header
static int rpl_read_header(AVFormatContext *s)
Definition: rpl.c:116
AV_CODEC_ID_PCM_VIDC
@ AV_CODEC_ID_PCM_VIDC
Definition: codec_id.h:363
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
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:94
FFStream
Definition: internal.h:193
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
RPL_SIGNATURE
#define RPL_SIGNATURE
Definition: rpl.c:31
offset
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
Definition: writing_filters.txt:86
line
Definition: graph2dot.c:48
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
rpl_probe
static int rpl_probe(const AVProbeData *p)
Definition: rpl.c:37
AVCodecParameters::height
int height
Definition: codec_par.h:135
demux.h
ff_rpl_demuxer
const FFInputFormat ff_rpl_demuxer
Definition: rpl.c:399
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:91
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
avformat.h
dict.h
AV_CODEC_ID_ESCAPE124
@ AV_CODEC_ID_ESCAPE124
Definition: codec_id.h:167
read_line_and_int
static int32_t read_line_and_int(AVIOContext *pb, int *error)
Definition: rpl.c:84
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVPacket::stream_index
int stream_index
Definition: packet.h:526
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:249
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:333
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
RPLContext::frame_in_part
uint32_t frame_in_part
Definition: rpl.c:52
rpl_read_packet
static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rpl.c:317
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:88
FFInputFormat
Definition: demux.h:37
int32_t
int32_t
Definition: audioconvert.c:56
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
avstring.h
line
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:40
RPLContext::frames_per_chunk
int32_t frames_per_chunk
Definition: rpl.c:47
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:345
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346