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 "fmtconvert.h"

38 #include "internal.h"

39 #include "wma.h"

40 #include "libavutil/intfloat.h"

42 static float quant_table[96];

44 #define MAX_CHANNELS 2

45 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)

47 typedef struct {

48 GetBitContext gb;

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

50 int first;

51 int channels;

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

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

54 int block_size;

55 int num_bands;

56 unsigned int *bands;

57 float root;

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

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

60 uint8_t *packet_buffer;

61 union {

62 RDFTContext rdft;

63 DCTContext dct;

64 } trans;

65 } BinkAudioContext;

68 static av_cold int decode_init(AVCodecContext *avctx)

69 {

70 BinkAudioContext *s = avctx->priv_data;

71 int sample_rate = avctx->sample_rate;

72 int sample_rate_half;

73 int i;

74 int frame_len_bits;

76 /* determine frame length */

77 if (avctx->sample_rate < 22050) {

78 frame_len_bits = 9;

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

80 frame_len_bits = 10;

81 } else {

82 frame_len_bits = 11;

83 }

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

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

87 return AVERROR_INVALIDDATA;

88 }

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

90 AV_CH_LAYOUT_STEREO;

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

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

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

96 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

97 sample_rate *= avctx->channels;

98 s->channels = 1;

99 if (!s->version_b)

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

101 } else {

102 s->channels = avctx->channels;

103 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

104 }

105

106 s->frame_len = 1 << frame_len_bits;

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

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

109 sample_rate_half = (sample_rate + 1) / 2;

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

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

112 else

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

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

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

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

117 }

118

119 /* calculate number of bands */

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

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

122 break;

123

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

125 if (!s->bands)

126 return AVERROR(ENOMEM);

127

128 /* populate bands data */

129 s->bands[0] = 2;

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

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

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

133

134 s->first = 1;

135

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

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

138 else if (CONFIG_BINKAUDIO_DCT_DECODER)

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

140 else

141 return -1;

142

143 return 0;

144 }

145

146 static float get_float(GetBitContext *gb)

147 {

148 int power = get_bits(gb, 5);

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

150 if (get_bits1(gb))

151 f = -f;

152 return f;

153 }

154

155 static const uint8_t rle_length_tab[16] = {

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

157 };

158

159 /**

160 * Decode Bink Audio block

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

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

163 */

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

165 {

166 int ch, i, j, k;

167 float q, quant[25];

168 int width, coeff;

169 GetBitContext *gb = &s->gb;

170

171 if (use_dct)

172 skip_bits(gb, 2);

173

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

175 FFTSample *coeffs = out[ch];

176

177 if (s->version_b) {

178 if (get_bits_left(gb) < 64)

179 return AVERROR_INVALIDDATA;

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

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

182 } else {

183 if (get_bits_left(gb) < 58)

184 return AVERROR_INVALIDDATA;

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

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

187 }

188

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

190 return AVERROR_INVALIDDATA;

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

192 int value = get_bits(gb, 8);

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

194 }

195

196 k = 0;

197 q = quant[0];

198

199 // parse coefficients

200 i = 2;

201 while (i < s->frame_len) {

202 if (s->version_b) {

203 j = i + 16;

204 } else {

205 int v = get_bits1(gb);

206 if (v) {

207 v = get_bits(gb, 4);

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

209 } else {

210 j = i + 8;

211 }

212 }

213

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

215

216 width = get_bits(gb, 4);

217 if (width == 0) {

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

219 i = j;

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

221 q = quant[k++];

222 } else {

223 while (i < j) {

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

225 q = quant[k++];

226 coeff = get_bits(gb, width);

227 if (coeff) {

228 int v;

229 v = get_bits1(gb);

230 if (v)

231 coeffs[i] = -q * coeff;

232 else

233 coeffs[i] = q * coeff;

234 } else {

235 coeffs[i] = 0.0f;

236 }

237 i++;

238 }

239 }

240 }

241

242 if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {

243 coeffs[0] /= 0.5;

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

245 }

246 else if (CONFIG_BINKAUDIO_RDFT_DECODER)

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

248 }

249

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

251 int j;

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

253 if (!s->first) {

254 j = ch;

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

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

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

258 }

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

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

261 }

262

263 s->first = 0;

264

265 return 0;

266 }

267

268 static av_cold int decode_end(AVCodecContext *avctx)

269 {

270 BinkAudioContext * s = avctx->priv_data;

271 av_freep(&s->bands);

272 av_freep(&s->packet_buffer);

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

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

275 else if (CONFIG_BINKAUDIO_DCT_DECODER)

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

277

278 return 0;

279 }

280

281 static void get_bits_align32(GetBitContext *s)

282 {

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

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

285 }

286

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

288 int *got_frame_ptr, AVPacket *avpkt)

289 {

290 BinkAudioContext *s = avctx->priv_data;

291 AVFrame *frame = data;

292 GetBitContext *gb = &s->gb;

293 int ret, consumed = 0;

294

295 if (!get_bits_left(gb)) {

296 uint8_t *buf;

297 /* handle end-of-stream */

298 if (!avpkt->size) {

299 *got_frame_ptr = 0;

300 return 0;

301 }

302 if (avpkt->size < 4) {

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

304 return AVERROR_INVALIDDATA;

305 }

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

307 if (!buf)

308 return AVERROR(ENOMEM);

309 s->packet_buffer = buf;

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

311 init_get_bits(gb, s->packet_buffer, avpkt->size * 8);

312 consumed = avpkt->size;

313

314 /* skip reported size */

315 skip_bits_long(gb, 32);

316 }

317

318 /* get output buffer */

319 frame->nb_samples = s->frame_len;

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

321 return ret;

322

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

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

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

326 return AVERROR_INVALIDDATA;

327 }

328 get_bits_align32(gb);

329

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

331 *got_frame_ptr = 1;

332

333 return consumed;

334 }

335

336 AVCodec ff_binkaudio_rdft_decoder = {

337 .name = "binkaudio_rdft",

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

339 .type = AVMEDIA_TYPE_AUDIO,

340 .id = AV_CODEC_ID_BINKAUDIO_RDFT,

341 .priv_data_size = sizeof(BinkAudioContext),

342 .init = decode_init,

343 .close = decode_end,

344 .decode = decode_frame,

345 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,

346 };

347

348 AVCodec ff_binkaudio_dct_decoder = {

349 .name = "binkaudio_dct",

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

351 .type = AVMEDIA_TYPE_AUDIO,

352 .id = AV_CODEC_ID_BINKAUDIO_DCT,

353 .priv_data_size = sizeof(BinkAudioContext),

354 .init = decode_init,

355 .close = decode_end,

356 .decode = decode_frame,

357 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,

358 };

Generated on Sat Jan 25 2014 19:51:45 for FFmpeg by doxygen 1.8.2