twinvq.c 38.8 KB
Newer Older
Vitor Sessak's avatar
Vitor Sessak committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * TwinVQ decoder
 * Copyright (c) 2009 Vitor Sessak
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22
#include "libavutil/channel_layout.h"
23
#include "libavutil/float_dsp.h"
Vitor Sessak's avatar
Vitor Sessak committed
24 25
#include "avcodec.h"
#include "get_bits.h"
26
#include "fft.h"
27
#include "internal.h"
28
#include "lsp.h"
29
#include "sinewin.h"
Vitor Sessak's avatar
Vitor Sessak committed
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178

#include <math.h>
#include <stdint.h>

#include "twinvq_data.h"

enum FrameType {
    FT_SHORT = 0,  ///< Short frame  (divided in n   sub-blocks)
    FT_MEDIUM,     ///< Medium frame (divided in m<n sub-blocks)
    FT_LONG,       ///< Long frame   (single sub-block + PPC)
    FT_PPC,        ///< Periodic Peak Component (part of the long frame)
};

/**
 * Parameters and tables that are different for each frame type
 */
struct FrameMode {
    uint8_t         sub;      ///< Number subblocks in each frame
    const uint16_t *bark_tab;

    /** number of distinct bark scale envelope values */
    uint8_t         bark_env_size;

    const int16_t  *bark_cb;    ///< codebook for the bark scale envelope (BSE)
    uint8_t         bark_n_coef;///< number of BSE CB coefficients to read
    uint8_t         bark_n_bit; ///< number of bits of the BSE coefs

    //@{
    /** main codebooks for spectrum data */
    const int16_t    *cb0;
    const int16_t    *cb1;
    //@}

    uint8_t         cb_len_read; ///< number of spectrum coefficients to read
};

/**
 * Parameters and tables that are different for every combination of
 * bitrate/sample rate
 */
typedef struct {
    struct FrameMode fmode[3]; ///< frame type-dependant parameters

    uint16_t     size;        ///< frame size in samples
    uint8_t      n_lsp;       ///< number of lsp coefficients
    const float *lspcodebook;

    /* number of bits of the different LSP CB coefficients */
    uint8_t      lsp_bit0;
    uint8_t      lsp_bit1;
    uint8_t      lsp_bit2;

    uint8_t      lsp_split;      ///< number of CB entries for the LSP decoding
    const int16_t *ppc_shape_cb; ///< PPC shape CB

    /** number of the bits for the PPC period value */
    uint8_t      ppc_period_bit;

    uint8_t      ppc_shape_bit;  ///< number of bits of the PPC shape CB coeffs
    uint8_t      ppc_shape_len;  ///< size of PPC shape CB
    uint8_t      pgain_bit;      ///< bits for PPC gain

    /** constant for peak period to peak width conversion */
    uint16_t     peak_per2wid;
} ModeTab;

static const ModeTab mode_08_08 = {
    {
        { 8, bark_tab_s08_64,  10, tab.fcb08s  , 1, 5, tab.cb0808s0, tab.cb0808s1, 18},
        { 2, bark_tab_m08_256, 20, tab.fcb08m  , 2, 5, tab.cb0808m0, tab.cb0808m1, 16},
        { 1, bark_tab_l08_512, 30, tab.fcb08l  , 3, 6, tab.cb0808l0, tab.cb0808l1, 17}
    },
    512 , 12, tab.lsp08,   1, 5, 3, 3, tab.shape08  , 8, 28, 20, 6, 40
};

static const ModeTab mode_11_08 = {
    {
        { 8, bark_tab_s11_64,  10, tab.fcb11s  , 1, 5, tab.cb1108s0, tab.cb1108s1, 29},
        { 2, bark_tab_m11_256, 20, tab.fcb11m  , 2, 5, tab.cb1108m0, tab.cb1108m1, 24},
        { 1, bark_tab_l11_512, 30, tab.fcb11l  , 3, 6, tab.cb1108l0, tab.cb1108l1, 27}
    },
    512 , 16, tab.lsp11,   1, 6, 4, 3, tab.shape11  , 9, 36, 30, 7, 90
};

static const ModeTab mode_11_10 = {
    {
        { 8, bark_tab_s11_64,  10, tab.fcb11s  , 1, 5, tab.cb1110s0, tab.cb1110s1, 21},
        { 2, bark_tab_m11_256, 20, tab.fcb11m  , 2, 5, tab.cb1110m0, tab.cb1110m1, 18},
        { 1, bark_tab_l11_512, 30, tab.fcb11l  , 3, 6, tab.cb1110l0, tab.cb1110l1, 20}
    },
    512 , 16, tab.lsp11,   1, 6, 4, 3, tab.shape11  , 9, 36, 30, 7, 90
};

static const ModeTab mode_16_16 = {
    {
        { 8, bark_tab_s16_128, 10, tab.fcb16s  , 1, 5, tab.cb1616s0, tab.cb1616s1, 16},
        { 2, bark_tab_m16_512, 20, tab.fcb16m  , 2, 5, tab.cb1616m0, tab.cb1616m1, 15},
        { 1, bark_tab_l16_1024,30, tab.fcb16l  , 3, 6, tab.cb1616l0, tab.cb1616l1, 16}
    },
    1024, 16, tab.lsp16,   1, 6, 4, 3, tab.shape16  , 9, 56, 60, 7, 180
};

static const ModeTab mode_22_20 = {
    {
        { 8, bark_tab_s22_128, 10, tab.fcb22s_1, 1, 6, tab.cb2220s0, tab.cb2220s1, 18},
        { 2, bark_tab_m22_512, 20, tab.fcb22m_1, 2, 6, tab.cb2220m0, tab.cb2220m1, 17},
        { 1, bark_tab_l22_1024,32, tab.fcb22l_1, 4, 6, tab.cb2220l0, tab.cb2220l1, 18}
    },
    1024, 16, tab.lsp22_1, 1, 6, 4, 3, tab.shape22_1, 9, 56, 36, 7, 144
};

static const ModeTab mode_22_24 = {
    {
        { 8, bark_tab_s22_128, 10, tab.fcb22s_1, 1, 6, tab.cb2224s0, tab.cb2224s1, 15},
        { 2, bark_tab_m22_512, 20, tab.fcb22m_1, 2, 6, tab.cb2224m0, tab.cb2224m1, 14},
        { 1, bark_tab_l22_1024,32, tab.fcb22l_1, 4, 6, tab.cb2224l0, tab.cb2224l1, 15}
    },
    1024, 16, tab.lsp22_1, 1, 6, 4, 3, tab.shape22_1, 9, 56, 36, 7, 144
};

static const ModeTab mode_22_32 = {
    {
        { 4, bark_tab_s22_128, 10, tab.fcb22s_2, 1, 6, tab.cb2232s0, tab.cb2232s1, 11},
        { 2, bark_tab_m22_256, 20, tab.fcb22m_2, 2, 6, tab.cb2232m0, tab.cb2232m1, 11},
        { 1, bark_tab_l22_512, 32, tab.fcb22l_2, 4, 6, tab.cb2232l0, tab.cb2232l1, 12}
    },
    512 , 16, tab.lsp22_2, 1, 6, 4, 4, tab.shape22_2, 9, 56, 36, 7, 72
};

