FFmpeg: libavcodec/binkaudio.c Source File

FFmpeg

[フレーム]

libavcodec

binkaudio.c

Go to the documentation of this file.

1 /*

2 * Bink Audio decoder

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 */

23 /**

24 * @file

25 * Bink Audio decoder

26 *

27 * Technical details here:

28 * http://wiki.multimedia.cx/index.php?title=Bink_Audio

29 */

31 #include "libavutil/channel_layout.h"

32 #include "avcodec.h"

33 #define BITSTREAM_READER_LE

34 #include "get_bits.h"

35 #include "dct.h"

36 #include "rdft.h"

37 #include "internal.h"

38 #include "wma_freqs.h"

39 #include "libavutil/intfloat.h"

41 static float quant_table[96];

43 #define MAX_CHANNELS 2

44 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)

46 typedef struct BinkAudioContext {

47 GetBitContext gb;

48 int version_b; ///< Bink version 'b'

49 int first;

50 int channels;

51 int frame_len; ///< transform size (samples)

52 int overlap_len; ///< overlap size (samples)

53 int block_size;

54 int num_bands;

55 unsigned int *bands;

56 float root;

57 DECLARE_ALIGNED(32, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];

58 float previous[MAX_CHANNELS][BINK_BLOCK_MAX_SIZE / 16]; ///< coeffs from previous audio block

59 uint8_t *packet_buffer;

60 union {

61 RDFTContext rdft;

62 DCTContext dct;

63 } trans;

64 } BinkAudioContext;

67 static av_cold int decode_init(AVCodecContext *avctx)

68 {

69 BinkAudioContext *s = avctx->priv_data;

70 int sample_rate = avctx->sample_rate;

71 int sample_rate_half;

72 int i;

73 int frame_len_bits;

75 /* determine frame length */

76 if (avctx->sample_rate < 22050) {

77 frame_len_bits = 9;

78 } else if (avctx->sample_rate < 44100) {

79 frame_len_bits = 10;

80 } else {

81 frame_len_bits = 11;

82 }

84 if (avctx->channels < 1 || avctx->channels > MAX_CHANNELS) {

85 av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", avctx->channels);

86 return AVERROR_INVALIDDATA;

87 }

88 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :

89 AV_CH_LAYOUT_STEREO;

91 s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b';

93 if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {

94 // audio is already interleaved for the RDFT format variant

95 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

96 sample_rate *= avctx->channels;

97 s->channels = 1;

98 if (!s->version_b)

99 frame_len_bits += av_log2(avctx->channels);

100 } else {

101 s->channels = avctx->channels;

102 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

103 }

104

105 s->frame_len = 1 << frame_len_bits;

106 s->overlap_len = s->frame_len / 16;

107 s->block_size = (s->frame_len - s->overlap_len) * s->channels;

108 sample_rate_half = (sample_rate + 1) / 2;

109 if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)

110 s->root = 2.0 / (sqrt(s->frame_len) * 32768.0);

111 else

112 s->root = s->frame_len / (sqrt(s->frame_len) * 32768.0);

113 for (i = 0; i < 96; i++) {

114 /* constant is result of 0.066399999/log10(M_E) */

115 quant_table[i] = expf(i * 0.15289164787221953823f) * s->root;

116 }

117

118 /* calculate number of bands */

119 for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)

120 if (sample_rate_half <= ff_wma_critical_freqs[s->num_bands - 1])

121 break;

122

123 s->bands = av_malloc((s->num_bands + 1) * sizeof(*s->bands));

124 if (!s->bands)

125 return AVERROR(ENOMEM);

126

127 /* populate bands data */

128 s->bands[0] = 2;

129 for (i = 1; i < s->num_bands; i++)

130 s->bands[i] = (ff_wma_critical_freqs[i - 1] * s->frame_len / sample_rate_half) & ~1;

131 s->bands[s->num_bands] = s->frame_len;

132

133 s->first = 1;

134

135 if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)

136 ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);

137 else if (CONFIG_BINKAUDIO_DCT_DECODER)

138 ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);

139 else

140 return -1;

141

142 return 0;

143 }

144

145 static float get_float(GetBitContext *gb)

146 {

147 int power = get_bits(gb, 5);

148 float f = ldexpf(get_bits_long(gb, 23), power - 23);

149 if (get_bits1(gb))

150 f = -f;

151 return f;

152 }

153

154 static const uint8_t rle_length_tab[16] = {

155 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64

156 };

157

158 /**

159 * Decode Bink Audio block

160 * @param[out] out Output buffer (must contain s->block_size elements)

161 * @return 0 on success, negative error code on failure

162 */

163 static int decode_block(BinkAudioContext *s, float **out, int use_dct)

