FFmpeg: libavcodec/wma.c Source File

FFmpeg

[フレーム]

libavcodec

wma.c

Go to the documentation of this file.

1 /*

2 * WMA compatible codec

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

22 #include "libavutil/attributes.h"

23 #include "libavutil/mem.h"

25 #include "avcodec.h"

26 #include "sinewin.h"

27 #include "wma.h"

28 #include "wma_common.h"

29 #include "wma_freqs.h"

30 #include "wmadata.h"

32 /* XXX: use same run/length optimization as mpeg decoders */

33 // FIXME maybe split decode / encode or pass flag

34 static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table,

35 float **plevel_table, uint16_t **pint_table,

36 const CoefVLCTable *vlc_table)

37 {

38 int n = vlc_table->n;

39 const uint8_t *table_bits = vlc_table->huffbits;

40 const uint32_t *table_codes = vlc_table->huffcodes;

41 const uint16_t *levels_table = vlc_table->levels;

42 uint16_t *run_table, *int_table;

43 float *flevel_table;

44 int i, l, j, k, level, ret;

46 ret = vlc_init(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);

47 if (ret < 0)

48 return ret;

50 run_table = av_malloc_array(n, sizeof(uint16_t));

51 flevel_table = av_malloc_array(n, sizeof(*flevel_table));

52 int_table = av_malloc_array(n, sizeof(uint16_t));

53 if (!run_table || !flevel_table || !int_table) {

54 av_freep(&run_table);

55 av_freep(&flevel_table);

56 av_freep(&int_table);

57 return AVERROR(ENOMEM);

58 }

59 i = 2;

60 level = 1;

61 k = 0;

62 while (i < n) {

63 int_table[k] = i;

64 l = levels_table[k++];

65 for (j = 0; j < l; j++) {

66 run_table[i] = j;

67 flevel_table[i] = level;

68 i++;

69 }

70 level++;

71 }

72 *prun_table = run_table;

73 *plevel_table = flevel_table;

74 *pint_table = int_table;

76 return 0;

77 }

79 av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)

80 {

81 WMACodecContext *s = avctx->priv_data;

82 int channels = avctx->ch_layout.nb_channels;

83 int i, ret;

84 float bps1, high_freq;

85 float bps;

86 int sample_rate1;

87 int coef_vlc_table;

89 if (avctx->sample_rate > 50000 ||

90 channels > 2 ||

91 avctx->bit_rate <= 0)

92 return -1;

95 if (avctx->codec->id == AV_CODEC_ID_WMAV1)

96 s->version = 1;

97 else

98 s->version = 2;

100 /* compute MDCT block size */

101 s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,

102 s->version, 0);

103 s->next_block_len_bits = s->frame_len_bits;

104 s->prev_block_len_bits = s->frame_len_bits;

105 s->block_len_bits = s->frame_len_bits;

106

107 s->frame_len = 1 << s->frame_len_bits;

108 if (s->use_variable_block_len) {

109 int nb_max, nb;

110 nb = ((flags2 >> 3) & 3) + 1;

111 if ((avctx->bit_rate / channels) >= 32000)

112 nb += 2;

113 nb_max = s->frame_len_bits - BLOCK_MIN_BITS;

114 if (nb > nb_max)

115 nb = nb_max;

116 s->nb_block_sizes = nb + 1;

117 } else

118 s->nb_block_sizes = 1;

119

120 /* init rate dependent parameters */

121 s->use_noise_coding = 1;

122 high_freq = avctx->sample_rate * 0.5;

123

124 /* if version 2, then the rates are normalized */

125 sample_rate1 = avctx->sample_rate;

126 if (s->version == 2) {

127 if (sample_rate1 >= 44100)

128 sample_rate1 = 44100;

129 else if (sample_rate1 >= 22050)

130 sample_rate1 = 22050;

131 else if (sample_rate1 >= 16000)

132 sample_rate1 = 16000;

133 else if (sample_rate1 >= 11025)

134 sample_rate1 = 11025;

135 else if (sample_rate1 >= 8000)

136 sample_rate1 = 8000;

137 }