static const ModeTab mode_44_40 = {
    {
        {16, bark_tab_s44_128, 10, tab.fcb44s  , 1, 6, tab.cb4440s0, tab.cb4440s1, 18},
        { 4, bark_tab_m44_512, 20, tab.fcb44m  , 2, 6, tab.cb4440m0, tab.cb4440m1, 17},
        { 1, bark_tab_l44_2048,40, tab.fcb44l  , 4, 6, tab.cb4440l0, tab.cb4440l1, 17}
    },
    2048, 20, tab.lsp44,   1, 6, 4, 4, tab.shape44  , 9, 84, 54, 7, 432
};

static const ModeTab mode_44_48 = {
    {
        {16, bark_tab_s44_128, 10, tab.fcb44s  , 1, 6, tab.cb4448s0, tab.cb4448s1, 15},
        { 4, bark_tab_m44_512, 20, tab.fcb44m  , 2, 6, tab.cb4448m0, tab.cb4448m1, 14},
        { 1, bark_tab_l44_2048,40, tab.fcb44l  , 4, 6, tab.cb4448l0, tab.cb4448l1, 14}
    },
    2048, 20, tab.lsp44,   1, 6, 4, 4, tab.shape44  , 9, 84, 54, 7, 432
};

typedef struct TwinContext {
    AVCodecContext *avctx;
179
    AVFloatDSPContext fdsp;
180
    FFTContext mdct_ctx[3];
Vitor Sessak's avatar
Vitor Sessak committed
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

    const ModeTab *mtab;

    // history
    float lsp_hist[2][20];           ///< LSP coefficients of the last frame
    float bark_hist[3][2][40];       ///< BSE coefficients of last frame

    // bitstream parameters
    int16_t permut[4][4096];
    uint8_t length[4][2];            ///< main codebook stride
    uint8_t length_change[4];
    uint8_t bits_main_spec[2][4][2]; ///< bits for the main codebook
    int bits_main_spec_change[4];
    int n_div[4];

    float *spectrum;
    float *curr_frame;               ///< non-interleaved output
    float *prev_frame;               ///< non-interleaved previous frame
    int last_block_pos[2];
200
    int discarded_packets;
Vitor Sessak's avatar
Vitor Sessak committed
201 202 203 204 205 206 207 208

    float *cos_tabs[3];

    // scratch buffers
    float *tmp_buf;
} TwinContext;

#define PPC_SHAPE_CB_SIZE 64
Måns Rullgård's avatar
Måns Rullgård committed
209
#define PPC_SHAPE_LEN_MAX 60
Vitor Sessak's avatar
Vitor Sessak committed
210 211 212 213 214 215 216
#define SUB_AMP_MAX       4500.0
#define MULAW_MU          100.0
#define GAIN_BITS         8
#define AMP_MAX           13000.0
#define SUB_GAIN_BITS     5
#define WINDOW_TYPE_BITS  4
#define PGAIN_MU          200
Måns Rullgård's avatar
Måns Rullgård committed
217 218 219 220 221
#define LSP_COEFS_MAX     20
#define LSP_SPLIT_MAX     4
#define CHANNELS_MAX      2
#define SUBBLOCKS_MAX     16
#define BARK_N_COEF_MAX   4
Vitor Sessak's avatar
Vitor Sessak committed
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239

/** @note not speed critical, hence not optimized */
static void memset_float(float *buf, float val, int size)
{
    while (size--)
        *buf++ = val;
}

/**
 * Evaluate a single LPC amplitude spectrum envelope coefficient from the line
 * spectrum pairs.
 *
 * @param lsp a vector of the cosinus of the LSP values
 * @param cos_val cos(PI*i/N) where i is the index of the LPC amplitude
 * @param order the order of the LSP (and the size of the *lsp buffer). Must
 *        be a multiple of four.
 * @return the LPC value
 *
240
 * @todo reuse code from Vorbis decoder: vorbis_floor0_decode
Vitor Sessak's avatar
Vitor Sessak committed
241 242 243 244 245 246 247 248
 */
static float eval_lpc_spectrum(const float *lsp, float cos_val, int order)
{
    int j;
    float p = 0.5f;
    float q = 0.5f;
    float two_cos_w = 2.0f*cos_val;

Vitor Sessak's avatar
Vitor Sessak committed
249
    for (j = 0; j + 1 < order; j += 2*2) {
Vitor Sessak's avatar
Vitor Sessak committed
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
        // Unroll the loop once since order is a multiple of four
        q *= lsp[j  ] - two_cos_w;
        p *= lsp[j+1] - two_cos_w;

        q *= lsp[j+2] - two_cos_w;
        p *= lsp[j+3] - two_cos_w;
    }

    p *= p * (2.0f - two_cos_w);
    q *= q * (2.0f + two_cos_w);

    return 0.5 / (p + q);
}

/**
265
 * Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
Vitor Sessak's avatar
Vitor Sessak committed
266 267 268 269 270 271 272
 */
static void eval_lpcenv(TwinContext *tctx, const float *cos_vals, float *lpc)
{
    int i;
    const ModeTab *mtab = tctx->mtab;
    int size_s = mtab->size / mtab->fmode[FT_SHORT].sub;

Vitor Sessak's avatar
Vitor Sessak committed
273
    for (i = 0; i < size_s/2; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
274 275 276 277 278 279 280 281 282 283 284
        float cos_i = tctx->cos_tabs[0][i];
        lpc[i]          = eval_lpc_spectrum(cos_vals,  cos_i, mtab->n_lsp);
        lpc[size_s-i-1] = eval_lpc_spectrum(cos_vals, -cos_i, mtab->n_lsp);
    }
}

static void interpolate(float *out, float v1, float v2, int size)
{
    int i;
    float step = (v1 - v2)/(size + 1);

Vitor Sessak's avatar
Vitor Sessak committed
285
    for (i = 0; i < size; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
286 287 288 289 290 291 292 293 294 295 296 297
        v2 += step;
        out[i] = v2;
    }
}

static inline float get_cos(int idx, int part, const float *cos_tab, int size)
{
    return part ? -cos_tab[size - idx - 1] :
                   cos_tab[       idx    ];
}

/**
298
 * Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
Vitor Sessak's avatar
Vitor Sessak committed
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
 * Probably for speed reasons, the coefficients are evaluated as
 * siiiibiiiisiiiibiiiisiiiibiiiisiiiibiiiis ...
 * where s is an evaluated value, i is a value interpolated from the others
 * and b might be either calculated or interpolated, depending on an
 * unexplained condition.
 *
 * @param step the size of a block "siiiibiiii"
 * @param in the cosinus of the LSP data
 * @param part is 0 for 0...PI (positive cossinus values) and 1 for PI...2PI
          (negative cossinus values)
 * @param size the size of the whole output
 */
