libavcodec/alsdec.c:793: error: Uninitialized Value
  The value read from sx[_] was never initialized.

libavcodec/alsdec.c:793:13: 
791.             delta[sb] = 5 - s[sb] + k[sb];
792. 
793.             ff_bgmc_decode(bc, sb_len, current_res, delta[sb], sx[sb], &high,
                 ^
794.                            &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
795. 

static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
{
    ALSSpecificConfig *sconf = &ctx->sconf;
    AVCodecContext *avctx    = ctx->avctx;
    BitstreamContext *bc     = &ctx->bc;
    unsigned int k;
    unsigned int s[8];
    unsigned int sx[8];
    unsigned int sub_blocks, log2_sub_blocks, sb_length;
    unsigned int start      = 0;
    unsigned int opt_order;
    int          sb;
    int32_t      *quant_cof = bd->quant_cof;
    int32_t      *current_res;
    *bd->const_block = 0;
    *bd->opt_order  = 1;
    bd->js_blocks   = bitstream_read_bit(bc);
    opt_order       = *bd->opt_order;
    if (!sconf->bgmc && !sconf->sb_part) {
        log2_sub_blocks = 0;
    } else {
        if (sconf->bgmc && sconf->sb_part)
            log2_sub_blocks = bitstream_read(bc, 2);
        else
            log2_sub_blocks = 2 * bitstream_read_bit(bc);
    }
    sub_blocks = 1 << log2_sub_blocks;
    if (bd->block_length & (sub_blocks - 1)) {
        av_log(avctx, AV_LOG_WARNING,
               "Block length is not evenly divisible by the number of subblocks.\n");
        return AVERROR_INVALIDDATA;
    }
    sb_length = bd->block_length >> log2_sub_blocks;
    if (sconf->bgmc) {
        s[0] = bitstream_read(bc, 8 + (sconf->resolution > 1));
        for (k = 1; k < sub_blocks; k++)
            s[k] = s[k - 1] + decode_rice(bc, 2);
        for (k = 0; k < sub_blocks; k++) {
            sx[k]   = s[k] & 0x0F;
            s [k] >>= 4;
        }
    } else {
        s[0] = bitstream_read(bc, 4 + (sconf->resolution > 1));
        for (k = 1; k < sub_blocks; k++)
            s[k] = s[k - 1] + decode_rice(bc, 0);
    }
    for (k = 1; k < sub_blocks; k++)
        if (s[k] > 32) {
            av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\n");
            return AVERROR_INVALIDDATA;
        }
    if (bitstream_read_bit(bc))
        *bd->shift_lsbs = bitstream_read(bc, 4) + 1;
    *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs;
    if (!sconf->rlslms) {
        if (sconf->adapt_order && sconf->max_order) {
            int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
                                                2, sconf->max_order + 1));
            *bd->opt_order       = bitstream_read(bc, opt_order_length);
            if (*bd->opt_order > sconf->max_order) {
                *bd->opt_order = sconf->max_order;
                av_log(avctx, AV_LOG_ERROR, "Predictor order too large!\n");
                return AVERROR_INVALIDDATA;
            }
        } else {
            *bd->opt_order = sconf->max_order;
        }
        opt_order = *bd->opt_order;
        if (opt_order) {
            int add_base;
            if (sconf->coef_table == 3) {
                add_base = 0x7F;
                quant_cof[0] = 32 * parcor_scaled_values[bitstream_read(bc, 7)];
                if (opt_order > 1)
                    quant_cof[1] = -32 * parcor_scaled_values[bitstream_read(bc, 7)];
                for (k = 2; k < opt_order; k++)
                    quant_cof[k] = bitstream_read(bc, 7);
            } else {
                int k_max;
                add_base = 1;
                k_max = FFMIN(opt_order, 20);
                for (k = 0; k < k_max; k++) {
                    int rice_param = parcor_rice_table[sconf->coef_table][k][1];
                    int offset     = parcor_rice_table[sconf->coef_table][k][0];
                    quant_cof[k] = decode_rice(bc, rice_param) + offset;
                    if (quant_cof[k] < -64 || quant_cof[k] > 63) {
                        av_log(avctx, AV_LOG_ERROR,
                               "quant_cof %"PRIu32" is out of range\n",
                               quant_cof[k]);
                        return AVERROR_INVALIDDATA;
                    }
                }
                k_max = FFMIN(opt_order, 127);
                for (; k < k_max; k++)
                    quant_cof[k] = decode_rice(bc, 2) + (k & 1);
                for (; k < opt_order; k++)
                    quant_cof[k] = decode_rice(bc, 1);
                quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
                if (opt_order > 1)
                    quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
            }
            for (k = 2; k < opt_order; k++)
                quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
        }
    }
    if (sconf->long_term_prediction) {
        *bd->use_ltp = bitstream_read_bit(bc);
        if (*bd->use_ltp) {
            int r, c;
            bd->ltp_gain[0]   = decode_rice(bc, 1) << 3;
            bd->ltp_gain[1]   = decode_rice(bc, 2) << 3;
            r                 = get_unary(bc, 0, 3);
            c                 = bitstream_read(bc, 2);
            bd->ltp_gain[2]   = ltp_gain_values[r][c];
            bd->ltp_gain[3]   = decode_rice(bc, 2) << 3;
            bd->ltp_gain[4]   = decode_rice(bc, 1) << 3;
            *bd->ltp_lag      = bitstream_read(bc, ctx->ltp_lag_length);
            *bd->ltp_lag     += FFMAX(4, opt_order + 1);
        }
    }
    if (bd->ra_block) {
        if (opt_order)
            bd->raw_samples[0] = decode_rice(bc, avctx->bits_per_raw_sample - 4);
        if (opt_order > 1)
            bd->raw_samples[1] = decode_rice(bc, FFMIN(s[0] + 3, ctx->s_max));
        if (opt_order > 2)
            bd->raw_samples[2] = decode_rice(bc, FFMIN(s[0] + 1, ctx->s_max));
        start = FFMIN(opt_order, 3);
    }
    if (sconf->bgmc) {
        int          delta[8];
        unsigned int k    [8];
        unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
        unsigned int high;
        unsigned int low;
        unsigned int value;
        ff_bgmc_decode_init(bc, &high, &low, &value);
        current_res = bd->raw_samples + start;
        for (sb = 0; sb < sub_blocks; sb++) {
            unsigned int sb_len  = sb_length - (sb ? 0 : start);
            k    [sb] = s[sb] > b ? s[sb] - b : 0;
            delta[sb] = 5 - s[sb] + k[sb];
            ff_bgmc_decode(bc, sb_len, current_res, delta[sb], sx[sb], &high,
                           &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
            current_res += sb_len;
        }
        ff_bgmc_decode_end(bc);
        current_res = bd->raw_samples + start;
        for (sb = 0; sb < sub_blocks; sb++, start = 0) {
            unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
            unsigned int cur_k         = k[sb];
            unsigned int cur_s         = s[sb];
            for (; start < sb_length; start++) {
                int32_t res = *current_res;
                if (res == cur_tail_code) {
                    unsigned int max_msb =   (2 + (sx[sb] > 2) + (sx[sb] > 10))
                                          << (5 - delta[sb]);
                    res = decode_rice(bc, cur_s);
                    if (res >= 0) {
                        res += (max_msb    ) << cur_k;
                    } else {
                        res -= (max_msb - 1) << cur_k;
                    }
                } else {
                    if (res > cur_tail_code)
                        res--;
                    if (res & 1)
                        res = -res;
                    res >>= 1;
                    if (cur_k) {
                        res <<= cur_k;
                        res  |= bitstream_read(bc, cur_k);
                    }
                }
                *current_res++ = res;
            }
        }
    } else {
        current_res = bd->raw_samples + start;
        for (sb = 0; sb < sub_blocks; sb++, start = 0)
            for (; start < sb_length; start++)
                *current_res++ = decode_rice(bc, s[sb]);
     }
    if (!sconf->mc_coding || ctx->js_switch)
        bitstream_align(bc);
    return 0;
}
['static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)\n{\n    ALSSpecificConfig *sconf = &ctx->sconf;\n    AVCodecContext *avctx    = ctx->avctx;\n    BitstreamContext *bc     = &ctx->bc;\n    unsigned int k;\n    unsigned int s[8];\n    unsigned int sx[8];\n    unsigned int sub_blocks, log2_sub_blocks, sb_length;\n    unsigned int start      = 0;\n    unsigned int opt_order;\n    int          sb;\n    int32_t      *quant_cof = bd->quant_cof;\n    int32_t      *current_res;\n    *bd->const_block = 0;\n    *bd->opt_order  = 1;\n    bd->js_blocks   = bitstream_read_bit(bc);\n    opt_order       = *bd->opt_order;\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 = bitstream_read(bc, 2);\n        else\n            log2_sub_blocks = 2 * bitstream_read_bit(bc);\n    }\n    sub_blocks = 1 << log2_sub_blocks;\n    if (bd->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 AVERROR_INVALIDDATA;\n    }\n    sb_length = bd->block_length >> log2_sub_blocks;\n    if (sconf->bgmc) {\n        s[0] = bitstream_read(bc, 8 + (sconf->resolution > 1));\n        for (k = 1; k < sub_blocks; k++)\n            s[k] = s[k - 1] + decode_rice(bc, 2);\n        for (k = 0; k < sub_blocks; k++) {\n            sx[k]   = s[k] & 0x0F;\n            s [k] >>= 4;\n        }\n    } else {\n        s[0] = bitstream_read(bc, 4 + (sconf->resolution > 1));\n        for (k = 1; k < sub_blocks; k++)\n            s[k] = s[k - 1] + decode_rice(bc, 0);\n    }\n    for (k = 1; k < sub_blocks; k++)\n        if (s[k] > 32) {\n            av_log(avctx, AV_LOG_ERROR, "k invalid for rice code.\\n");\n            return AVERROR_INVALIDDATA;\n        }\n    if (bitstream_read_bit(bc))\n        *bd->shift_lsbs = bitstream_read(bc, 4) + 1;\n    *bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || *bd->shift_lsbs;\n    if (!sconf->rlslms) {\n        if (sconf->adapt_order && sconf->max_order) {\n            int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,\n                                                2, sconf->max_order + 1));\n            *bd->opt_order       = bitstream_read(bc, opt_order_length);\n            if (*bd->opt_order > sconf->max_order) {\n                *bd->opt_order = sconf->max_order;\n                av_log(avctx, AV_LOG_ERROR, "Predictor order too large!\\n");\n                return AVERROR_INVALIDDATA;\n            }\n        } else {\n            *bd->opt_order = sconf->max_order;\n        }\n        opt_order = *bd->opt_order;\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[bitstream_read(bc, 7)];\n                if (opt_order > 1)\n                    quant_cof[1] = -32 * parcor_scaled_values[bitstream_read(bc, 7)];\n                for (k = 2; k < opt_order; k++)\n                    quant_cof[k] = bitstream_read(bc, 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(bc, rice_param) + offset;\n                    if (quant_cof[k] < -64 || quant_cof[k] > 63) {\n                        av_log(avctx, AV_LOG_ERROR,\n                               "quant_cof %"PRIu32" is out of range\\n",\n                               quant_cof[k]);\n                        return AVERROR_INVALIDDATA;\n                    }\n                }\n                k_max = FFMIN(opt_order, 127);\n                for (; k < k_max; k++)\n                    quant_cof[k] = decode_rice(bc, 2) + (k & 1);\n                for (; k < opt_order; k++)\n                    quant_cof[k] = decode_rice(bc, 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        *bd->use_ltp = bitstream_read_bit(bc);\n        if (*bd->use_ltp) {\n            int r, c;\n            bd->ltp_gain[0]   = decode_rice(bc, 1) << 3;\n            bd->ltp_gain[1]   = decode_rice(bc, 2) << 3;\n            r                 = get_unary(bc, 0, 3);\n            c                 = bitstream_read(bc, 2);\n            bd->ltp_gain[2]   = ltp_gain_values[r][c];\n            bd->ltp_gain[3]   = decode_rice(bc, 2) << 3;\n            bd->ltp_gain[4]   = decode_rice(bc, 1) << 3;\n            *bd->ltp_lag      = bitstream_read(bc, ctx->ltp_lag_length);\n            *bd->ltp_lag     += FFMAX(4, opt_order + 1);\n        }\n    }\n    if (bd->ra_block) {\n        if (opt_order)\n            bd->raw_samples[0] = decode_rice(bc, avctx->bits_per_raw_sample - 4);\n        if (opt_order > 1)\n            bd->raw_samples[1] = decode_rice(bc, FFMIN(s[0] + 3, ctx->s_max));\n        if (opt_order > 2)\n            bd->raw_samples[2] = decode_rice(bc, FFMIN(s[0] + 1, ctx->s_max));\n        start = FFMIN(opt_order, 3);\n    }\n    if (sconf->bgmc) {\n        int          delta[8];\n        unsigned int k    [8];\n        unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);\n        unsigned int high;\n        unsigned int low;\n        unsigned int value;\n        ff_bgmc_decode_init(bc, &high, &low, &value);\n        current_res = bd->raw_samples + start;\n        for (sb = 0; sb < sub_blocks; sb++) {\n            unsigned int sb_len  = sb_length - (sb ? 0 : start);\n            k    [sb] = s[sb] > b ? s[sb] - b : 0;\n            delta[sb] = 5 - s[sb] + k[sb];\n            ff_bgmc_decode(bc, sb_len, current_res, delta[sb], sx[sb], &high,\n                           &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);\n            current_res += sb_len;\n        }\n        ff_bgmc_decode_end(bc);\n        current_res = bd->raw_samples + start;\n        for (sb = 0; sb < sub_blocks; sb++, start = 0) {\n            unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];\n            unsigned int cur_k         = k[sb];\n            unsigned int cur_s         = s[sb];\n            for (; start < sb_length; start++) {\n                int32_t res = *current_res;\n                if (res == cur_tail_code) {\n                    unsigned int max_msb =   (2 + (sx[sb] > 2) + (sx[sb] > 10))\n                                          << (5 - delta[sb]);\n                    res = decode_rice(bc, cur_s);\n                    if (res >= 0) {\n                        res += (max_msb    ) << cur_k;\n                    } else {\n                        res -= (max_msb - 1) << cur_k;\n                    }\n                } else {\n                    if (res > cur_tail_code)\n                        res--;\n                    if (res & 1)\n                        res = -res;\n                    res >>= 1;\n                    if (cur_k) {\n                        res <<= cur_k;\n                        res  |= bitstream_read(bc, cur_k);\n                    }\n                }\n                *current_res++ = res;\n            }\n        }\n    } else {\n        current_res = bd->raw_samples + start;\n        for (sb = 0; sb < sub_blocks; sb++, start = 0)\n            for (; start < sb_length; start++)\n                *current_res++ = decode_rice(bc, s[sb]);\n     }\n    if (!sconf->mc_coding || ctx->js_switch)\n        bitstream_align(bc);\n    return 0;\n}']