164 {

165 int ch, i, j, k;

166 float q, quant[25];

167 int width, coeff;

168 GetBitContext *gb = &s->gb;

169

170 if (use_dct)

171 skip_bits(gb, 2);

172

173 for (ch = 0; ch < s->channels; ch++) {

174 FFTSample *coeffs = out[ch];

175

176 if (s->version_b) {

177 if (get_bits_left(gb) < 64)

178 return AVERROR_INVALIDDATA;

179 coeffs[0] = av_int2float(get_bits_long(gb, 32)) * s->root;

180 coeffs[1] = av_int2float(get_bits_long(gb, 32)) * s->root;

181 } else {

182 if (get_bits_left(gb) < 58)

183 return AVERROR_INVALIDDATA;

184 coeffs[0] = get_float(gb) * s->root;

185 coeffs[1] = get_float(gb) * s->root;

186 }

187

188 if (get_bits_left(gb) < s->num_bands * 8)

189 return AVERROR_INVALIDDATA;

190 for (i = 0; i < s->num_bands; i++) {

191 int value = get_bits(gb, 8);

192 quant[i] = quant_table[FFMIN(value, 95)];

193 }

194

195 k = 0;

196 q = quant[0];

197

198 // parse coefficients

199 i = 2;

200 while (i < s->frame_len) {

201 if (s->version_b) {

202 j = i + 16;

203 } else {

204 int v = get_bits1(gb);

205 if (v) {

206 v = get_bits(gb, 4);

207 j = i + rle_length_tab[v] * 8;

208 } else {

209 j = i + 8;

210 }

211 }

212

213 j = FFMIN(j, s->frame_len);

214

215 width = get_bits(gb, 4);

216 if (width == 0) {

217 memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));

218 i = j;

219 while (s->bands[k] < i)

220 q = quant[k++];

221 } else {

222 while (i < j) {

223 if (s->bands[k] == i)

224 q = quant[k++];

225 coeff = get_bits(gb, width);

226 if (coeff) {

227 int v;

228 v = get_bits1(gb);

229 if (v)

230 coeffs[i] = -q * coeff;

231 else

232 coeffs[i] = q * coeff;

233 } else {

234 coeffs[i] = 0.0f;

235 }

236 i++;

237 }

238 }

239 }

240

241 if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {

242 coeffs[0] /= 0.5;

243 s->trans.dct.dct_calc(&s->trans.dct, coeffs);

244 }

245 else if (CONFIG_BINKAUDIO_RDFT_DECODER)

246 s->trans.rdft.rdft_calc(&s->trans.rdft, coeffs);

247 }

248

249 for (ch = 0; ch < s->channels; ch++) {

250 int j;

251 int count = s->overlap_len * s->channels;

252 if (!s->first) {

253 j = ch;

254 for (i = 0; i < s->overlap_len; i++, j += s->channels)

255 out[ch][i] = (s->previous[ch][i] * (count - j) +

256 out[ch][i] * j) / count;

257 }

258 memcpy(s->previous[ch], &out[ch][s->frame_len - s->overlap_len],

259 s->overlap_len * sizeof(*s->previous[ch]));

260 }

261

262 s->first = 0;

263

264 return 0;

265 }

266

267 static av_cold int decode_end(AVCodecContext *avctx)

268 {

269 BinkAudioContext * s = avctx->priv_data;

270 av_freep(&s->bands);

271 av_freep(&s->packet_buffer);

272 if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)

273 ff_rdft_end(&s->trans.rdft);

274 else if (CONFIG_BINKAUDIO_DCT_DECODER)

275 ff_dct_end(&s->trans.dct);

276

277 return 0;

278 }

279

280 static void get_bits_align32(GetBitContext *s)

281 {

282 int n = (-get_bits_count(s)) & 31;

283 if (n) skip_bits(s, n);

284 }

285

286 static int decode_frame(AVCodecContext *avctx, void *data,

287 int *got_frame_ptr, AVPacket *avpkt)

288 {

289 BinkAudioContext *s = avctx->priv_data;

290 AVFrame *frame = data;

291 GetBitContext *gb = &s->gb;

292 int ret, consumed = 0;

293

294 if (!get_bits_left(gb)) {

295 uint8_t *buf;

296 /* handle end-of-stream */

297 if (!avpkt->size) {

298 *got_frame_ptr = 0;

299 return 0;

300 }

301 if (avpkt->size < 4) {

302 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");

303 return AVERROR_INVALIDDATA;

304 }

305 buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);

306 if (!buf)

307 return AVERROR(ENOMEM);

308 memset(buf + avpkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

309 s->packet_buffer = buf;

310 memcpy(s->packet_buffer, avpkt->data, avpkt->size);

311 if ((ret = init_get_bits8(gb, s->packet_buffer, avpkt->size)) < 0)

312 return ret;

313 consumed = avpkt->size;

314

315 /* skip reported size */

316 skip_bits_long(gb, 32);

317 }

318

319 /* get output buffer */

320 frame->nb_samples = s->frame_len;

321 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

322 return ret;

323

324 if (decode_block(s, (float **)frame->extended_data,

325 avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {

326 av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");

327 return AVERROR_INVALIDDATA;

328 }

329 get_bits_align32(gb);

330

331 frame->nb_samples = s->block_size / avctx->channels;

332 *got_frame_ptr = 1;

333

334 return consumed;

335 }

336

337 AVCodec ff_binkaudio_rdft_decoder = {

338 .name = "binkaudio_rdft",

339 .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)"),

340 .type = AVMEDIA_TYPE_AUDIO,

341 .id = AV_CODEC_ID_BINKAUDIO_RDFT,

342 .priv_data_size = sizeof(BinkAudioContext),

343 .init = decode_init,

344 .close = decode_end,

345 .decode = decode_frame,

346 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,

347 };

348

349 AVCodec ff_binkaudio_dct_decoder = {

350 .name = "binkaudio_dct",

351 .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)"),

352 .type = AVMEDIA_TYPE_AUDIO,

353 .id = AV_CODEC_ID_BINKAUDIO_DCT,

354 .priv_data_size = sizeof(BinkAudioContext),

355 .init = decode_init,

356 .close = decode_end,

357 .decode = decode_frame,

358 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,

359 };

Generated on Sun Mar 8 2015 02:34:49 for FFmpeg by doxygen 1.8.2