138

139 bps = (float) avctx->bit_rate /

140 (float) (channels * avctx->sample_rate);

141 s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;

142 if (s->byte_offset_bits + 3 > MIN_CACHE_BITS) {

143 av_log(avctx, AV_LOG_ERROR, "byte_offset_bits %d is too large\n", s->byte_offset_bits);

144 return AVERROR_PATCHWELCOME;

145 }

146

147 /* compute high frequency value and choose if noise coding should

148 * be activated */

149 bps1 = bps;

150 if (channels == 2)

151 bps1 = bps * 1.6;

152 if (sample_rate1 == 44100) {

153 if (bps1 >= 0.61)

154 s->use_noise_coding = 0;

155 else

156 high_freq = high_freq * 0.4;

157 } else if (sample_rate1 == 22050) {

158 if (bps1 >= 1.16)

159 s->use_noise_coding = 0;

160 else if (bps1 >= 0.72)

161 high_freq = high_freq * 0.7;

162 else

163 high_freq = high_freq * 0.6;

164 } else if (sample_rate1 == 16000) {

165 if (bps > 0.5)

166 high_freq = high_freq * 0.5;

167 else

168 high_freq = high_freq * 0.3;

169 } else if (sample_rate1 == 11025)

170 high_freq = high_freq * 0.7;

171 else if (sample_rate1 == 8000) {

172 if (bps <= 0.625)

173 high_freq = high_freq * 0.5;

174 else if (bps > 0.75)

175 s->use_noise_coding = 0;

176 else

177 high_freq = high_freq * 0.65;

178 } else {

179 if (bps >= 0.8)

180 high_freq = high_freq * 0.75;

181 else if (bps >= 0.6)

182 high_freq = high_freq * 0.6;

183 else

184 high_freq = high_freq * 0.5;

185 }

186 ff_dlog(s->avctx, "flags2=0x%x\n", flags2);

187 ff_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%"PRId64" block_align=%d\n",

188 s->version, channels, avctx->sample_rate, avctx->bit_rate,

189 avctx->block_align);

190 ff_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",

191 bps, bps1, high_freq, s->byte_offset_bits);

192 ff_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",

193 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);

194

195 /* compute the scale factor band sizes for each MDCT block size */

196 {

197 int a, b, pos, lpos, k, block_len, i, j, n;

198 const uint8_t *table;

199

200 if (s->version == 1)

201 s->coefs_start = 3;

202 else

203 s->coefs_start = 0;

204 for (k = 0; k < s->nb_block_sizes; k++) {

205 block_len = s->frame_len >> k;

206

207 if (s->version == 1) {

208 lpos = 0;

209 for (i = 0; i < 25; i++) {

210 a = ff_wma_critical_freqs[i];

211 b = avctx->sample_rate;

212 pos = ((block_len * 2 * a) + (b >> 1)) / b;

213 if (pos > block_len)

214 pos = block_len;

215 s->exponent_bands[0][i] = pos - lpos;

216 if (pos >= block_len) {

217 i++;

218 break;

219 }

220 lpos = pos;

221 }

222 s->exponent_sizes[0] = i;

223 } else {

224 /* hardcoded tables */

225 table = NULL;

226 a = s->frame_len_bits - BLOCK_MIN_BITS - k;

227 if (a < 3) {

228 if (avctx->sample_rate >= 44100)

229 table = exponent_band_44100[a];

230 else if (avctx->sample_rate >= 32000)

231 table = exponent_band_32000[a];

232 else if (avctx->sample_rate >= 22050)

233 table = exponent_band_22050[a];

234 }

235 if (table) {

236 n = *table++;

237 for (i = 0; i < n; i++)

238 s->exponent_bands[k][i] = table[i];

239 s->exponent_sizes[k] = n;

240 } else {

241 j = 0;

242 lpos = 0;

243 for (i = 0; i < 25; i++) {

244 a = ff_wma_critical_freqs[i];

245 b = avctx->sample_rate;

246 pos = ((block_len * 2 * a) + (b << 1)) / (4 * b);

247 pos <<= 2;

248 if (pos > block_len)

249 pos = block_len;

250 if (pos > lpos)

251 s->exponent_bands[k][j++] = pos - lpos;

252 if (pos >= block_len)

253 break;

254 lpos = pos;

255 }

256 s->exponent_sizes[k] = j;

257 }

258 }

259

260 /* max number of coefs */

261 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;

262 /* high freq computation */

263 s->high_band_start[k] = (int) ((block_len * 2 * high_freq) /

264 avctx->sample_rate + 0.5);

265 n = s->exponent_sizes[k];

266 j = 0;

267 pos = 0;

268 for (i = 0; i < n; i++) {

269 int start, end;

270 start = pos;

271 pos += s->exponent_bands[k][i];

272 end = pos;

273 if (start < s->high_band_start[k])

274 start = s->high_band_start[k];

275 if (end > s->coefs_end[k])

276 end = s->coefs_end[k];

277 if (end > start)

278 s->exponent_high_bands[k][j++] = end - start;

279 }

280 s->exponent_high_sizes[k] = j;

281 }

282 }

