FFmpeg: libavformat/rsd.c Source File

FFmpeg
rsd.c
Go to the documentation of this file.
1 /*
2  * RSD demuxer
3  * Copyright (c) 2013 James Almer
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 "libavcodec/bytestream.h"
23 #include "libavutil/intreadwrite.h"
24 #include "avformat.h"
25 #include "avio.h"
26 #include "internal.h"
27 
28  static const AVCodecTag rsd_tags[] = {
29  { AV_CODEC_ID_ADPCM_PSX, MKTAG('V','A','G',' ') },
30  { AV_CODEC_ID_ADPCM_THP_LE, MKTAG('G','A','D','P') },
31  { AV_CODEC_ID_ADPCM_THP, MKTAG('W','A','D','P') },
32  { AV_CODEC_ID_ADPCM_IMA_RAD, MKTAG('R','A','D','P') },
33  { AV_CODEC_ID_ADPCM_IMA_WAV, MKTAG('X','A','D','P') },
34  { AV_CODEC_ID_PCM_S16BE, MKTAG('P','C','M','B') },
35  { AV_CODEC_ID_PCM_S16LE, MKTAG('P','C','M',' ') },
36  { AV_CODEC_ID_XMA2, MKTAG('X','M','A',' ') },
37  { AV_CODEC_ID_NONE, 0 },
38 };
39 
40  static const uint32_t rsd_unsupported_tags[] = {
41  MKTAG('O','G','G',' '),
42 };
43 
44  static int rsd_probe(AVProbeData *p)
45 {
46  if (memcmp(p->buf, "RSD", 3) || p->buf[3] - '0' < 2 || p->buf[3] - '0' > 6)
47  return 0;
48  if (AV_RL32(p->buf + 8) > 256 || !AV_RL32(p->buf + 8))
49  return AVPROBE_SCORE_MAX / 8;
50  if (AV_RL32(p->buf + 16) > 8*48000 || !AV_RL32(p->buf + 16))
51  return AVPROBE_SCORE_MAX / 8;
52  return AVPROBE_SCORE_MAX;
53 }
54 
55  static int rsd_read_header(AVFormatContext *s)
56 {
57  AVIOContext *pb = s->pb;
58  int i, ret, version, start = 0x800;
59  AVCodecParameters *par;
60  AVStream *st = avformat_new_stream(s, NULL);
61 
62  if (!st)
63  return AVERROR(ENOMEM);
64 
65  avio_skip(pb, 3); // "RSD"
66  version = avio_r8(pb) - '0';
67 
68  par = st->codecpar;
69  par->codec_type = AVMEDIA_TYPE_AUDIO;
70  par->codec_tag = avio_rl32(pb);
71  par->codec_id = ff_codec_get_id(rsd_tags, par->codec_tag);
72  if (!par->codec_id) {
73  const char *tag_buf = av_fourcc2str(par->codec_tag);
74  for (i=0; i < FF_ARRAY_ELEMS(rsd_unsupported_tags); i++) {
75  if (par->codec_tag == rsd_unsupported_tags[i]) {
76  avpriv_request_sample(s, "Codec tag: %s", tag_buf);
77  return AVERROR_PATCHWELCOME;
78  }
79  }
80  av_log(s, AV_LOG_ERROR, "Unknown codec tag: %s\n", tag_buf);
81  return AVERROR_INVALIDDATA;
82  }
83 
84  par->channels = avio_rl32(pb);
85  if (par->channels <= 0 || par->channels > INT_MAX / 36) {
86  av_log(s, AV_LOG_ERROR, "Invalid number of channels: %d\n", par->channels);
87  return AVERROR_INVALIDDATA;
88  }
89 
90  avio_skip(pb, 4); // Bit depth
91  par->sample_rate = avio_rl32(pb);
92  if (!par->sample_rate)
93  return AVERROR_INVALIDDATA;
94 
95  avio_skip(pb, 4); // Unknown
96 
97  switch (par->codec_id) {
98  case AV_CODEC_ID_XMA2:
99  par->block_align = 2048;
100  ff_alloc_extradata(par, 34);
101  if (!par->extradata)
102  return AVERROR(ENOMEM);
103  memset(par->extradata, 0, 34);
104  break;
105  case AV_CODEC_ID_ADPCM_PSX:
106  par->block_align = 16 * par->channels;
107  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
108  st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
109  break;
110  case AV_CODEC_ID_ADPCM_IMA_RAD:
111  par->block_align = 20 * par->channels;
112  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
113  st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
114  break;
115  case AV_CODEC_ID_ADPCM_IMA_WAV:
116  if (version == 2)
117  start = avio_rl32(pb);
118 
119  par->bits_per_coded_sample = 4;
120  par->block_align = 36 * par->channels;
121  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
122  st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
123  break;
124  case AV_CODEC_ID_ADPCM_THP_LE:
125  /* RSD3GADP is mono, so only alloc enough memory
126  to store the coeff table for a single channel. */
127 
128  start = avio_rl32(pb);
129 
130  if ((ret = ff_get_extradata(s, par, s->pb, 32)) < 0)
131  return ret;
132  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
133  st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
134  break;
135  case AV_CODEC_ID_ADPCM_THP:
136  par->block_align = 8 * par->channels;
137  avio_skip(s->pb, 0x1A4 - avio_tell(s->pb));
138 
139  if ((ret = ff_alloc_extradata(st->codecpar, 32 * par->channels)) < 0)
140  return ret;
141 
142  for (i = 0; i < par->channels; i++) {
143  avio_read(s->pb, st->codecpar->extradata + 32 * i, 32);
144  avio_skip(s->pb, 8);
145  }
146  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
147  st->duration = (avio_size(pb) - start) / (8 * par->channels) * 14;
148  break;
149  case AV_CODEC_ID_PCM_S16LE:
150  case AV_CODEC_ID_PCM_S16BE:
151  if (version != 4)
152  start = avio_rl32(pb);
153 
154  if (pb->seekable & AVIO_SEEKABLE_NORMAL)
155  st->duration = (avio_size(pb) - start) / 2 / par->channels;
156  break;
157  }
158 
159  avio_skip(pb, start - avio_tell(pb));
160  if (par->codec_id == AV_CODEC_ID_XMA2) {
161  avio_skip(pb, avio_rb32(pb) + avio_rb32(pb));
162  st->duration = avio_rb32(pb);
163  }
164 
165  avpriv_set_pts_info(st, 64, 1, par->sample_rate);
166 
167  return 0;
168 }
169 
170  static int rsd_read_packet(AVFormatContext *s, AVPacket *pkt)
171 {
172  AVCodecParameters *par = s->streams[0]->codecpar;
173  int ret, size = 1024;
174  int64_t pos;
175 
176  if (avio_feof(s->pb))
177  return AVERROR_EOF;
178 
179  pos = avio_tell(s->pb);
180  if (par->codec_id == AV_CODEC_ID_ADPCM_IMA_RAD ||
181  par->codec_id == AV_CODEC_ID_ADPCM_PSX ||
182  par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
183  par->codec_id == AV_CODEC_ID_XMA2) {
184  ret = av_get_packet(s->pb, pkt, par->block_align);
185  } else if (par->codec_tag == MKTAG('W','A','D','P') &&
186  par->channels > 1) {
187  int i, ch;
188 
189  ret = av_new_packet(pkt, par->block_align);
190  if (ret < 0)
191  return ret;
192  for (i = 0; i < 4; i++) {
193  for (ch = 0; ch < par->channels; ch++) {
194  pkt->data[ch * 8 + i * 2 + 0] = avio_r8(s->pb);
195  pkt->data[ch * 8 + i * 2 + 1] = avio_r8(s->pb);
196  }
197  }
198  ret = 0;
199  } else {
200  ret = av_get_packet(s->pb, pkt, size);
201  }
202 
203  if (par->codec_id == AV_CODEC_ID_XMA2 && pkt->size >= 1)
204  pkt->duration = (pkt->data[0] >> 2) * 512;
205 
206  pkt->pos = pos;
207  pkt->stream_index = 0;
208 
209  return ret;
210 }
211 
212  AVInputFormat ff_rsd_demuxer = {
213  .name = "rsd",
214  .long_name = NULL_IF_CONFIG_SMALL("GameCube RSD"),
215  .read_probe = rsd_probe,
216  .read_header = rsd_read_header,
217  .read_packet = rsd_read_packet,
218  .extensions = "rsd",
219  .codec_tag = (const AVCodecTag* const []){rsd_tags, 0},
220  .flags = AVFMT_GENERIC_INDEX,
221 };
NULL
#define NULL
Definition: coverity.c:32
s
const char * s
Definition: avisynth_c.h:768
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_CODEC_ID_NONE
Definition: avcodec.h:215
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
avio.h
Buffered I/O operations.
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3053
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1699
avpriv_set_pts_info
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:4737
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4152
AVPacket::size
int size
Definition: avcodec.h:1680
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
version
int version
Definition: avisynth_c.h:766
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AV_CODEC_ID_ADPCM_IMA_WAV
Definition: avcodec.h:493
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4144
AVFormatContext
Format I/O context.
Definition: avformat.h:1349
rsd_read_packet
static int rsd_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rsd.c:170
avpriv_request_sample
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1697
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
rsd_probe
static int rsd_probe(AVProbeData *p)
Definition: rsd.c:44
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4367
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1417
AVPacket::data
uint8_t * data
Definition: avcodec.h:1679
AV_CODEC_ID_ADPCM_IMA_RAD
Definition: avcodec.h:530
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:289
size
ptrdiff_t size
Definition: opengl_enc.c:101
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:556
rsd_tags
static const AVCodecTag rsd_tags[]
Definition: rsd.c:28
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
AVERROR
#define AVERROR(e)
Definition: error.h:43
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:179
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4148
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:1876
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
AV_CODEC_ID_ADPCM_THP_LE
Definition: avcodec.h:532
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:463
AVCodecParameters::block_align
int block_align
Audio only.
Definition: avcodec.h:4269
rsd_unsupported_tags
static const uint32_t rsd_unsupported_tags[]
Definition: rsd.c:40
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
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:3216
AV_CODEC_ID_XMA2
Definition: avcodec.h:639
rsd_read_header
static int rsd_read_header(AVFormatContext *s)
Definition: rsd.c:55
AV_CODEC_ID_PCM_S16BE
Definition: avcodec.h:455
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:36
AVStream
Stream structure.
Definition: avformat.h:889
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1391
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:487
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:461
AV_CODEC_ID_ADPCM_PSX
Definition: avcodec.h:533
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:946
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: avcodec.h:4262
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:473
avformat.h
Main libavformat public API header.
AV_CODEC_ID_ADPCM_THP
Definition: avcodec.h:510
ff_get_extradata
int ff_get_extradata(AVFormatContext *s, 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: utils.c:3237
AV_CODEC_ID_PCM_S16LE
Definition: avcodec.h:454
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4194
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4166
AVCodecParameters::channels
int channels
Audio only.
Definition: avcodec.h:4258
start
void INT64 start
Definition: avisynth_c.h:690
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:664
AVStream::codecpar
AVCodecParameters * codecpar
Definition: avformat.h:1252
avio_feof
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:356
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:4156
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1681
ff_rsd_demuxer
AVInputFormat ff_rsd_demuxer
Definition: rsd.c:212
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:342
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1656
Generated on Fri Jan 12 2018 01:48:04 for FFmpeg by   doxygen 1.8.6

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