static inline void eval_lpcenv_or_interp(TwinContext *tctx,
                                         enum FrameType ftype,
                                         float *out, const float *in,
                                         int size, int step, int part)
{
    int i;
    const ModeTab *mtab = tctx->mtab;
    const float *cos_tab = tctx->cos_tabs[ftype];

    // Fill the 's'
Vitor Sessak's avatar
Vitor Sessak committed
321
    for (i = 0; i < size; i += step)
Vitor Sessak's avatar
Vitor Sessak committed
322 323 324 325 326 327
        out[i] =
            eval_lpc_spectrum(in,
                              get_cos(i, part, cos_tab, size),
                              mtab->n_lsp);

    // Fill the 'iiiibiiii'
Vitor Sessak's avatar
Vitor Sessak committed
328
    for (i = step; i <= size - 2*step; i += step) {
Vitor Sessak's avatar
Vitor Sessak committed
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
        if (out[i + step] + out[i - step] >  1.95*out[i] ||
            out[i + step]                 >=  out[i - step]) {
            interpolate(out + i - step + 1, out[i], out[i-step], step - 1);
        } else {
            out[i - step/2] =
                eval_lpc_spectrum(in,
                                  get_cos(i-step/2, part, cos_tab, size),
                                  mtab->n_lsp);
            interpolate(out + i - step   + 1, out[i-step/2], out[i-step  ], step/2 - 1);
            interpolate(out + i - step/2 + 1, out[i       ], out[i-step/2], step/2 - 1);
        }
    }

    interpolate(out + size - 2*step + 1, out[size-step], out[size - 2*step], step - 1);
}

static void eval_lpcenv_2parts(TwinContext *tctx, enum FrameType ftype,
                               const float *buf, float *lpc,
                               int size, int step)
{
    eval_lpcenv_or_interp(tctx, ftype, lpc         , buf, size/2,   step, 0);
    eval_lpcenv_or_interp(tctx, ftype, lpc + size/2, buf, size/2, 2*step, 1);

    interpolate(lpc+size/2-step+1, lpc[size/2], lpc[size/2-step], step);

    memset_float(lpc + size - 2*step + 1, lpc[size - 2*step], 2*step - 1);
}

/**
 * Inverse quantization. Read CB coefficients for cb1 and cb2 from the
 * bitstream, sum the corresponding vectors and write the result to *out
 * after permutation.
 */
static void dequant(TwinContext *tctx, GetBitContext *gb, float *out,
                    enum FrameType ftype,
                    const int16_t *cb0, const int16_t *cb1, int cb_len)
{
    int pos = 0;
    int i, j;

Vitor Sessak's avatar
Vitor Sessak committed
369
    for (i = 0; i < tctx->n_div[ftype]; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
        int tmp0, tmp1;
        int sign0 = 1;
        int sign1 = 1;
        const int16_t *tab0, *tab1;
        int length = tctx->length[ftype][i >= tctx->length_change[ftype]];
        int bitstream_second_part = (i >= tctx->bits_main_spec_change[ftype]);

        int bits = tctx->bits_main_spec[0][ftype][bitstream_second_part];
        if (bits == 7) {
            if (get_bits1(gb))
                sign0 = -1;
            bits = 6;
        }
        tmp0 = get_bits(gb, bits);

        bits = tctx->bits_main_spec[1][ftype][bitstream_second_part];

        if (bits == 7) {
            if (get_bits1(gb))
                sign1 = -1;

            bits = 6;
        }
        tmp1 = get_bits(gb, bits);

        tab0 = cb0 + tmp0*cb_len;
        tab1 = cb1 + tmp1*cb_len;

Vitor Sessak's avatar
Vitor Sessak committed
398
        for (j = 0; j < length; j++)
Vitor Sessak's avatar
Vitor Sessak committed
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
            out[tctx->permut[ftype][pos+j]] = sign0*tab0[j] + sign1*tab1[j];

        pos += length;
    }

}

static inline float mulawinv(float y, float clip, float mu)
{
    y = av_clipf(y/clip, -1, 1);
    return clip * FFSIGN(y) * (exp(log(1+mu) * fabs(y)) - 1) / mu;
}

/**
 * Evaluate a*b/400 rounded to the nearest integer. When, for example,
 * a*b == 200 and the nearest integer is ill-defined, use a table to emulate
 * the following broken float-based implementation used by the binary decoder:
 *
417
 * @code
Vitor Sessak's avatar
Vitor Sessak committed
418 419 420 421 422 423 424
 * static int very_broken_op(int a, int b)
 * {
 *    static float test; // Ugh, force gcc to do the division first...
 *
 *    test = a/400.;
 *    return b * test +  0.5;
 * }
425
 * @endcode
Vitor Sessak's avatar
Vitor Sessak committed
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
 *
 * @note if this function is replaced by just ROUNDED_DIV(a*b,400.), the stddev
 * between the original file (before encoding with Yamaha encoder) and the
 * decoded output increases, which leads one to believe that the encoder expects
 * exactly this broken calculation.
 */
static int very_broken_op(int a, int b)
{
    int x = a*b + 200;
    int size;
    const uint8_t *rtab;

    if (x%400 || b%5)
        return x/400;

    x /= 400;

    size = tabs[b/5].size;
    rtab = tabs[b/5].tab;
    return x - rtab[size*av_log2(2*(x - 1)/size)+(x - 1)%size];
}

/**
 * Sum to data a periodic peak of a given period, width and shape.
 *
 * @param period the period of the peak divised by 400.0
 */
static void add_peak(int period, int width, const float *shape,
                     float ppc_gain, float *speech, int len)
{
    int i, j;

    const float *shape_end = shape + len;
    int center;

    // First peak centered around zero
Vitor Sessak's avatar
Vitor Sessak committed
462
    for (i = 0; i < width/2; i++)
Vitor Sessak's avatar
Vitor Sessak committed
463 464
        speech[i] += ppc_gain * *shape++;

Vitor Sessak's avatar
Vitor Sessak committed
465
    for (i = 1; i < ROUNDED_DIV(len,width) ; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
466
        center = very_broken_op(period, i);
Vitor Sessak's avatar
Vitor Sessak committed
467
        for (j = -width/2; j < (width+1)/2; j++)
Vitor Sessak's avatar
Vitor Sessak committed
468 469 470 471 472
            speech[j+center] += ppc_gain * *shape++;
    }

    // For the last block, be careful not to go beyond the end of the buffer
    center = very_broken_op(period, i);
Vitor Sessak's avatar
Vitor Sessak committed
473
    for (j = -width/2; j < (width + 1)/2 && shape < shape_end; j++)
Vitor Sessak's avatar
Vitor Sessak committed
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
        speech[j+center] += ppc_gain * *shape++;
}

static void decode_ppc(TwinContext *tctx, int period_coef, const float *shape,
                       float ppc_gain, float *speech)
{
    const ModeTab *mtab = tctx->mtab;
    int isampf = tctx->avctx->sample_rate/1000;
    int ibps = tctx->avctx->bit_rate/(1000 * tctx->avctx->channels);
    int min_period = ROUNDED_DIV(  40*2*mtab->size, isampf);
    int max_period = ROUNDED_DIV(6*40*2*mtab->size, isampf);
    int period_range = max_period - min_period;

    // This is actually the period multiplied by 400. It is just linearly coded
    // between its maximum and minimum value.
    int period = min_period +
        ROUNDED_DIV(period_coef*period_range, (1 << mtab->ppc_period_bit) - 1);
    int width;

    if (isampf == 22 && ibps == 32) {
        // For some unknown reason, NTT decided to code this case differently...
        width = ROUNDED_DIV((period + 800)* mtab->peak_per2wid, 400*mtab->size);
    } else
        width =             (period      )* mtab->peak_per2wid/(400*mtab->size);

    add_peak(period, width, shape, ppc_gain, speech, mtab->ppc_shape_len);
}