283

284 #ifdef TRACE

285 {

286 int i, j;

287 for (i = 0; i < s->nb_block_sizes; i++) {

288 ff_tlog(s->avctx, "%5d: n=%2d:",

289 s->frame_len >> i,

290 s->exponent_sizes[i]);

291 for (j = 0; j < s->exponent_sizes[i]; j++)

292 ff_tlog(s->avctx, " %d", s->exponent_bands[i][j]);

293 ff_tlog(s->avctx, "\n");

294 }

295 }

296 #endif /* TRACE */

297

298 /* init MDCT windows : simple sine window */

299 for (i = 0; i < s->nb_block_sizes; i++) {

300 ff_init_ff_sine_windows(s->frame_len_bits - i);

301 s->windows[i] = ff_sine_windows[s->frame_len_bits - i];

302 }

303

304 s->reset_block_lengths = 1;

305

306 if (s->use_noise_coding) {

307 /* init the noise generator */

308 if (s->use_exp_vlc)

309 s->noise_mult = 0.02;

310 else

311 s->noise_mult = 0.04;

312

313 #ifdef TRACE

314 for (i = 0; i < NOISE_TAB_SIZE; i++)

315 s->noise_table[i] = 1.0 * s->noise_mult;

316 #else

317 {

318 unsigned int seed;

319 float norm;

320 seed = 1;

321 norm = (1.0 / (float) (1LL << 31)) * sqrt(3) * s->noise_mult;

322 for (i = 0; i < NOISE_TAB_SIZE; i++) {

323 seed = seed * 314159 + 1;

324 s->noise_table[i] = (float) ((int) seed) * norm;

325 }

326 }

327 #endif /* TRACE */

328 }

329

330 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);

331 if (!s->fdsp)

332 return AVERROR(ENOMEM);

333

334 /* choose the VLC tables for the coefficients */

335 coef_vlc_table = 2;

336 if (avctx->sample_rate >= 32000) {

337 if (bps1 < 0.72)

338 coef_vlc_table = 0;

339 else if (bps1 < 1.16)

340 coef_vlc_table = 1;

341 }

342 s->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];

343 s->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];

344 ret = init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],

345 &s->int_table[0], s->coef_vlcs[0]);

346 if (ret < 0)

347 return ret;

348

349 return init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],

350 &s->int_table[1], s->coef_vlcs[1]);

351 }

352

353 int ff_wma_total_gain_to_bits(int total_gain)

