FFmpeg: libavcodec/libvorbisdec.c Source File

FFmpeg

[フレーム]

libavcodec

libvorbisdec.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include <vorbis/vorbisenc.h>

23 #include "avcodec.h"

24 #include "bytestream.h"

25 #include "internal.h"

27 typedef struct OggVorbisDecContext {

28 vorbis_info vi; /**< vorbis_info used during init */

29 vorbis_dsp_state vd; /**< DSP state used for analysis */

30 vorbis_block vb; /**< vorbis_block used for analysis */

31 vorbis_comment vc; /**< VorbisComment info */

32 ogg_packet op; /**< ogg packet */

33 } OggVorbisDecContext;

35 static int oggvorbis_decode_close(AVCodecContext *avccontext);

37 static int oggvorbis_decode_init(AVCodecContext *avccontext) {

38 OggVorbisDecContext *context = avccontext->priv_data ;

39 uint8_t *p= avccontext->extradata;

40 int i, hsizes[3], ret;

41 unsigned char *headers[3], *extradata = avccontext->extradata;

43 if(! avccontext->extradata_size || ! p) {

44 av_log(avccontext, AV_LOG_ERROR, "vorbis extradata absent\n");

45 return AVERROR(EINVAL);

46 }

48 vorbis_info_init(&context->vi) ;

49 vorbis_comment_init(&context->vc) ;

51 if(p[0] == 0 && p[1] == 30) {

52 int sizesum = 0;

53 for(i = 0; i < 3; i++){

54 hsizes[i] = bytestream_get_be16((const uint8_t **)&p);

55 sizesum += 2 + hsizes[i];

56 if (sizesum > avccontext->extradata_size) {

57 av_log(avccontext, AV_LOG_ERROR, "vorbis extradata too small\n");

58 ret = AVERROR_INVALIDDATA;

59 goto error;

60 }

62 headers[i] = p;

63 p += hsizes[i];

64 }

65 } else if(*p == 2) {

66 unsigned int offset = 1;

67 unsigned int sizesum = 1;

68 p++;

69 for(i=0; i<2; i++) {

70 hsizes[i] = 0;

71 while((*p == 0xFF) && (sizesum < avccontext->extradata_size)) {

72 hsizes[i] += 0xFF;

73 offset++;

74 sizesum += 1 + 0xFF;

75 p++;

76 }

77 hsizes[i] += *p;

78 offset++;

79 sizesum += 1 + *p;

80 if(sizesum > avccontext->extradata_size) {

81 av_log(avccontext, AV_LOG_ERROR,

82 "vorbis header sizes damaged\n");

83 ret = AVERROR_INVALIDDATA;

84 goto error;

85 }

86 p++;

87 }

88 hsizes[2] = avccontext->extradata_size - hsizes[0]-hsizes[1]-offset;

89 #if 0

90 av_log(avccontext, AV_LOG_DEBUG,

91 "vorbis header sizes: %d, %d, %d, / extradata_len is %d \n",

92 hsizes[0], hsizes[1], hsizes[2], avccontext->extradata_size);

93 #endif

94 headers[0] = extradata + offset;

95 headers[1] = extradata + offset + hsizes[0];

96 headers[2] = extradata + offset + hsizes[0] + hsizes[1];

97 } else {

98 av_log(avccontext, AV_LOG_ERROR,

99 "vorbis initial header len is wrong: %d\n", *p);

100 ret = AVERROR_INVALIDDATA;

101 goto error;

102 }

103

104 for(i=0; i<3; i++){

105 context->op.b_o_s= i==0;

106 context->op.bytes = hsizes[i];

107 context->op.packet = headers[i];

108 if(vorbis_synthesis_headerin(&context->vi, &context->vc, &context->op)<0){

109 av_log(avccontext, AV_LOG_ERROR, "%d. vorbis header damaged\n", i+1);

110 ret = AVERROR_INVALIDDATA;

111 goto error;

112 }

113 }

114

115 avccontext->channels = context->vi.channels;

116 avccontext->sample_rate = context->vi.rate;

117 avccontext->sample_fmt = AV_SAMPLE_FMT_S16;

118 avccontext->time_base= (AVRational){1, avccontext->sample_rate};

119

120 vorbis_synthesis_init(&context->vd, &context->vi);

121 vorbis_block_init(&context->vd, &context->vb);

122

123 return 0 ;

124

125 error:

126 oggvorbis_decode_close(avccontext);

127 return ret;

128 }

129

130

131 static inline int conv(int samples, float **pcm, char *buf, int channels) {

132 int i, j;

133 ogg_int16_t *ptr, *data = (ogg_int16_t*)buf ;

134 float *mono ;

135

136 for(i = 0 ; i < channels ; i++){

137 ptr = &data[i];

138 mono = pcm[i] ;

139

140 for(j = 0 ; j < samples ; j++) {

141 *ptr = av_clip_int16(mono[j] * 32767.f);

142 ptr += channels;

143 }

144 }

145

146 return 0 ;

147 }

148

149 static int oggvorbis_decode_frame(AVCodecContext *avccontext, void *data,

150 int *got_frame_ptr, AVPacket *avpkt)