static void dec_gain(TwinContext *tctx, GetBitContext *gb, enum FrameType ftype,
                     float *out)
{
    const ModeTab *mtab = tctx->mtab;
    int i, j;
    int sub = mtab->fmode[ftype].sub;
    float step     = AMP_MAX     / ((1 <<     GAIN_BITS) - 1);
    float sub_step = SUB_AMP_MAX / ((1 << SUB_GAIN_BITS) - 1);

    if (ftype == FT_LONG) {
Vitor Sessak's avatar
Vitor Sessak committed
512
        for (i = 0; i < tctx->avctx->channels; i++)
Vitor Sessak's avatar
Vitor Sessak committed
513 514 515 516
            out[i] = (1./(1<<13)) *
                mulawinv(step * 0.5 + step * get_bits(gb, GAIN_BITS),
                         AMP_MAX, MULAW_MU);
    } else {
Vitor Sessak's avatar
Vitor Sessak committed
517
        for (i = 0; i < tctx->avctx->channels; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
518 519 520 521
            float val = (1./(1<<23)) *
                mulawinv(step * 0.5 + step * get_bits(gb, GAIN_BITS),
                         AMP_MAX, MULAW_MU);

Vitor Sessak's avatar
Vitor Sessak committed
522
            for (j = 0; j < sub; j++) {
Vitor Sessak's avatar
Vitor Sessak committed
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
                out[i*sub + j] =
                    val*mulawinv(sub_step* 0.5 +
                                 sub_step* get_bits(gb, SUB_GAIN_BITS),
                                 SUB_AMP_MAX, MULAW_MU);
            }
        }
    }
}

/**
 * Rearrange the LSP coefficients so that they have a minimum distance of
 * min_dist. This function does it exactly as described in section of 3.2.4
 * of the G.729 specification (but interestingly is different from what the
 * reference decoder actually does).
 */
static void rearrange_lsp(int order, float *lsp, float min_dist)
{
    int i;
    float min_dist2 = min_dist * 0.5;
Vitor Sessak's avatar
Vitor Sessak committed
542
    for (i = 1; i < order; i++)
Vitor Sessak's avatar
Vitor Sessak committed
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
        if (lsp[i] - lsp[i-1] < min_dist) {
            float avg = (lsp[i] + lsp[i-1]) * 0.5;

            lsp[i-1] = avg - min_dist2;
            lsp[i  ] = avg + min_dist2;
        }
}

static void decode_lsp(TwinContext *tctx, int lpc_idx1, uint8_t *lpc_idx2,
                       int lpc_hist_idx, float *lsp, float *hist)
{
    const ModeTab *mtab = tctx->mtab;
    int i, j;

    const float *cb  =  mtab->lspcodebook;
    const float *cb2 =  cb  + (1 << mtab->lsp_bit1)*mtab->n_lsp;
    const float *cb3 =  cb2 + (1 << mtab->lsp_bit2)*mtab->n_lsp;

    const int8_t funny_rounding[4] = {
        -2,
        mtab->lsp_split == 4 ? -2 : 1,
        mtab->lsp_split == 4 ? -2 : 1,
        0
    };

Vitor Sessak's avatar
Vitor Sessak committed
568 569
    j = 0;
    for (i = 0; i < mtab->lsp_split; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
570 571 572 573 574 575 576 577
        int chunk_end = ((i + 1)*mtab->n_lsp + funny_rounding[i])/mtab->lsp_split;
        for (; j < chunk_end; j++)
            lsp[j] = cb [lpc_idx1    * mtab->n_lsp + j] +
                     cb2[lpc_idx2[i] * mtab->n_lsp + j];
    }

    rearrange_lsp(mtab->n_lsp, lsp, 0.0001);

Vitor Sessak's avatar
Vitor Sessak committed
578
    for (i = 0; i < mtab->n_lsp; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
579 580 581 582 583 584 585 586
        float tmp1 = 1. -          cb3[lpc_hist_idx*mtab->n_lsp + i];
        float tmp2 =     hist[i] * cb3[lpc_hist_idx*mtab->n_lsp + i];
        hist[i] = lsp[i];
        lsp[i]  = lsp[i] * tmp1 + tmp2;
    }

    rearrange_lsp(mtab->n_lsp, lsp, 0.0001);
    rearrange_lsp(mtab->n_lsp, lsp, 0.000095);
587
    ff_sort_nearly_sorted_floats(lsp, mtab->n_lsp);
Vitor Sessak's avatar
Vitor Sessak committed
588 589 590 591 592 593 594 595
}

static void dec_lpc_spectrum_inv(TwinContext *tctx, float *lsp,
                                 enum FrameType ftype, float *lpc)
{
    int i;
    int size = tctx->mtab->size / tctx->mtab->fmode[ftype].sub;

Vitor Sessak's avatar
Vitor Sessak committed
596
    for (i = 0; i < tctx->mtab->n_lsp; i++)
Vitor Sessak's avatar
Vitor Sessak committed
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
        lsp[i] =  2*cos(lsp[i]);

    switch (ftype) {
    case FT_LONG:
        eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 8);
        break;
    case FT_MEDIUM:
        eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 2);
        break;
    case FT_SHORT:
        eval_lpcenv(tctx, lsp, lpc);
        break;
    }
}