354 {

355 if (total_gain < 15)

356 return 13;

357 else if (total_gain < 32)

358 return 12;

359 else if (total_gain < 40)

360 return 11;

361 else if (total_gain < 45)

362 return 10;

363 else

364 return 9;

365 }

366

367 av_cold int ff_wma_end(AVCodecContext *avctx)

368 {

369 WMACodecContext *s = avctx->priv_data;

370 int i;

371

372 for (i = 0; i < s->nb_block_sizes; i++)

373 av_tx_uninit(&s->mdct_ctx[i]);

374

375 if (s->use_exp_vlc)

376 ff_vlc_free(&s->exp_vlc);

377 if (s->use_noise_coding)

378 ff_vlc_free(&s->hgain_vlc);

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

380 ff_vlc_free(&s->coef_vlc[i]);

381 av_freep(&s->run_table[i]);

382 av_freep(&s->level_table[i]);

383 av_freep(&s->int_table[i]);

384 }

385 av_freep(&s->fdsp);

386

387 return 0;

388 }

389

390 /**

391 * Decode an uncompressed coefficient.

392 * @param gb GetBitContext

393 * @return the decoded coefficient

394 */

395 unsigned int ff_wma_get_large_val(GetBitContext *gb)

396 {

397 /** consumes up to 34 bits */

398 int n_bits = 8;

399 /** decode length */

400 if (get_bits1(gb)) {

401 n_bits += 8;

402 if (get_bits1(gb)) {

403 n_bits += 8;

404 if (get_bits1(gb))

405 n_bits += 7;

406 }

407 }

408 return get_bits_long(gb, n_bits);

409 }

410

411 /**

412 * Decode run level compressed coefficients.

413 * @param avctx codec context

414 * @param gb bitstream reader context

415 * @param vlc vlc table for get_vlc2

416 * @param level_table level codes

417 * @param run_table run codes

418 * @param version 0 for wma1,2 1 for wmapro

419 * @param ptr output buffer

420 * @param offset offset in the output buffer

421 * @param num_coefs number of input coefficients

422 * @param block_len input buffer length (2^n)

423 * @param frame_len_bits number of bits for escaped run codes

424 * @param coef_nb_bits number of bits for escaped level codes

425 * @return 0 on success, -1 otherwise

426 */

427 int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb,

428 const VLCElem *vlc, const float *level_table,

429 const uint16_t *run_table, int version,

430 WMACoef *ptr, int offset, int num_coefs,

431 int block_len, int frame_len_bits,

432 int coef_nb_bits)

433 {

434 int code, level, sign;

435 const uint32_t *ilvl = (const uint32_t *) level_table;

436 uint32_t *iptr = (uint32_t *) ptr;

437 const unsigned int coef_mask = block_len - 1;

438 for (; offset < num_coefs; offset++) {

439 code = get_vlc2(gb, vlc, VLCBITS, VLCMAX);

440 if (code > 1) {

441 /** normal code */

442 offset += run_table[code];

443 sign = get_bits1(gb) - 1;

444 iptr[offset & coef_mask] = ilvl[code] ^ (sign & 0x80000000);

445 } else if (code == 1) {

446 /** EOB */

447 break;

448 } else {

449 /** escape */

450 if (!version) {

451 level = get_bits(gb, coef_nb_bits);

452 /** NOTE: this is rather suboptimal. reading

453 * block_len_bits would be better */

454 offset += get_bits(gb, frame_len_bits);

455 } else {

456 level = ff_wma_get_large_val(gb);

457 /** escape decode */

458 if (get_bits1(gb)) {

459 if (get_bits1(gb)) {

460 if (get_bits1(gb)) {

461 av_log(avctx, AV_LOG_ERROR,

462 "broken escape sequence\n");

463 return AVERROR_INVALIDDATA;

464 } else

465 offset += get_bits(gb, frame_len_bits) + 4;

466 } else

467 offset += get_bits(gb, 2) + 1;

468 }

469 }

470 sign = get_bits1(gb) - 1;

471 ptr[offset & coef_mask] = (level ^ sign) - sign;

472 }

473 }

474 /** NOTE: EOB can be omitted */

475 if (offset > num_coefs) {

476 av_log(avctx, AV_LOG_ERROR,

477 "overflow (%d > %d) in spectral RLE, ignoring\n",

478 offset,

479 num_coefs

480 );

481 return AVERROR_INVALIDDATA;

482 }

483

484 return 0;

485 }