151 {

152 OggVorbisDecContext *context = avccontext->priv_data ;

153 AVFrame *frame = data;

154 float **pcm ;

155 ogg_packet *op= &context->op;

156 int samples, total_samples, total_bytes;

157 int ret;

158 int16_t *output;

159

160 if(!avpkt->size){

161 //FIXME flush

162 return 0;

163 }

164

165 frame->nb_samples = 8192*4;

166 if ((ret = ff_get_buffer(avccontext, frame, 0)) < 0)

167 return ret;

168 output = (int16_t *)frame->data[0];

169

170

171 op->packet = avpkt->data;

172 op->bytes = avpkt->size;

173

174 // av_log(avccontext, AV_LOG_DEBUG, "%d %d %d %"PRId64" %"PRId64" %d %d\n", op->bytes, op->b_o_s, op->e_o_s, op->granulepos, op->packetno, buf_size, context->vi.rate);

175

176 /* for(i=0; i<op->bytes; i++)

177 av_log(avccontext, AV_LOG_DEBUG, "%02X ", op->packet[i]);

178 av_log(avccontext, AV_LOG_DEBUG, "\n");*/

179

180 if(vorbis_synthesis(&context->vb, op) == 0)

181 vorbis_synthesis_blockin(&context->vd, &context->vb) ;

182

183 total_samples = 0 ;

184 total_bytes = 0 ;

185

186 while((samples = vorbis_synthesis_pcmout(&context->vd, &pcm)) > 0) {

187 conv(samples, pcm, (char*)output + total_bytes, context->vi.channels) ;

188 total_bytes += samples * 2 * context->vi.channels ;

189 total_samples += samples ;

190 vorbis_synthesis_read(&context->vd, samples) ;

191 }

192

193 frame->nb_samples = total_samples;

194 *got_frame_ptr = total_samples > 0;

195 return avpkt->size;

196 }

197

198

199 static int oggvorbis_decode_close(AVCodecContext *avccontext) {

200 OggVorbisDecContext *context = avccontext->priv_data ;

201

202 vorbis_block_clear(&context->vb);

203 vorbis_dsp_clear(&context->vd);

204 vorbis_info_clear(&context->vi) ;

205 vorbis_comment_clear(&context->vc) ;

206

207 return 0 ;

208 }

209

210

211 const AVCodec ff_libvorbis_decoder = {

212 .name = "libvorbis",

213 .long_name = NULL_IF_CONFIG_SMALL("libvorbis"),

214 .type = AVMEDIA_TYPE_AUDIO,

215 .id = AV_CODEC_ID_VORBIS,

216 .priv_data_size = sizeof(OggVorbisDecContext),

217 .init = oggvorbis_decode_init,

218 .decode = oggvorbis_decode_frame,

219 .close = oggvorbis_decode_close,

220 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_CHANNEL_CONF,

221 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

OggVorbisDecContext::vd

vorbis_dsp_state vd

DSP state used for analysis

Definition: libvorbisdec.c:29

AVCodec

AVCodec.

Definition: codec.h:202

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

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:992

output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output

Definition: filter_design.txt:225

oggvorbis_decode_init

static int oggvorbis_decode_init(AVCodecContext *avccontext)

Definition: libvorbisdec.c:37

ff_libvorbis_decoder

const AVCodec ff_libvorbis_decoder

Definition: libvorbisdec.c:211

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:317

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

data

const char data[16]

Definition: mxf.c:143

OggVorbisDecContext::vi

vorbis_info vi

vorbis_info used during init

Definition: libvorbisdec.c:28

init

static int init

Definition: av_tx.c:47

OggVorbisDecContext::vb

vorbis_block vb

vorbis_block used for analysis

Definition: libvorbisdec.c:30

ogg_packet

static int ogg_packet(AVFormatContext *s, int *sid, int *dstart, int *dsize, int64_t *fpos)

find the next Ogg packet

Definition: oggdec.c:497

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:71

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:485

OggVorbisDecContext::op

ogg_packet op

ogg packet

Definition: libvorbisdec.c:32

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)

Perform decode operation.

Definition: anm.c:75

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

channels

Definition: aptx.h:33

#define f(width, name)

Definition: cbs_vp9.c:255

conv

static int conv(int samples, float **pcm, char *buf, int channels)

Definition: libvorbisdec.c:131

context

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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context

Definition: writing_filters.txt:91

av_clip_int16

#define av_clip_int16

Definition: common.h:111

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AV_CODEC_CAP_CHANNEL_CONF

#define AV_CODEC_CAP_CHANNEL_CONF

Codec should fill in channel configuration and samplerate instead of container.

Definition: codec.h:109

AVCodecContext::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avcodec.h:506

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1652

AVPacket::size

int size

Definition: packet.h:374

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:117

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1000

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

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:993

OggVorbisDecContext::vc

vorbis_comment vc

VorbisComment info

Definition: libvorbisdec.c:31

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:484

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:61

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

avcodec.h

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

AVCodecContext

main external API structure.

Definition: avcodec.h:383

headers

FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers

Definition: build_system.txt:34

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: codec.h:82

samples

Filter the word "frame" indicates either a video frame or a group of audio samples

Definition: filter_design.txt:8

oggvorbis_decode_close

static int oggvorbis_decode_close(AVCodecContext *avccontext)

Definition: libvorbisdec.c:199

OggVorbisDecContext