git.sesse.net Git - ffmpeg/blob - libavcodec/wmaenc.c

   1 /*
   2  * WMA compatible encoder
   3  * Copyright (c) 2007 Michael Niedermayer
   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 "libavutil/attributes.h"
  23
  24 #include "avcodec.h"
  25 #include "internal.h"
  26 #include "wma.h"
  27 #include "libavutil/avassert.h"
  28
  29
  30 static av_cold int encode_init(AVCodecContext *avctx)
  31 {
  32     WMACodecContext *s = avctx->priv_data;
  33     int i, flags1, flags2, block_align;
  34     uint8_t *extradata;
  35
  36     s->avctx = avctx;
  37
  38     if (avctx->channels > MAX_CHANNELS) {
  39         av_log(avctx, AV_LOG_ERROR,
  40                "too many channels: got %i, need %i or fewer\n",
  41                avctx->channels, MAX_CHANNELS);
  42         return AVERROR(EINVAL);
  43     }
  44
  45     if (avctx->sample_rate > 48000) {
  46         av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
  47                avctx->sample_rate);
  48         return AVERROR(EINVAL);
  49     }
  50
  51     if (avctx->bit_rate < 24 * 1000) {
  52         av_log(avctx, AV_LOG_ERROR,
  53                "bitrate too low: got %i, need 24000 or higher\n",
  54                avctx->bit_rate);
  55         return AVERROR(EINVAL);
  56     }
  57
  58     /* extract flag infos */
  59     flags1 = 0;
  60     flags2 = 1;
  61     if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
  62         extradata             = av_malloc(4);
  63         avctx->extradata_size = 4;
  64         AV_WL16(extradata, flags1);
  65         AV_WL16(extradata + 2, flags2);
  66     } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
  67         extradata             = av_mallocz(10);
  68         avctx->extradata_size = 10;
  69         AV_WL32(extradata, flags1);
  70         AV_WL16(extradata + 4, flags2);
  71     } else {
  72         av_assert0(0);
  73     }
  74     avctx->extradata          = extradata;
  75     s->use_exp_vlc            = flags2 & 0x0001;
  76     s->use_bit_reservoir      = flags2 & 0x0002;
  77     s->use_variable_block_len = flags2 & 0x0004;
  78     if (avctx->channels == 2)
  79         s->ms_stereo = 1;
  80
  81     ff_wma_init(avctx, flags2);
  82
  83     /* init MDCT */
  84     for (i = 0; i < s->nb_block_sizes; i++)
  85         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
  86
  87     block_align        = avctx->bit_rate * (int64_t) s->frame_len /
  88                          (avctx->sample_rate * 8);
  89     block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
  90     avctx->block_align = block_align;
  91     avctx->frame_size = avctx->initial_padding = s->frame_len;
  92
  93     return 0;
  94 }
  95
  96 static void apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
  97 {
  98     WMACodecContext *s = avctx->priv_data;
  99     float **audio      = (float **) frame->extended_data;
 100     int len            = frame->nb_samples;
 101     int window_index   = s->frame_len_bits - s->block_len_bits;
 102     FFTContext *mdct   = &s->mdct_ctx[window_index];
 103     int ch;
 104     const float *win   = s->windows[window_index];
 105     int window_len     = 1 << s->block_len_bits;
 106     float n            = 2.0 * 32768.0 / window_len;
 107
 108     for (ch = 0; ch < avctx->channels; ch++) {
 109         memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
 110         s->fdsp->vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
 111         s->fdsp->vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
 112                                     win, len);
 113         s->fdsp->vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
 114         mdct->mdct_calc(mdct, s->coefs[ch], s->output);
 115     }
 116 }
 117
 118 // FIXME use for decoding too
 119 static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
 120 {
 121     int n;
 122     const uint16_t *ptr;
 123     float v, *q, max_scale, *q_end;
 124
 125     ptr       = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
 126     q         = s->exponents[ch];
 127     q_end     = q + s->block_len;
 128     max_scale = 0;
 129     while (q < q_end) {
 130         /* XXX: use a table */
 131         v         = pow(10, *exp_param++ *(1.0 / 16.0));
 132         max_scale = FFMAX(max_scale, v);
 133         n         = *ptr++;
 134         do {
 135             *q++ = v;
 136         } while (--n);
 137     }
 138     s->max_exponent[ch] = max_scale;
 139 }
 140
 141 static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
 142 {
 143     int last_exp;
 144     const uint16_t *ptr;
 145     float *q, *q_end;
 146
 147     ptr   = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
 148     q     = s->exponents[ch];
 149     q_end = q + s->block_len;
 150     if (s->version == 1) {
 151         last_exp = *exp_param++;
 152         av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
 153         put_bits(&s->pb, 5, last_exp - 10);
 154         q += *ptr++;
 155     } else
 156         last_exp = 36;
 157     while (q < q_end) {
 158         int exp  = *exp_param++;
 159         int code = exp - last_exp + 60;
 160         av_assert1(code >= 0 && code < 120);
 161         put_bits(&s->pb, ff_aac_scalefactor_bits[code],
 162                  ff_aac_scalefactor_code[code]);
 163         /* XXX: use a table */
 164         q       += *ptr++;
 165         last_exp = exp;
 166     }
 167 }
 168
 169 static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
 170                         int total_gain)
 171 {
 172     int v, bsize, ch, coef_nb_bits, parse_exponents;
 173     float mdct_norm;
 174     int nb_coefs[MAX_CHANNELS];
 175     static const int fixed_exp[25] = {
 176         20, 20, 20, 20, 20,
 177         20, 20, 20, 20, 20,
 178         20, 20, 20, 20, 20,
 179         20, 20, 20, 20, 20,
 180         20, 20, 20, 20, 20
 181     };
 182
 183     // FIXME remove duplication relative to decoder
 184     if (s->use_variable_block_len) {
 185         av_assert0(0); // FIXME not implemented
 186     } else {
 187         /* fixed block len */
 188         s->next_block_len_bits = s->frame_len_bits;
 189         s->prev_block_len_bits = s->frame_len_bits;
 190         s->block_len_bits      = s->frame_len_bits;
 191     }
 192
 193     s->block_len = 1 << s->block_len_bits;
 194 //     av_assert0((s->block_pos + s->block_len) <= s->frame_len);
 195     bsize = s->frame_len_bits - s->block_len_bits;
 196
 197     // FIXME factor
 198     v = s->coefs_end[bsize] - s->coefs_start;
 199     for (ch = 0; ch < s->avctx->channels; ch++)
 200         nb_coefs[ch] = v;
 201     {
 202         int n4 = s->block_len / 2;
 203         mdct_norm = 1.0 / (float) n4;
 204         if (s->version == 1)
 205             mdct_norm *= sqrt(n4);
 206     }
 207
 208     if (s->avctx->channels == 2)
 209         put_bits(&s->pb, 1, !!s->ms_stereo);
 210
 211     for (ch = 0; ch < s->avctx->channels; ch++) {
 212         // FIXME only set channel_coded when needed, instead of always
 213         s->channel_coded[ch] = 1;
 214         if (s->channel_coded[ch])
 215             init_exp(s, ch, fixed_exp);
 216     }
 217
 218     for (ch = 0; ch < s->avctx->channels; ch++) {
 219         if (s->channel_coded[ch]) {
 220             WMACoef *coefs1;
 221             float *coefs, *exponents, mult;
 222             int i, n;
 223
 224             coefs1    = s->coefs1[ch];
 225             exponents = s->exponents[ch];
 226             mult      = pow(10, total_gain * 0.05) / s->max_exponent[ch];
 227             mult     *= mdct_norm;
 228             coefs     = src_coefs[ch];
 229             if (s->use_noise_coding && 0) {
 230                 av_assert0(0); // FIXME not implemented
 231             } else {
 232                 coefs += s->coefs_start;
 233                 n      = nb_coefs[ch];
 234                 for (i = 0; i < n; i++) {
 235                     double t = *coefs++ / (exponents[i] * mult);
 236                     if (t < -32768 || t > 32767)
 237                         return -1;
 238
 239                     coefs1[i] = lrint(t);
 240                 }
 241             }
 242         }
 243     }
 244
 245     v = 0;
 246     for (ch = 0; ch < s->avctx->channels; ch++) {
 247         int a = s->channel_coded[ch];
 248         put_bits(&s->pb, 1, a);
 249         v |= a;
 250     }
 251
 252     if (!v)
 253         return 1;
 254
 255     for (v = total_gain - 1; v >= 127; v -= 127)
 256         put_bits(&s->pb, 7, 127);
 257     put_bits(&s->pb, 7, v);
 258
 259     coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
 260
 261     if (s->use_noise_coding) {
 262         for (ch = 0; ch < s->avctx->channels; ch++) {
 263             if (s->channel_coded[ch]) {
 264                 int i, n;
 265                 n = s->exponent_high_sizes[bsize];
 266                 for (i = 0; i < n; i++) {
 267                     put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
 268                     if (0)
 269                         nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
 270                 }
 271             }
 272         }
 273     }
 274
 275     parse_exponents = 1;
 276     if (s->block_len_bits != s->frame_len_bits)
 277         put_bits(&s->pb, 1, parse_exponents);
 278
 279     if (parse_exponents) {
 280         for (ch = 0; ch < s->avctx->channels; ch++) {
 281             if (s->channel_coded[ch]) {
 282                 if (s->use_exp_vlc) {
 283                     encode_exp_vlc(s, ch, fixed_exp);
 284                 } else {
 285                     av_assert0(0); // FIXME not implemented
 286 //                    encode_exp_lsp(s, ch);
 287                 }
 288             }
 289         }
 290     } else
 291         av_assert0(0); // FIXME not implemented
 292
 293     for (ch = 0; ch < s->avctx->channels; ch++) {
 294         if (s->channel_coded[ch]) {
 295             int run, tindex;
 296             WMACoef *ptr, *eptr;
 297             tindex = (ch == 1 && s->ms_stereo);
 298             ptr    = &s->coefs1[ch][0];
 299             eptr   = ptr + nb_coefs[ch];
 300
 301             run = 0;
 302             for (; ptr < eptr; ptr++) {
 303                 if (*ptr) {
 304                     int level     = *ptr;
 305                     int abs_level = FFABS(level);
 306                     int code      = 0;
 307                     if (abs_level <= s->coef_vlcs[tindex]->max_level)
 308                         if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
 309                             code = run + s->int_table[tindex][abs_level - 1];
 310
 311                     av_assert2(code < s->coef_vlcs[tindex]->n);
 312                     put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
 313                              s->coef_vlcs[tindex]->huffcodes[code]);
 314
 315                     if (code == 0) {
 316                         if (1 << coef_nb_bits <= abs_level)
 317                             return -1;
 318
 319                         put_bits(&s->pb, coef_nb_bits, abs_level);
 320                         put_bits(&s->pb, s->frame_len_bits, run);
 321                     }
 322                     // FIXME the sign is flipped somewhere
 323                     put_bits(&s->pb, 1, level < 0);
 324                     run = 0;
 325                 } else
 326                     run++;
 327             }
 328             if (run)
 329                 put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
 330                          s->coef_vlcs[tindex]->huffcodes[1]);
 331         }
 332         if (s->version == 1 && s->avctx->channels >= 2)
 333             avpriv_align_put_bits(&s->pb);
 334     }
 335     return 0;
 336 }
 337
 338 static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
 339                         uint8_t *buf, int buf_size, int total_gain)
 340 {
 341     init_put_bits(&s->pb, buf, buf_size);
 342
 343     if (s->use_bit_reservoir)
 344         av_assert0(0); // FIXME not implemented
 345     else if (encode_block(s, src_coefs, total_gain) < 0)
 346         return INT_MAX;
 347
 348     avpriv_align_put_bits(&s->pb);
 349
 350     return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
 351 }
 352
 353 static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
 354                              const AVFrame *frame, int *got_packet_ptr)
 355 {
 356     WMACodecContext *s = avctx->priv_data;
 357     int i, total_gain, ret, error;
 358
 359     s->block_len_bits = s->frame_len_bits; // required by non variable block len
 360     s->block_len      = 1 << s->block_len_bits;
 361
 362     apply_window_and_mdct(avctx, frame);
 363
 364     if (s->ms_stereo) {
 365         float a, b;
 366         int i;
 367
 368         for (i = 0; i < s->block_len; i++) {
 369             a              = s->coefs[0][i] * 0.5;
 370             b              = s->coefs[1][i] * 0.5;
 371             s->coefs[0][i] = a + b;
 372             s->coefs[1][i] = a - b;
 373         }
 374     }
 375
 376     if ((ret = ff_alloc_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE)) < 0)
 377         return ret;
 378
 379     total_gain = 128;
 380     for (i = 64; i; i >>= 1) {
 381         error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
 382                                  total_gain - i);
 383         if (error <= 0)
 384             total_gain -= i;
 385     }
 386
 387     while(total_gain <= 128 && error > 0)
 388         error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
 389     if (error > 0) {
 390         av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
 391         avpkt->size = 0;
 392         return AVERROR(EINVAL);
 393     }
 394     av_assert0((put_bits_count(&s->pb) & 7) == 0);
 395     i= avctx->block_align - (put_bits_count(&s->pb)+7)/8;
 396     av_assert0(i>=0);
 397     while(i--)
 398         put_bits(&s->pb, 8, 'N');
 399
 400     flush_put_bits(&s->pb);
 401     av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
 402
 403     if (frame->pts != AV_NOPTS_VALUE)
 404         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
 405
 406     avpkt->size     = avctx->block_align;
 407     *got_packet_ptr = 1;
 408     return 0;
 409 }
 410
 411 #if CONFIG_WMAV1_ENCODER
 412 AVCodec ff_wmav1_encoder = {
 413     .name           = "wmav1",
 414     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
 415     .type           = AVMEDIA_TYPE_AUDIO,
 416     .id             = AV_CODEC_ID_WMAV1,
 417     .priv_data_size = sizeof(WMACodecContext),
 418     .init           = encode_init,
 419     .encode2        = encode_superframe,
 420     .close          = ff_wma_end,
 421     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
 422                                                       AV_SAMPLE_FMT_NONE },
 423 };
 424 #endif
 425 #if CONFIG_WMAV2_ENCODER
 426 AVCodec ff_wmav2_encoder = {
 427     .name           = "wmav2",
 428     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
 429     .type           = AVMEDIA_TYPE_AUDIO,
 430     .id             = AV_CODEC_ID_WMAV2,
 431     .priv_data_size = sizeof(WMACodecContext),
 432     .init           = encode_init,
 433     .encode2        = encode_superframe,
 434     .close          = ff_wma_end,
 435     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
 436                                                       AV_SAMPLE_FMT_NONE },
 437 };
 438 #endif