level

uint8_t level

Definition: svq3.c:208

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

ff_sine_windows

SINETABLE_CONST float *const ff_sine_windows[]

Definition: sinewin_tablegen.h:51

coef_vlcs

static const CoefVLCTable coef_vlcs[6]

Definition: wmadata.h:1371

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1024

wma_freqs.h

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:424

exponent_band_32000

static const uint8_t exponent_band_32000[3][25]

Definition: wmadata.h:42

BLOCK_MIN_BITS

#define BLOCK_MIN_BITS

Definition: wma.h:34

#define b

Definition: input.c:42

table

static const uint16_t table[]

Definition: prosumer.c:203

CoefVLCTable::n

int n

total number of codes

Definition: wma.h:61

ff_wma_run_level_decode

int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, const VLCElem *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)

Decode run level compressed coefficients.

Definition: wma.c:427

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

VLCBITS

#define VLCBITS

Definition: wma.h:55

CoefVLCTable::huffbits

const uint8_t * huffbits

VLC bit size.

Definition: wma.h:64

VLCMAX

#define VLCMAX

Definition: wma.h:56

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:337

init_coef_vlc

static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table, float **plevel_table, uint16_t **pint_table, const CoefVLCTable *vlc_table)

Definition: wma.c:34

CoefVLCTable

Definition: wma.h:60

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:440

WMACoef

float WMACoef

type for decoded coefficients, int16_t would be enough for wma 1/2

Definition: wma.h:58

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

GetBitContext

Definition: get_bits.h:109

WMACodecContext

Definition: wma.h:68

AV_CODEC_ID_WMAV1

@ AV_CODEC_ID_WMAV1

Definition: codec_id.h:466

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

wma_common.h

float

Definition: af_crystalizer.c:122

#define s(width, name)

Definition: cbs_vp9.c:198

vlc_init

#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:70

channels

Definition: aptx.h:31

ff_wma_critical_freqs

const uint16_t ff_wma_critical_freqs[25]

Definition: wma_freqs.c:23

wma.h

ff_wma_total_gain_to_bits

int ff_wma_total_gain_to_bits(int total_gain)

Definition: wma.c:353

CoefVLCTable::huffcodes

const uint32_t * huffcodes

VLC bit values.

Definition: wma.h:63

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:481

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:391

seed

static unsigned int seed

Definition: videogen.c:78

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:651

ff_wma_end

av_cold int ff_wma_end(AVCodecContext *avctx)

Definition: wma.c:367

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

bps

unsigned bps

Definition: movenc.c:1996

VLCElem

Definition: vlc.h:32

ff_wma_init

av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)

Definition: wma.c:79

NOISE_TAB_SIZE

#define NOISE_TAB_SIZE

Definition: wma.h:50

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

sinewin.h

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

attributes.h

version

Definition: libkvazaar.c:313

av_tx_uninit

av_cold void av_tx_uninit(AVTXContext **ctx)

Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

Definition: tx.c:295

AVCodec::id

enum AVCodecID id

Definition: codec.h:186

wmadata.h

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

Definition: cbs_h2645.c:256

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

exponent_band_44100

static const uint8_t exponent_band_44100[3][25]

Definition: wmadata.h:48

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

MIN_CACHE_BITS

#define MIN_CACHE_BITS

Definition: get_bits.h:167

avcodec.h

ff_vlc_free