static void imdct_and_window(TwinContext *tctx, enum FrameType ftype, int wtype,
                            float *in, float *prev, int ch)
{
615
    FFTContext *mdct = &tctx->mdct_ctx[ftype];
Vitor Sessak's avatar
Vitor Sessak committed
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
    const ModeTab *mtab = tctx->mtab;
    int bsize = mtab->size / mtab->fmode[ftype].sub;
    int size  = mtab->size;
    float *buf1 = tctx->tmp_buf;
    int j;
    int wsize; // Window size
    float *out = tctx->curr_frame + 2*ch*mtab->size;
    float *out2 = out;
    float *prev_buf;
    int first_wsize;

    static const uint8_t wtype_to_wsize[]      = {0, 0, 2, 2, 2, 1, 0, 1, 1};
    int types_sizes[] = {
        mtab->size /    mtab->fmode[FT_LONG  ].sub,
        mtab->size /    mtab->fmode[FT_MEDIUM].sub,
        mtab->size / (2*mtab->fmode[FT_SHORT ].sub),
    };

    wsize = types_sizes[wtype_to_wsize[wtype]];
    first_wsize = wsize;
    prev_buf = prev + (size - bsize)/2;

Vitor Sessak's avatar
Vitor Sessak committed
638
    for (j = 0; j < mtab->fmode[ftype].sub; j++) {
Vitor Sessak's avatar
Vitor Sessak committed
639 640 641 642 643 644 645 646 647
        int sub_wtype = ftype == FT_MEDIUM ? 8 : wtype;

        if (!j && wtype == 4)
            sub_wtype = 4;
        else if (j == mtab->fmode[ftype].sub-1 && wtype == 7)
            sub_wtype = 7;

        wsize = types_sizes[wtype_to_wsize[sub_wtype]];

648
        mdct->imdct_half(mdct, buf1 + bsize*j, in + bsize*j);
Vitor Sessak's avatar
Vitor Sessak committed
649

650 651 652 653
        tctx->fdsp.vector_fmul_window(out2, prev_buf + (bsize-wsize) / 2,
                                      buf1 + bsize * j,
                                      ff_sine_windows[av_log2(wsize)],
                                      wsize / 2);
Vitor Sessak's avatar
Vitor Sessak committed
654 655 656 657 658 659 660 661 662 663 664 665 666
        out2 += wsize;

        memcpy(out2, buf1 + bsize*j + wsize/2, (bsize - wsize/2)*sizeof(float));

        out2 += ftype == FT_MEDIUM ? (bsize-wsize)/2 : bsize - wsize;

        prev_buf = buf1 + bsize*j + bsize/2;
    }

    tctx->last_block_pos[ch] = (size + first_wsize)/2;
}

static void imdct_output(TwinContext *tctx, enum FrameType ftype, int wtype,
667
                         float **out)
Vitor Sessak's avatar
Vitor Sessak committed
668 669
{
    const ModeTab *mtab = tctx->mtab;
670
    int size1, size2;
Vitor Sessak's avatar
Vitor Sessak committed
671
    float *prev_buf = tctx->prev_frame + tctx->last_block_pos[0];
672
    int i;
Vitor Sessak's avatar
Vitor Sessak committed
673

Vitor Sessak's avatar
Vitor Sessak committed
674
    for (i = 0; i < tctx->avctx->channels; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
675 676 677 678 679 680
        imdct_and_window(tctx, ftype, wtype,
                         tctx->spectrum + i*mtab->size,
                         prev_buf + 2*i*mtab->size,
                         i);
    }

681 682 683
    if (!out)
        return;

684 685
    size2 = tctx->last_block_pos[0];
    size1 = mtab->size - size2;
Vitor Sessak's avatar
Vitor Sessak committed
686

687 688
    memcpy(&out[0][0    ], prev_buf,         size1 * sizeof(out[0][0]));
    memcpy(&out[0][size1], tctx->curr_frame, size2 * sizeof(out[0][0]));
Vitor Sessak's avatar
Vitor Sessak committed
689

690 691 692
    if (tctx->avctx->channels == 2) {
        memcpy(&out[1][0],     &prev_buf[2*mtab->size],         size1 * sizeof(out[1][0]));
        memcpy(&out[1][size1], &tctx->curr_frame[2*mtab->size], size2 * sizeof(out[1][0]));
693
        tctx->fdsp.butterflies_float(out[0], out[1], mtab->size);
Vitor Sessak's avatar
Vitor Sessak committed
694 695 696 697 698 699 700 701 702 703 704 705 706 707
    }
}

static void dec_bark_env(TwinContext *tctx, const uint8_t *in, int use_hist,
                         int ch, float *out, float gain, enum FrameType ftype)
{
    const ModeTab *mtab = tctx->mtab;
    int i,j;
    float *hist = tctx->bark_hist[ftype][ch];
    float val = ((const float []) {0.4, 0.35, 0.28})[ftype];
    int bark_n_coef  = mtab->fmode[ftype].bark_n_coef;
    int fw_cb_len = mtab->fmode[ftype].bark_env_size / bark_n_coef;
    int idx = 0;

Vitor Sessak's avatar
Vitor Sessak committed
708 709
    for (i = 0; i < fw_cb_len; i++)
        for (j = 0; j < bark_n_coef; j++, idx++) {
Vitor Sessak's avatar
Vitor Sessak committed
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
            float tmp2 =
                mtab->fmode[ftype].bark_cb[fw_cb_len*in[j] + i] * (1./4096);
            float st = use_hist ?
                (1. - val) * tmp2 + val*hist[idx] + 1. : tmp2 + 1.;

            hist[idx] = tmp2;
            if (st < -1.) st = 1.;

            memset_float(out, st * gain, mtab->fmode[ftype].bark_tab[idx]);
            out += mtab->fmode[ftype].bark_tab[idx];
        }

}

static void read_and_decode_spectrum(TwinContext *tctx, GetBitContext *gb,
                                     float *out, enum FrameType ftype)
{
    const ModeTab *mtab = tctx->mtab;
    int channels = tctx->avctx->channels;
    int sub = mtab->fmode[ftype].sub;
    int block_size = mtab->size / sub;
Måns Rullgård's avatar
Måns Rullgård committed
731 732 733 734
    float gain[CHANNELS_MAX*SUBBLOCKS_MAX];
    float ppc_shape[PPC_SHAPE_LEN_MAX * CHANNELS_MAX * 4];
    uint8_t bark1[CHANNELS_MAX][SUBBLOCKS_MAX][BARK_N_COEF_MAX];
    uint8_t bark_use_hist[CHANNELS_MAX][SUBBLOCKS_MAX];
Vitor Sessak's avatar
Vitor Sessak committed
735

Måns Rullgård's avatar
Måns Rullgård committed
736 737 738
    uint8_t lpc_idx1[CHANNELS_MAX];
    uint8_t lpc_idx2[CHANNELS_MAX][LSP_SPLIT_MAX];
    uint8_t lpc_hist_idx[CHANNELS_MAX];
Vitor Sessak's avatar
Vitor Sessak committed
739 740 741 742 743 744 745

    int i, j, k;

    dequant(tctx, gb, out, ftype,
            mtab->fmode[ftype].cb0, mtab->fmode[ftype].cb1,
            mtab->fmode[ftype].cb_len_read);

Vitor Sessak's avatar
Vitor Sessak committed
746 747 748
    for (i = 0; i < channels; i++)
        for (j = 0; j < sub; j++)
            for (k = 0; k < mtab->fmode[ftype].bark_n_coef; k++)
Vitor Sessak's avatar
Vitor Sessak committed
749 750 751
                bark1[i][j][k] =
                    get_bits(gb, mtab->fmode[ftype].bark_n_bit);

Vitor Sessak's avatar
Vitor Sessak committed
752 753
    for (i = 0; i < channels; i++)
        for (j = 0; j < sub; j++)
Vitor Sessak's avatar
Vitor Sessak committed
754 755 756 757
            bark_use_hist[i][j] = get_bits1(gb);

    dec_gain(tctx, gb, ftype, gain);

Vitor Sessak's avatar
Vitor Sessak committed
758
    for (i = 0; i < channels; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
759 760 761
        lpc_hist_idx[i] = get_bits(gb, tctx->mtab->lsp_bit0);
        lpc_idx1    [i] = get_bits(gb, tctx->mtab->lsp_bit1);

Vitor Sessak's avatar
Vitor Sessak committed
762
        for (j = 0; j < tctx->mtab->lsp_split; j++)
Vitor Sessak's avatar
Vitor Sessak committed
763 764 765 766 767 768 769 770 771 772
            lpc_idx2[i][j] = get_bits(gb, tctx->mtab->lsp_bit2);
    }

    if (ftype == FT_LONG) {
        int cb_len_p = (tctx->n_div[3] + mtab->ppc_shape_len*channels - 1)/
            tctx->n_div[3];
        dequant(tctx, gb, ppc_shape, FT_PPC, mtab->ppc_shape_cb,
                mtab->ppc_shape_cb + cb_len_p*PPC_SHAPE_CB_SIZE, cb_len_p);
    }

Vitor Sessak's avatar
Vitor Sessak committed
773
    for (i = 0; i < channels; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
774
        float *chunk = out + mtab->size * i;
Måns Rullgård's avatar
Måns Rullgård committed
775
        float lsp[LSP_COEFS_MAX];
Vitor Sessak's avatar
Vitor Sessak committed
776

Vitor Sessak's avatar
Vitor Sessak committed
777
        for (j = 0; j < sub; j++) {
Vitor Sessak's avatar
Vitor Sessak committed
778 779 780
            dec_bark_env(tctx, bark1[i][j], bark_use_hist[i][j], i,
                         tctx->tmp_buf, gain[sub*i+j], ftype);

781 782
            tctx->fdsp.vector_fmul(chunk + block_size*j, chunk + block_size*j,
                                   tctx->tmp_buf, block_size);
Vitor Sessak's avatar
Vitor Sessak committed
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801

        }

        if (ftype == FT_LONG) {
            float pgain_step = 25000. / ((1 << mtab->pgain_bit) - 1);
            int p_coef = get_bits(gb, tctx->mtab->ppc_period_bit);
            int g_coef = get_bits(gb, tctx->mtab->pgain_bit);
            float v = 1./8192*
                mulawinv(pgain_step*g_coef+ pgain_step/2, 25000., PGAIN_MU);

            decode_ppc(tctx, p_coef, ppc_shape + i*mtab->ppc_shape_len, v,
                       chunk);
        }

        decode_lsp(tctx, lpc_idx1[i], lpc_idx2[i], lpc_hist_idx[i], lsp,
                   tctx->lsp_hist[i]);

        dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf);

Vitor Sessak's avatar
Vitor Sessak committed
802
        for (j = 0; j < mtab->fmode[ftype].sub; j++) {
803
            tctx->fdsp.vector_fmul(chunk, chunk, tctx->tmp_buf, block_size);
Vitor Sessak's avatar
Vitor Sessak committed
804 805 806 807 808 809
            chunk += block_size;
        }
    }
}

static int twin_decode_frame(AVCodecContext * avctx, void *data,
810
                             int *got_frame_ptr, AVPacket *avpkt)
Vitor Sessak's avatar
Vitor Sessak committed
811
{
812
    AVFrame *frame     = data;
Vitor Sessak's avatar
Vitor Sessak committed
813 814 815 816 817
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
    TwinContext *tctx = avctx->priv_data;
    GetBitContext gb;
    const ModeTab *mtab = tctx->mtab;
818
    float **out = NULL;
Vitor Sessak's avatar
Vitor Sessak committed
819
    enum FrameType ftype;
820
    int window_type, ret;
Vitor Sessak's avatar
Vitor Sessak committed
821 822 823 824 825 826 827 828
    static const enum FrameType wtype_to_ftype_table[] = {
        FT_LONG,   FT_LONG, FT_SHORT, FT_LONG,
        FT_MEDIUM, FT_LONG, FT_LONG,  FT_MEDIUM, FT_MEDIUM
    };

    if (buf_size*8 < avctx->bit_rate*mtab->size/avctx->sample_rate + 8) {
        av_log(avctx, AV_LOG_ERROR,
               "Frame too small (%d bytes). Truncated file?\n", buf_size);
829
        return AVERROR(EINVAL);
Vitor Sessak's avatar
Vitor Sessak committed
830 831
    }

832 833
    /* get output buffer */
    if (tctx->discarded_packets >= 2) {
834
        frame->nb_samples = mtab->size;
835
        if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
836 837 838
            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
            return ret;
        }
839
        out = (float **)frame->extended_data;
Vitor Sessak's avatar
Vitor Sessak committed
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
    }

    init_get_bits(&gb, buf, buf_size * 8);
    skip_bits(&gb, get_bits(&gb, 8));
    window_type = get_bits(&gb, WINDOW_TYPE_BITS);

    if (window_type > 8) {
        av_log(avctx, AV_LOG_ERROR, "Invalid window type, broken sample?\n");
        return -1;
    }

    ftype = wtype_to_ftype_table[window_type];

    read_and_decode_spectrum(tctx, &gb, tctx->spectrum, ftype);

    imdct_output(tctx, ftype, window_type, out);

    FFSWAP(float*, tctx->curr_frame, tctx->prev_frame);

859 860 861
    if (tctx->discarded_packets < 2) {
        tctx->discarded_packets++;
        *got_frame_ptr = 0;
Vitor Sessak's avatar
Vitor Sessak committed
862 863 864
        return buf_size;
    }

865
    *got_frame_ptr = 1;
Vitor Sessak's avatar
Vitor Sessak committed
866 867 868 869 870 871 872

    return buf_size;
}

/**
 * Init IMDCT and windowing tables
 */
873
static av_cold int init_mdct_win(TwinContext *tctx)
Vitor Sessak's avatar
Vitor Sessak committed
874
{
875
    int i, j, ret;
Vitor Sessak's avatar
Vitor Sessak committed
876 877 878 879 880 881
    const ModeTab *mtab = tctx->mtab;
    int size_s = mtab->size / mtab->fmode[FT_SHORT].sub;
    int size_m = mtab->size / mtab->fmode[FT_MEDIUM].sub;
    int channels = tctx->avctx->channels;
    float norm = channels == 1 ? 2. : 1.;

Vitor Sessak's avatar
Vitor Sessak committed
882
    for (i = 0; i < 3; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
883
        int bsize = tctx->mtab->size/tctx->mtab->fmode[i].sub;
884 885 886
        if ((ret = ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1,
                                -sqrt(norm/bsize) / (1<<15))))
            return ret;
Vitor Sessak's avatar
Vitor Sessak committed
887 888
    }

889 890
    FF_ALLOC_OR_GOTO(tctx->avctx, tctx->tmp_buf,
                     mtab->size * sizeof(*tctx->tmp_buf), alloc_fail);
Vitor Sessak's avatar
Vitor Sessak committed
891

892 893 894 895 896 897 898 899 900
    FF_ALLOC_OR_GOTO(tctx->avctx, tctx->spectrum,
                     2 * mtab->size * channels * sizeof(*tctx->spectrum),
                     alloc_fail);
    FF_ALLOC_OR_GOTO(tctx->avctx, tctx->curr_frame,
                     2 * mtab->size * channels * sizeof(*tctx->curr_frame),
                     alloc_fail);
    FF_ALLOC_OR_GOTO(tctx->avctx, tctx->prev_frame,
                     2 * mtab->size * channels * sizeof(*tctx->prev_frame),
                     alloc_fail);
Vitor Sessak's avatar
Vitor Sessak committed
901

Vitor Sessak's avatar
Vitor Sessak committed
902
    for (i = 0; i < 3; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
903 904
        int m = 4*mtab->size/mtab->fmode[i].sub;
        double freq = 2*M_PI/m;
905 906
        FF_ALLOC_OR_GOTO(tctx->avctx, tctx->cos_tabs[i],
                         (m / 4) * sizeof(*tctx->cos_tabs[i]), alloc_fail);
Vitor Sessak's avatar
Vitor Sessak committed
907

Vitor Sessak's avatar
Vitor Sessak committed
908
        for (j = 0; j <= m/8; j++)
Vitor Sessak's avatar
Vitor Sessak committed
909
            tctx->cos_tabs[i][j] = cos((2*j + 1)*freq);
Vitor Sessak's avatar
Vitor Sessak committed
910
        for (j = 1; j <  m/8; j++)
Vitor Sessak's avatar
Vitor Sessak committed
911 912 913 914
            tctx->cos_tabs[i][m/4-j] = tctx->cos_tabs[i][j];
    }


915 916 917
    ff_init_ff_sine_windows(av_log2(size_m));
    ff_init_ff_sine_windows(av_log2(size_s/2));
    ff_init_ff_sine_windows(av_log2(mtab->size));
918 919 920 921

    return 0;
alloc_fail:
    return AVERROR(ENOMEM);
Vitor Sessak's avatar
Vitor Sessak committed
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
}

/**
 * Interpret the data as if it were a num_blocks x line_len[0] matrix and for
 * each line do a cyclic permutation, i.e.
 * abcdefghijklm -> defghijklmabc
 * where the amount to be shifted is evaluated depending on the column.
 */
static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks,
                              int block_size,
                              const uint8_t line_len[2], int length_div,
                              enum FrameType ftype)

{
    int i,j;

Vitor Sessak's avatar
Vitor Sessak committed
938
    for (i = 0; i < line_len[0]; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
939 940 941 942 943 944 945 946 947 948 949 950
        int shift;

        if (num_blocks == 1 ||
            (ftype == FT_LONG && num_vect % num_blocks) ||
            (ftype != FT_LONG && num_vect & 1         ) ||
            i == line_len[1]) {
            shift = 0;
        } else if (ftype == FT_LONG) {
            shift = i;
        } else
            shift = i*i;

Vitor Sessak's avatar
Vitor Sessak committed
951
        for (j = 0; j < num_vect && (j+num_vect*i < block_size*num_blocks); j++)
Vitor Sessak's avatar
Vitor Sessak committed
952 953 954 955 956 957 958
            tab[i*num_vect+j] = i*num_vect + (j + shift) % num_vect;
    }
}

/**
 * Interpret the input data as in the following table:
 *
959
 * @verbatim
Vitor Sessak's avatar
Vitor Sessak committed
960 961 962 963 964 965
 *
 * abcdefgh
 * ijklmnop
 * qrstuvw
 * x123456
 *
966
 * @endverbatim
Vitor Sessak's avatar
Vitor Sessak committed
967 968 969 970 971 972 973 974 975
 *
 * and transpose it, giving the output
 * aiqxbjr1cks2dlt3emu4fvn5gow6hp
 */
static void transpose_perm(int16_t *out, int16_t *in, int num_vect,
                           const uint8_t line_len[2], int length_div)
{
    int i,j;
    int cont= 0;
Vitor Sessak's avatar
Vitor Sessak committed
976 977
    for (i = 0; i < num_vect; i++)
        for (j = 0; j < line_len[i >= length_div]; j++)
Vitor Sessak's avatar
Vitor Sessak committed
978 979 980 981 982 983 984 985
            out[cont++] = in[j*num_vect + i];
}

static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
{
    int block_size = size/n_blocks;
    int i;

Vitor Sessak's avatar
Vitor Sessak committed
986
    for (i = 0; i < size; i++)
Vitor Sessak's avatar
Vitor Sessak committed
987 988 989 990 991 992 993
        out[i] = block_size * (in[i] % n_blocks) + in[i] / n_blocks;
}

static av_cold void construct_perm_table(TwinContext *tctx,enum FrameType ftype)
{
    int block_size;
    const ModeTab *mtab = tctx->mtab;
994
    int size;
Vitor Sessak's avatar
Vitor Sessak committed
995 996 997 998 999
    int16_t *tmp_perm = (int16_t *) tctx->tmp_buf;

    if (ftype == FT_PPC) {
        size  = tctx->avctx->channels;
        block_size = mtab->ppc_shape_len;
1000 1001
    } else {
        size       = tctx->avctx->channels * mtab->fmode[ftype].sub;
Vitor Sessak's avatar
Vitor Sessak committed
1002
        block_size = mtab->size / mtab->fmode[ftype].sub;
1003
    }
Vitor Sessak's avatar
Vitor Sessak committed
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031

    permutate_in_line(tmp_perm, tctx->n_div[ftype], size,
                      block_size, tctx->length[ftype],
                      tctx->length_change[ftype], ftype);

    transpose_perm(tctx->permut[ftype], tmp_perm, tctx->n_div[ftype],
                   tctx->length[ftype], tctx->length_change[ftype]);

    linear_perm(tctx->permut[ftype], tctx->permut[ftype], size,
                size*block_size);
}

static av_cold void init_bitstream_params(TwinContext *tctx)
{
    const ModeTab *mtab = tctx->mtab;
    int n_ch = tctx->avctx->channels;
    int total_fr_bits = tctx->avctx->bit_rate*mtab->size/
                             tctx->avctx->sample_rate;

    int lsp_bits_per_block = n_ch*(mtab->lsp_bit0 + mtab->lsp_bit1 +
                                   mtab->lsp_split*mtab->lsp_bit2);

    int ppc_bits = n_ch*(mtab->pgain_bit + mtab->ppc_shape_bit +
                         mtab->ppc_period_bit);

    int bsize_no_main_cb[3];
    int bse_bits[3];
    int i;
1032
    enum FrameType frametype;
Vitor Sessak's avatar
Vitor Sessak committed
1033

Vitor Sessak's avatar
Vitor Sessak committed
1034
    for (i = 0; i < 3; i++)
Vitor Sessak's avatar
Vitor Sessak committed
1035 1036 1037 1038 1039 1040 1041
        // +1 for history usage switch
        bse_bits[i] = n_ch *
            (mtab->fmode[i].bark_n_coef * mtab->fmode[i].bark_n_bit + 1);

    bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits +
                          WINDOW_TYPE_BITS + n_ch*GAIN_BITS;

Vitor Sessak's avatar
Vitor Sessak committed
1042
    for (i = 0; i < 2; i++)
Vitor Sessak's avatar
Vitor Sessak committed
1043 1044 1045 1046 1047
        bsize_no_main_cb[i] =
            lsp_bits_per_block + n_ch*GAIN_BITS + WINDOW_TYPE_BITS +
            mtab->fmode[i].sub*(bse_bits[i] + n_ch*SUB_GAIN_BITS);

    // The remaining bits are all used for the main spectrum coefficients
Vitor Sessak's avatar
Vitor Sessak committed
1048
    for (i = 0; i < 4; i++) {
Vitor Sessak's avatar
Vitor Sessak committed
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
        int bit_size;
        int vect_size;
        int rounded_up, rounded_down, num_rounded_down, num_rounded_up;
        if (i == 3) {
            bit_size  = n_ch * mtab->ppc_shape_bit;
            vect_size = n_ch * mtab->ppc_shape_len;
        } else {
            bit_size = total_fr_bits - bsize_no_main_cb[i];
            vect_size = n_ch * mtab->size;
        }

        tctx->n_div[i] = (bit_size + 13) / 14;

        rounded_up   = (bit_size + tctx->n_div[i] - 1)/tctx->n_div[i];
        rounded_down = (bit_size           )/tctx->n_div[i];
        num_rounded_down = rounded_up * tctx->n_div[i] - bit_size;
        num_rounded_up = tctx->n_div[i] - num_rounded_down;
        tctx->bits_main_spec[0][i][0] = (rounded_up   + 1)/2;
        tctx->bits_main_spec[1][i][0] = (rounded_up      )/2;
        tctx->bits_main_spec[0][i][1] = (rounded_down + 1)/2;
        tctx->bits_main_spec[1][i][1] = (rounded_down    )/2;
        tctx->bits_main_spec_change[i] = num_rounded_up;

        rounded_up   = (vect_size + tctx->n_div[i] - 1)/tctx->n_div[i];
        rounded_down = (vect_size                     )/tctx->n_div[i];
        num_rounded_down = rounded_up * tctx->n_div[i] - vect_size;
        num_rounded_up = tctx->n_div[i] - num_rounded_down;
        tctx->length[i][0] = rounded_up;
        tctx->length[i][1] = rounded_down;
        tctx->length_change[i] = num_rounded_up;
    }

1081 1082
    for (frametype = FT_SHORT; frametype <= FT_PPC; frametype++)
        construct_perm_table(tctx, frametype);
Vitor Sessak's avatar
Vitor Sessak committed
1083 1084
}

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
static av_cold int twin_decode_close(AVCodecContext *avctx)
{
    TwinContext *tctx = avctx->priv_data;
    int i;

    for (i = 0; i < 3; i++) {
        ff_mdct_end(&tctx->mdct_ctx[i]);
        av_free(tctx->cos_tabs[i]);
    }


    av_free(tctx->curr_frame);
    av_free(tctx->spectrum);
    av_free(tctx->prev_frame);
    av_free(tctx->tmp_buf);

    return 0;
}

Vitor Sessak's avatar
Vitor Sessak committed
1104 1105
static av_cold int twin_decode_init(AVCodecContext *avctx)
{
1106
    int ret;
Vitor Sessak's avatar
Vitor Sessak committed
1107
    TwinContext *tctx = avctx->priv_data;
1108
    int isampf, ibps;
Vitor Sessak's avatar
Vitor Sessak committed
1109 1110

    tctx->avctx       = avctx;
1111
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
Vitor Sessak's avatar
Vitor Sessak committed
1112

1113 1114 1115 1116 1117 1118 1119
    if (!avctx->extradata || avctx->extradata_size < 12) {
        av_log(avctx, AV_LOG_ERROR, "Missing or incomplete extradata\n");
        return AVERROR_INVALIDDATA;
    }
    avctx->channels = AV_RB32(avctx->extradata    ) + 1;
    avctx->bit_rate = AV_RB32(avctx->extradata + 4) * 1000;
    isampf          = AV_RB32(avctx->extradata + 8);
1120 1121 1122 1123 1124

    if (isampf < 8 || isampf > 44) {
        av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate\n");
        return AVERROR_INVALIDDATA;
    }
1125 1126 1127 1128 1129 1130 1131
    switch (isampf) {
    case 44: avctx->sample_rate = 44100;         break;
    case 22: avctx->sample_rate = 22050;         break;
    case 11: avctx->sample_rate = 11025;         break;
    default: avctx->sample_rate = isampf * 1000; break;
    }

1132
    if (avctx->channels <= 0 || avctx->channels > CHANNELS_MAX) {
Vitor Sessak's avatar
Vitor Sessak committed
1133 1134 1135 1136
        av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %i\n",
               avctx->channels);
        return -1;
    }
1137 1138 1139
    avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
                                                   AV_CH_LAYOUT_STEREO;

1140
    ibps = avctx->bit_rate / (1000 * avctx->channels);
Vitor Sessak's avatar
Vitor Sessak committed
1141

1142
    if (ibps > 255U) {
1143 1144 1145 1146
        av_log(avctx, AV_LOG_ERROR, "unsupported per channel bitrate %dkbps\n", ibps);
        return AVERROR_INVALIDDATA;
    }

Vitor Sessak's avatar
Vitor Sessak committed
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
    switch ((isampf << 8) +  ibps) {
    case (8 <<8) +  8: tctx->mtab = &mode_08_08; break;
    case (11<<8) +  8: tctx->mtab = &mode_11_08; break;
    case (11<<8) + 10: tctx->mtab = &mode_11_10; break;
    case (16<<8) + 16: tctx->mtab = &mode_16_16; break;
    case (22<<8) + 20: tctx->mtab = &mode_22_20; break;
    case (22<<8) + 24: tctx->mtab = &mode_22_24; break;
    case (22<<8) + 32: tctx->mtab = &mode_22_32; break;
    case (44<<8) + 40: tctx->mtab = &mode_44_40; break;
    case (44<<8) + 48: tctx->mtab = &mode_44_48; break;
    default:
        av_log(avctx, AV_LOG_ERROR, "This version does not support %d kHz - %d kbit/s/ch mode.\n", isampf, isampf);
        return -1;
    }

1162
    avpriv_float_dsp_init(&tctx->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
1163 1164 1165 1166 1167
    if ((ret = init_mdct_win(tctx))) {
        av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
        twin_decode_close(avctx);
        return ret;
    }
Vitor Sessak's avatar
Vitor Sessak committed
1168 1169 1170 1171 1172 1173 1174
    init_bitstream_params(tctx);

    memset_float(tctx->bark_hist[0][0], 0.1, FF_ARRAY_ELEMS(tctx->bark_hist));

    return 0;
}

1175 1176 1177
AVCodec ff_twinvq_decoder = {
    .name           = "twinvq",
    .type           = AVMEDIA_TYPE_AUDIO,
1178
    .id             = AV_CODEC_ID_TWINVQ,
1179 1180 1181 1182
    .priv_data_size = sizeof(TwinContext),
    .init           = twin_decode_init,
    .close          = twin_decode_close,
    .decode         = twin_decode_frame,
1183
    .capabilities   = CODEC_CAP_DR1,
1184
    .long_name      = NULL_IF_CONFIG_SMALL("VQF TwinVQ"),
1185 1186
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                      AV_SAMPLE_FMT_NONE },
Vitor Sessak's avatar
Vitor Sessak committed
1187
};