libavcodec/alsdec.c:688: error: Integer Overflow L2
  ([0, +oo] - 1):unsigned32 by call to `parcor_to_lpc`.

libavcodec/alsdec.c:511:5: Assignment
509.     unsigned int s[8];
510.     unsigned int sub_blocks, log2_sub_blocks, sb_length;
511.     unsigned int opt_order  = 1;
         ^
512.     int32_t      *quant_cof = ctx->quant_cof;
513.     int32_t      *lpc_cof   = ctx->lpc_cof;

libavcodec/alsdec.c:688:13: Call
686. 
687.             raw_samples[smp] -= y >> 20;
688.             parcor_to_lpc(smp, quant_cof, lpc_cof);
                 ^
689.         }
690.     } else {

libavcodec/alsdec.c:399:1: <LHS trace>
397. /** Converts PARCOR coefficient k to direct filter coefficient.
398.  */
399. static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
     ^
400. {
401.     int i, j;

libavcodec/alsdec.c:399:1: Parameter `k`
  397. /** Converts PARCOR coefficient k to direct filter coefficient.
  398.  */
  399. static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
       ^
  400. {
  401.     int i, j;

libavcodec/alsdec.c:403:17: Binary operation: ([0, +oo] - 1):unsigned32 by call to `parcor_to_lpc` 
  401.     int i, j;
  402. 
  403.     for (i = 0, j = k - 1; i < j; i++, j--) {
                       ^
  404.         int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
  405.         cof[j]  += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);

static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
{
    int i, j;
    for (i = 0, j = k - 1; i < j; i++, j--) {
        int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
        cof[j]  += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
        cof[i]  += tmp1;
    }
    if (i == j)
        cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
    cof[k] = par[k];
}
['static int read_var_block(ALSDecContext *ctx, unsigned int ra_block,\n                          int32_t *raw_samples, unsigned int block_length,\n                          unsigned int *js_blocks, int32_t *raw_other,\n                          unsigned int *shift_lsbs)\n{\n    ALSSpecificConfig *sconf = &ctx->sconf;\n    AVCodecContext *avctx    = ctx->avctx;\n    GetBitContext *gb        = &ctx->gb;\n    unsigned int k;\n    unsigned int s[8];\n    unsigned int sub_blocks, log2_sub_blocks, sb_length;\n    unsigned int opt_order  = 1;\n    int32_t      *quant_cof = ctx->quant_cof;\n    int32_t      *lpc_cof   = ctx->lpc_cof;\n    unsigned int start      = 0;\n    int          smp        = 0;\n    int          sb, store_prev_samples;\n    int64_t      y;\n    int          use_ltp    = 0;\n    int          ltp_lag    = 0;\n    int          ltp_gain[5];\n    *js_blocks  = get_bits1(gb);\n    if (!sconf->bgmc && !sconf->sb_part) {\n        log2_sub_blocks = 0;\n    } else {\n        if (sconf->bgmc && sconf->sb_part)\n            log2_sub_blocks = get_bits(gb, 2);\n        else\n            log2_sub_blocks = 2 * get_bits1(gb);\n    }\n    sub_blocks = 1 << log2_sub_blocks;\n    if (block_length & (sub_blocks - 1)) {\n        av_log(avctx, AV_LOG_WARNING,\n               "Block length is not evenly divisible by the number of subblocks.\\n");\n        return -1;\n    }\n    sb_length = block_length >> log2_sub_blocks;\n    if (sconf->bgmc) {\n    } else {\n        s[0] = get_bits(gb, 4 + (sconf->resolution > 1));\n        for (k = 1; k < sub_blocks; k++)\n            s[k] = s[k - 1] + decode_rice(gb, 0);\n    }\n    if (get_bits1(gb))\n        *shift_lsbs = get_bits(gb, 4) + 1;\n    store_prev_samples = (*js_blocks && raw_other) || *shift_lsbs;\n    if (!sconf->rlslms) {\n        if (sconf->adapt_order) {\n            int opt_order_length = av_ceil_log2(av_clip((block_length >> 3) - 1,\n                                                2, sconf->max_order + 1));\n            opt_order            = get_bits(gb, opt_order_length);\n        } else {\n            opt_order = sconf->max_order;\n        }\n        if (opt_order) {\n            int add_base;\n            if (sconf->coef_table == 3) {\n                add_base = 0x7F;\n                quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];\n                if (opt_order > 1)\n                    quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];\n                for (k = 2; k < opt_order; k++)\n                    quant_cof[k] = get_bits(gb, 7);\n            } else {\n                int k_max;\n                add_base = 1;\n                k_max = FFMIN(opt_order, 20);\n                for (k = 0; k < k_max; k++) {\n                    int rice_param = parcor_rice_table[sconf->coef_table][k][1];\n                    int offset     = parcor_rice_table[sconf->coef_table][k][0];\n                    quant_cof[k] = decode_rice(gb, rice_param) + offset;\n                }\n                k_max = FFMIN(opt_order, 127);\n                for (; k < k_max; k++)\n                    quant_cof[k] = decode_rice(gb, 2) + (k & 1);\n                for (; k < opt_order; k++)\n                    quant_cof[k] = decode_rice(gb, 1);\n                quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];\n                if (opt_order > 1)\n                    quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];\n            }\n            for (k = 2; k < opt_order; k++)\n                quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);\n        }\n    }\n    if (sconf->long_term_prediction) {\n        use_ltp = get_bits1(gb);\n        if (use_ltp) {\n            ltp_gain[0]   = decode_rice(gb, 1) << 3;\n            ltp_gain[1]   = decode_rice(gb, 2) << 3;\n            ltp_gain[2]   = ltp_gain_values[get_unary(gb, 0, 4)][get_bits(gb, 2)];\n            ltp_gain[3]   = decode_rice(gb, 2) << 3;\n            ltp_gain[4]   = decode_rice(gb, 1) << 3;\n            ltp_lag       = get_bits(gb, ctx->ltp_lag_length);\n            ltp_lag      += FFMAX(4, opt_order + 1);\n        }\n    }\n    if (ra_block) {\n        if (opt_order)\n            raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);\n        if (opt_order > 1)\n            raw_samples[1] = decode_rice(gb, s[0] + 3);\n        if (opt_order > 2)\n            raw_samples[2] = decode_rice(gb, s[0] + 1);\n        start = FFMIN(opt_order, 3);\n    }\n    if (sconf->bgmc) {\n    } else {\n        int32_t *current_res = raw_samples + start;\n        for (sb = 0; sb < sub_blocks; sb++, start = 0)\n            for (; start < sb_length; start++)\n                *current_res++ = decode_rice(gb, s[sb]);\n     }\n    if (use_ltp) {\n        int ltp_smp;\n        for (ltp_smp = FFMAX(ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {\n            int center = ltp_smp - ltp_lag;\n            int begin  = FFMAX(0, center - 2);\n            int end    = center + 3;\n            int tab    = 5 - (end - begin);\n            int base;\n            y = 1 << 6;\n            for (base = begin; base < end; base++, tab++)\n                y += MUL64(ltp_gain[tab], raw_samples[base]);\n            raw_samples[ltp_smp] += y >> 7;\n        }\n    }\n    if (ra_block) {\n        for (smp = 0; smp < opt_order; smp++) {\n            y = 1 << 19;\n            for (sb = 0; sb < smp; sb++)\n                y += MUL64(lpc_cof[sb],raw_samples[smp - (sb + 1)]);\n            raw_samples[smp] -= y >> 20;\n            parcor_to_lpc(smp, quant_cof, lpc_cof);\n        }\n    } else {\n        for (k = 0; k < opt_order; k++)\n            parcor_to_lpc(k, quant_cof, lpc_cof);\n        if (store_prev_samples)\n            memcpy(ctx->prev_raw_samples, raw_samples - sconf->max_order,\n                   sizeof(*ctx->prev_raw_samples) * sconf->max_order);\n        if (*js_blocks && raw_other) {\n            int32_t *left, *right;\n            if (raw_other > raw_samples) {\n                left  = raw_samples;\n                right = raw_other;\n            } else {\n                left  = raw_other;\n                right = raw_samples;\n            }\n            for (sb = -1; sb >= -sconf->max_order; sb--)\n                raw_samples[sb] = right[sb] - left[sb];\n        }\n        if (*shift_lsbs)\n            for (sb = -1; sb >= -sconf->max_order; sb--)\n                raw_samples[sb] >>= *shift_lsbs;\n    }\n    for (; smp < block_length; smp++) {\n        y = 1 << 19;\n        for (sb = 0; sb < opt_order; sb++)\n            y += MUL64(lpc_cof[sb],raw_samples[smp - (sb + 1)]);\n        raw_samples[smp] -= y >> 20;\n    }\n    if (store_prev_samples)\n        memcpy(raw_samples - sconf->max_order, ctx->prev_raw_samples,\n               sizeof(*raw_samples) * sconf->max_order);\n    return 0;\n}', 'static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)\n{\n    int i, j;\n    for (i = 0, j = k - 1; i < j; i++, j--) {\n        int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);\n        cof[j]  += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);\n        cof[i]  += tmp1;\n    }\n    if (i == j)\n        cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);\n    cof[k] = par[k];\n}']