FFmpeg: libavformat/bink.c Source File

FFmpeg
bink.c
Go to the documentation of this file.
1 /*
2  * Bink demuxer
3  * Copyright (c) 2008-2010 Peter Ross (pross@xvid.org)
4  * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)
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 /**
24  * @file
25  * Bink demuxer
26  *
27  * Technical details here:
28  * http://wiki.multimedia.cx/index.php?title=Bink_Container
29  */
30 
31 #include <inttypes.h>
32 
33 #include "libavutil/channel_layout.h"
34 #include "libavutil/intreadwrite.h"
35 #include "avformat.h"
36 #include "demux.h"
37 #include "internal.h"
38 
39  enum BinkAudFlags {
40   BINK_AUD_16BITS = 0x4000, ///< prefer 16-bit output
41   BINK_AUD_STEREO = 0x2000,
42   BINK_AUD_USEDCT = 0x1000,
43 };
44 
45  #define BINK_EXTRADATA_SIZE 1
46  #define BINK_MAX_AUDIO_TRACKS 256
47  #define BINK_MAX_WIDTH 7680
48  #define BINK_MAX_HEIGHT 4800
49  #define SMUSH_BLOCK_SIZE 512
50 
51  typedef struct BinkDemuxContext {
52   uint32_t file_size;
53 
54   uint32_t num_audio_tracks;
55   int current_track; ///< audio track to return in next packet
56   int64_t video_pts;
57   int64_t audio_pts[BINK_MAX_AUDIO_TRACKS];
58 
59   uint32_t remain_packet_size;
60   int flags;
61   int smush_size;
62 } BinkDemuxContext;
63 
64  static int probe(const AVProbeData *p)
65 {
66  const uint8_t *b = p->buf;
67  int smush = AV_RN32(p->buf) == AV_RN32("SMUS");
68 
69  do {
70  if (((b[0] == 'B' && b[1] == 'I' && b[2] == 'K' && /* Bink 1 */
71  (b[3] == 'b' || b[3] == 'f' || b[3] == 'g' || b[3] == 'h' || b[3] == 'i' ||
72  b[3] == 'k')) ||
73  (b[0] == 'K' && b[1] == 'B' && b[2] == '2' && /* Bink 2 */
74  (b[3] == 'a' || b[3] == 'd' || b[3] == 'f' || b[3] == 'g' || b[3] == 'h' ||
75  b[3] == 'i' || b[3] == 'j' || b[3] == 'k'))) &&
76  AV_RL32(b+8) > 0 && // num_frames
77  AV_RL32(b+20) > 0 && AV_RL32(b+20) <= BINK_MAX_WIDTH &&
78  AV_RL32(b+24) > 0 && AV_RL32(b+24) <= BINK_MAX_HEIGHT &&
79  AV_RL32(b+28) > 0 && AV_RL32(b+32) > 0) // fps num,den
80  return AVPROBE_SCORE_MAX;
81  b += SMUSH_BLOCK_SIZE;
82  } while (smush && b < p->buf + p->buf_size - 32);
83  return 0;
84 }
85 
86  static int read_header(AVFormatContext *s)
87 {
88  BinkDemuxContext *bink = s->priv_data;
89  AVIOContext *pb = s->pb;
90  uint32_t fps_num, fps_den;
91  AVStream *const vst = avformat_new_stream(s, NULL);
92  FFStream *const vsti = ffstream(vst);
93  unsigned int i;
94  uint32_t pos, next_pos;
95  uint16_t flags;
96  int next_keyframe = 1;
97  int keyframe;
98  int ret;
99  uint32_t signature;
100  uint8_t revision;
101 
102  if (!vst)
103  return AVERROR(ENOMEM);
104 
105  vst->codecpar->codec_tag = avio_rl32(pb);
106  if (vst->codecpar->codec_tag == AV_RL32("SMUS")) {
107  do {
108  bink->smush_size += SMUSH_BLOCK_SIZE;
109  avio_skip(pb, SMUSH_BLOCK_SIZE - 4);
110  vst->codecpar->codec_tag = avio_rl32(pb);
111  } while (!avio_feof(pb) && (vst->codecpar->codec_tag & 0xFFFFFF) != AV_RL32("BIK"));
112  if (avio_feof(pb)) {
113  av_log(s, AV_LOG_ERROR, "invalid SMUSH header: BIK not found\n");
114  return AVERROR_INVALIDDATA;
115  }
116  }
117 
118  bink->file_size = avio_rl32(pb) + 8;
119  vst->duration = avio_rl32(pb);
120 
121  if (vst->duration > 1000000) {
122  av_log(s, AV_LOG_ERROR, "invalid header: more than 1000000 frames\n");
123  return AVERROR(EIO);
124  }
125 
126  if (avio_rl32(pb) > bink->file_size) {
127  av_log(s, AV_LOG_ERROR,
128  "invalid header: largest frame size greater than file size\n");
129  return AVERROR(EIO);
130  }
131 
132  avio_skip(pb, 4);
133 
134  vst->codecpar->width = avio_rl32(pb);
135  vst->codecpar->height = avio_rl32(pb);
136 
137  fps_num = avio_rl32(pb);
138  fps_den = avio_rl32(pb);
139  if (fps_num == 0 || fps_den == 0) {
140  av_log(s, AV_LOG_ERROR,
141  "invalid header: invalid fps (%"PRIu32"/%"PRIu32")\n",
142  fps_num, fps_den);
143  return AVERROR(EIO);
144  }
145  avpriv_set_pts_info(vst, 64, fps_den, fps_num);
146  vst->avg_frame_rate = av_inv_q(vst->time_base);
147 
148  vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
149  vst->codecpar->codec_id = AV_CODEC_ID_BINKVIDEO;
150 
151  if ((vst->codecpar->codec_tag & 0xFFFFFF) == MKTAG('K', 'B', '2', 0)) {
152  av_log(s, AV_LOG_WARNING, "Bink 2 video is not implemented\n");
153  vst->codecpar->codec_id = AV_CODEC_ID_NONE;
154  }
155 
156  if ((ret = ff_get_extradata(s, vst->codecpar, pb, 4)) < 0)
157  return ret;
158 
159  bink->num_audio_tracks = avio_rl32(pb);
160 
161  if (bink->num_audio_tracks > BINK_MAX_AUDIO_TRACKS) {
162  av_log(s, AV_LOG_ERROR,
163  "invalid header: more than "AV_STRINGIFY(BINK_MAX_AUDIO_TRACKS)" audio tracks (%"PRIu32")\n",
164  bink->num_audio_tracks);
165  return AVERROR(EIO);
166  }
167 
168  signature = (vst->codecpar->codec_tag & 0xFFFFFF);
169  revision = ((vst->codecpar->codec_tag >> 24) % 0xFF);
170 
171  if ((signature == AV_RL32("BIK") && (revision == 'k')) ||
172  (signature == AV_RL32("KB2") && (revision == 'i' || revision == 'j' || revision == 'k')))
173  avio_skip(pb, 4); /* unknown new field */
174 
175  if (bink->num_audio_tracks) {
176  avio_skip(pb, 4 * bink->num_audio_tracks); /* max decoded size */
177 
178  for (i = 0; i < bink->num_audio_tracks; i++) {
179  AVStream *const ast = avformat_new_stream(s, NULL);
180  if (!ast)
181  return AVERROR(ENOMEM);
182  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
183  ast->codecpar->codec_tag = 0;
184  ast->codecpar->sample_rate = avio_rl16(pb);
185  avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
186  flags = avio_rl16(pb);
187  ast->codecpar->codec_id = flags & BINK_AUD_USEDCT ?
188  AV_CODEC_ID_BINKAUDIO_DCT : AV_CODEC_ID_BINKAUDIO_RDFT;
189  if (flags & BINK_AUD_STEREO) {
190  ast->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
191  } else {
192  ast->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
193  }
194  if ((ret = ff_alloc_extradata(ast->codecpar, 4)) < 0)
195  return ret;
196  AV_WL32(ast->codecpar->extradata, vst->codecpar->codec_tag);
197  }
198 
199  for (i = 0; i < bink->num_audio_tracks; i++)
200  s->streams[i + 1]->id = avio_rl32(pb);
201  }
202 
203  /* frame index table */
204  next_pos = avio_rl32(pb);
205  for (i = 0; i < vst->duration; i++) {
206  pos = next_pos;
207  keyframe = next_keyframe;
208  if (i == vst->duration - 1) {
209  next_pos = bink->file_size;
210  next_keyframe = 0;
211  } else {
212  next_pos = avio_rl32(pb);
213  next_keyframe = next_pos & 1;
214  }
215  pos &= ~1;
216  next_pos &= ~1;
217 
218  if (next_pos <= pos) {
219  av_log(s, AV_LOG_ERROR, "invalid frame index table\n");
220  return AVERROR(EIO);
221  }
222  if ((ret = av_add_index_entry(vst, pos, i, next_pos - pos, 0,
223  keyframe ? AVINDEX_KEYFRAME : 0)) < 0)
224  return ret;
225  }
226 
227  if (vsti->index_entries)
228  avio_seek(pb, vsti->index_entries[0].pos + bink->smush_size, SEEK_SET);
229  else
230  avio_skip(pb, 4);
231 
232  bink->current_track = -1;
233  return 0;
234 }
235 
236  static int read_packet(AVFormatContext *s, AVPacket *pkt)
237 {
238  BinkDemuxContext *bink = s->priv_data;
239  AVIOContext *pb = s->pb;
240  int ret;
241 
242  if (bink->current_track < 0) {
243  int index_entry;
244  AVStream *st = s->streams[0]; // stream 0 is video stream with index
245  FFStream *const sti = ffstream(st);
246 
247  if (bink->video_pts >= st->duration)
248  return AVERROR_EOF;
249 
250  index_entry = av_index_search_timestamp(st, bink->video_pts,
251  AVSEEK_FLAG_ANY);
252  if (index_entry < 0) {
253  av_log(s, AV_LOG_ERROR,
254  "could not find index entry for frame %"PRId64"\n",
255  bink->video_pts);
256  return AVERROR(EIO);
257  }
258 
259  bink->remain_packet_size = sti->index_entries[index_entry].size;
260  bink->flags = sti->index_entries[index_entry].flags;
261  bink->current_track = 0;
262  }
263 
264  while (bink->current_track < bink->num_audio_tracks) {
265  uint32_t audio_size = avio_rl32(pb);
266  if (audio_size > bink->remain_packet_size - 4) {
267  av_log(s, AV_LOG_ERROR,
268  "frame %"PRId64": audio size in header (%"PRIu32") > size of packet left (%"PRIu32")\n",
269  bink->video_pts, audio_size, bink->remain_packet_size);
270  return AVERROR(EIO);
271  }
272  bink->remain_packet_size -= 4 + audio_size;
273  bink->current_track++;
274  if (audio_size >= 4) {
275  /* get one audio packet per track */
276  if ((ret = av_get_packet(pb, pkt, audio_size)) < 0)
277  return ret;
278  pkt->stream_index = bink->current_track;
279  pkt->pts = bink->audio_pts[bink->current_track - 1];
280 
281  /* Each audio packet reports the number of decompressed samples
282  (in bytes). We use this value to calculate the audio PTS */
283  if (pkt->size >= 4)
284  bink->audio_pts[bink->current_track -1] +=
285  AV_RL32(pkt->data) / (2 * s->streams[bink->current_track]->codecpar->ch_layout.nb_channels);
286  return 0;
287  } else {
288  avio_skip(pb, audio_size);
289  }
290  }
291 
292  /* get video packet */
293  if ((ret = av_get_packet(pb, pkt, bink->remain_packet_size)) < 0)
294  return ret;
295  pkt->stream_index = 0;
296  pkt->pts = bink->video_pts++;
297  if (bink->flags & AVINDEX_KEYFRAME)
298  pkt->flags |= AV_PKT_FLAG_KEY;
299 
300  /* -1 instructs the next call to read_packet() to read the next frame */
301  bink->current_track = -1;
302 
303  return 0;
304 }
305 
306  static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
307 {
308  BinkDemuxContext *bink = s->priv_data;
309  AVStream *vst = s->streams[0];
310  FFStream *const vsti = ffstream(vst);
311  int64_t ret;
312 
313  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
314  return -1;
315 
316  /* seek to the first frame */
317  ret = avio_seek(s->pb, vsti->index_entries[0].pos + bink->smush_size, SEEK_SET);
318  if (ret < 0)
319  return ret;
320 
321  bink->video_pts = 0;
322  memset(bink->audio_pts, 0, sizeof(bink->audio_pts));
323  bink->current_track = -1;
324  return 0;
325 }
326 
327  const FFInputFormat ff_bink_demuxer = {
328  .p.name = "bink",
329  .p.long_name = NULL_IF_CONFIG_SMALL("Bink"),
330  .p.flags = AVFMT_SHOW_IDS,
331  .priv_data_size = sizeof(BinkDemuxContext),
332  .read_probe = probe,
333  .read_header = read_header,
334  .read_packet = read_packet,
335  .read_seek = read_seek,
336 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
BINK_AUD_STEREO
@ BINK_AUD_STEREO
Definition: bink.c:41
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
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:477
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:379
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
BinkAudFlags
BinkAudFlags
Definition: bink.c:39
int64_t
long long int64_t
Definition: coverity.c:34
BinkDemuxContext::video_pts
int64_t video_pts
Definition: bink.c:56
AVPacket::data
uint8_t * data
Definition: packet.h:522
b
#define b
Definition: input.c:41
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
BinkDemuxContext
Definition: bink.c:51
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
BinkDemuxContext::file_size
uint32_t file_size
Definition: bink.c:52
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
BinkDemuxContext::current_track
int current_track
audio track to return in next packet
Definition: bink.c:55
ff_get_extradata
int ff_get_extradata(void *logctx, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: demux_utils.c:335
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
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2435
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:120
BinkDemuxContext::num_audio_tracks
uint32_t num_audio_tracks
Definition: bink.c:54
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:802
ff_bink_demuxer
const FFInputFormat ff_bink_demuxer
Definition: bink.c:327
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:713
signature
static const char signature[]
Definition: ipmovie.c:591
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
read_seek
static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: bink.c:306
BINK_AUD_USEDCT
@ BINK_AUD_USEDCT
Definition: bink.c:42
BINK_MAX_AUDIO_TRACKS
#define BINK_MAX_AUDIO_TRACKS
Definition: bink.c:46
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
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
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
AV_CODEC_ID_BINKAUDIO_DCT
@ AV_CODEC_ID_BINKAUDIO_DCT
Definition: codec_id.h:488
BinkDemuxContext::flags
int flags
Definition: bink.c:60
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
SMUSH_BLOCK_SIZE
#define SMUSH_BLOCK_SIZE
Definition: bink.c:49
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:782
NULL
#define NULL
Definition: coverity.c:32
AVIndexEntry::flags
int flags
Definition: avformat.h:612
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:362
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
probe
static int probe(const AVProbeData *p)
Definition: bink.c:64
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
BinkDemuxContext::smush_size
int smush_size
Definition: bink.c:61
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:729
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVPacket::size
int size
Definition: packet.h:523
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:106
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
FFStream
Definition: internal.h:193
read_header
static int read_header(AVFormatContext *s)
Definition: bink.c:86
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
BINK_MAX_HEIGHT
#define BINK_MAX_HEIGHT
Definition: bink.c:48
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
BINK_AUD_16BITS
@ BINK_AUD_16BITS
prefer 16-bit output
Definition: bink.c:40
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:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_STRINGIFY
#define AV_STRINGIFY(s)
Definition: macros.h:66
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
demux.h
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:103
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:230
read_packet
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: bink.c:236
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
BinkDemuxContext::audio_pts
int64_t audio_pts[BINK_MAX_AUDIO_TRACKS]
Definition: bink.c:57
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
channel_layout.h
AV_CODEC_ID_BINKVIDEO
@ AV_CODEC_ID_BINKVIDEO
Definition: codec_id.h:187
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
BinkDemuxContext::remain_packet_size
uint32_t remain_packet_size
Definition: bink.c:59
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVPacket::stream_index
int stream_index
Definition: packet.h:524
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:317
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
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:378
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:499
FFInputFormat
Definition: demux.h:37
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
AV_CODEC_ID_BINKAUDIO_RDFT
@ AV_CODEC_ID_BINKAUDIO_RDFT
Definition: codec_id.h:487
BINK_MAX_WIDTH
#define BINK_MAX_WIDTH
Definition: bink.c:47
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:243
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:239
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:345
Generated on Thu Sep 26 2024 23:14:50 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /