libavcodec/bink.c:877: error: Uninitialized Value
  The value read from col[_] was never initialized.

libavcodec/bink.c:877:25: 
875.                     v = get_value(c, BINK_SRC_PATTERN);
876.                     for (j = 0; j < 8; j++, v >>= 1)
877.                         dst[i*stride + j] = col[v & 1];
                             ^
878.                 }
879.                 break;

static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,
                             int is_chroma)
{
    int blk;
    int i, j, bx, by;
    uint8_t *dst, *prev, *ref, *ref_start, *ref_end;
    int v, col[2];
    const uint8_t *scan;
    int xoff, yoff;
    DECLARE_ALIGNED_16(DCTELEM, block[64]);
    DECLARE_ALIGNED_16(uint8_t, ublock[64]);
    int coordmap[64];
    const int stride = c->pic.linesize[plane_idx];
    int bw = is_chroma ? (c->avctx->width  + 15) >> 4 : (c->avctx->width  + 7) >> 3;
    int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;
    int width = c->avctx->width >> is_chroma;
    init_lengths(c, FFMAX(width, 8), bw);
    for (i = 0; i < BINK_NB_SRC; i++)
        read_bundle(gb, c, i);
    ref_start = c->last.data[plane_idx];
    ref_end   = c->last.data[plane_idx]
                + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8;
    for (i = 0; i < 64; i++)
        coordmap[i] = (i & 7) + (i >> 3) * stride;
    for (by = 0; by < bh; by++) {
        if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)
            return -1;
        if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES]) < 0)
            return -1;
        if (read_colors(gb, &c->bundle[BINK_SRC_COLORS], c) < 0)
            return -1;
        if (read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN]) < 0)
            return -1;
        if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF]) < 0)
            return -1;
        if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)
            return -1;
        if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)
            return -1;
        if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)
            return -1;
        if (read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN]) < 0)
            return -1;
        if (by == bh)
            break;
        dst  = c->pic.data[plane_idx]  + 8*by*stride;
        prev = c->last.data[plane_idx] + 8*by*stride;
        for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
            blk = get_value(c, BINK_SRC_BLOCK_TYPES);
            if ((by & 1) && blk == SCALED_BLOCK) {
                bx++;
                dst  += 8;
                prev += 8;
                continue;
            }
            switch (blk) {
            case SKIP_BLOCK:
                c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8);
                break;
            case SCALED_BLOCK:
                blk = get_value(c, BINK_SRC_SUB_BLOCK_TYPES);
                switch (blk) {
                case RUN_BLOCK:
                    scan = bink_patterns[get_bits(gb, 4)];
                    i = 0;
                    do {
                        int run = get_value(c, BINK_SRC_RUN) + 1;
                        i += run;
                        if (i > 64) {
                            av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
                            return -1;
                        }
                        if (get_bits1(gb)) {
                            v = get_value(c, BINK_SRC_COLORS);
                            for (j = 0; j < run; j++)
                                ublock[*scan++] = v;
                        } else {
                            for (j = 0; j < run; j++)
                                ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
                        }
                    } while (i < 63);
                    if (i == 63)
                        ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
                    break;
                case INTRA_BLOCK:
                    c->dsp.clear_block(block);
                    block[0] = get_value(c, BINK_SRC_INTRA_DC);
                    read_dct_coeffs(gb, block, c->scantable.permutated, 1);
                    c->dsp.idct(block);
                    c->dsp.put_pixels_nonclamped(block, ublock, 8);
                    break;
                case FILL_BLOCK:
                    v = get_value(c, BINK_SRC_COLORS);
                    c->dsp.fill_block_tab[0](dst, v, stride, 16);
                    break;
                case PATTERN_BLOCK:
                    for (i = 0; i < 2; i++)
                        col[i] = get_value(c, BINK_SRC_COLORS);
                    for (j = 0; j < 8; j++) {
                        v = get_value(c, BINK_SRC_PATTERN);
                        for (i = 0; i < 8; i++, v >>= 1)
                            ublock[i + j*8] = col[v & 1];
                    }
                    break;
                case RAW_BLOCK:
                    for (j = 0; j < 8; j++)
                        for (i = 0; i < 8; i++)
                            ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
                    break;
                default:
                    av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
                    return -1;
                }
                if (blk != FILL_BLOCK)
                c->dsp.scale_block(ublock, dst, stride);
                bx++;
                dst  += 8;
                prev += 8;
                break;
            case MOTION_BLOCK:
                xoff = get_value(c, BINK_SRC_X_OFF);
                yoff = get_value(c, BINK_SRC_Y_OFF);
                ref = prev + xoff + yoff * stride;
                if (ref < ref_start || ref > ref_end) {
                    av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
                           bx*8 + xoff, by*8 + yoff);
                    return -1;
                }
                c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
                break;
            case RUN_BLOCK:
                scan = bink_patterns[get_bits(gb, 4)];
                i = 0;
                do {
                    int run = get_value(c, BINK_SRC_RUN) + 1;
                    i += run;
                    if (i > 64) {
                        av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\n");
                        return -1;
                    }
                    if (get_bits1(gb)) {
                        v = get_value(c, BINK_SRC_COLORS);
                        for (j = 0; j < run; j++)
                            dst[coordmap[*scan++]] = v;
                    } else {
                        for (j = 0; j < run; j++)
                            dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
                    }
                } while (i < 63);
                if (i == 63)
                    dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
                break;
            case RESIDUE_BLOCK:
                xoff = get_value(c, BINK_SRC_X_OFF);
                yoff = get_value(c, BINK_SRC_Y_OFF);
                ref = prev + xoff + yoff * stride;
                if (ref < ref_start || ref > ref_end) {
                    av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
                           bx*8 + xoff, by*8 + yoff);
                    return -1;
                }
                c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
                c->dsp.clear_block(block);
                v = get_bits(gb, 7);
                read_residue(gb, block, v);
                c->dsp.add_pixels8(dst, block, stride);
                break;
            case INTRA_BLOCK:
                c->dsp.clear_block(block);
                block[0] = get_value(c, BINK_SRC_INTRA_DC);
                read_dct_coeffs(gb, block, c->scantable.permutated, 1);
                c->dsp.idct_put(dst, stride, block);
                break;
            case FILL_BLOCK:
                v = get_value(c, BINK_SRC_COLORS);
                c->dsp.fill_block_tab[1](dst, v, stride, 8);
                break;
            case INTER_BLOCK:
                xoff = get_value(c, BINK_SRC_X_OFF);
                yoff = get_value(c, BINK_SRC_Y_OFF);
                ref = prev + xoff + yoff * stride;
                c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
                c->dsp.clear_block(block);
                block[0] = get_value(c, BINK_SRC_INTER_DC);
                read_dct_coeffs(gb, block, c->scantable.permutated, 0);
                c->dsp.idct_add(dst, stride, block);
                break;
            case PATTERN_BLOCK:
                for (i = 0; i < 2; i++)
                    col[i] = get_value(c, BINK_SRC_COLORS);
                for (i = 0; i < 8; i++) {
                    v = get_value(c, BINK_SRC_PATTERN);
                    for (j = 0; j < 8; j++, v >>= 1)
                        dst[i*stride + j] = col[v & 1];
                }
                break;
            case RAW_BLOCK:
                for (i = 0; i < 8; i++)
                    memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);
                c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
                break;
            default:
                av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
                return -1;
            }
        }
    }
    if (get_bits_count(gb) & 0x1F)
        skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));
    return 0;
}
['static int bink_decode_plane(BinkContext *c, GetBitContext *gb, int plane_idx,\n                             int is_chroma)\n{\n    int blk;\n    int i, j, bx, by;\n    uint8_t *dst, *prev, *ref, *ref_start, *ref_end;\n    int v, col[2];\n    const uint8_t *scan;\n    int xoff, yoff;\n    DECLARE_ALIGNED_16(DCTELEM, block[64]);\n    DECLARE_ALIGNED_16(uint8_t, ublock[64]);\n    int coordmap[64];\n    const int stride = c->pic.linesize[plane_idx];\n    int bw = is_chroma ? (c->avctx->width  + 15) >> 4 : (c->avctx->width  + 7) >> 3;\n    int bh = is_chroma ? (c->avctx->height + 15) >> 4 : (c->avctx->height + 7) >> 3;\n    int width = c->avctx->width >> is_chroma;\n    init_lengths(c, FFMAX(width, 8), bw);\n    for (i = 0; i < BINK_NB_SRC; i++)\n        read_bundle(gb, c, i);\n    ref_start = c->last.data[plane_idx];\n    ref_end   = c->last.data[plane_idx]\n                + (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8;\n    for (i = 0; i < 64; i++)\n        coordmap[i] = (i & 7) + (i >> 3) * stride;\n    for (by = 0; by < bh; by++) {\n        if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)\n            return -1;\n        if (read_block_types(c->avctx, gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES]) < 0)\n            return -1;\n        if (read_colors(gb, &c->bundle[BINK_SRC_COLORS], c) < 0)\n            return -1;\n        if (read_patterns(c->avctx, gb, &c->bundle[BINK_SRC_PATTERN]) < 0)\n            return -1;\n        if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_X_OFF]) < 0)\n            return -1;\n        if (read_motion_values(c->avctx, gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)\n            return -1;\n        if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)\n            return -1;\n        if (read_dcs(c->avctx, gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)\n            return -1;\n        if (read_runs(c->avctx, gb, &c->bundle[BINK_SRC_RUN]) < 0)\n            return -1;\n        if (by == bh)\n            break;\n        dst  = c->pic.data[plane_idx]  + 8*by*stride;\n        prev = c->last.data[plane_idx] + 8*by*stride;\n        for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {\n            blk = get_value(c, BINK_SRC_BLOCK_TYPES);\n            if ((by & 1) && blk == SCALED_BLOCK) {\n                bx++;\n                dst  += 8;\n                prev += 8;\n                continue;\n            }\n            switch (blk) {\n            case SKIP_BLOCK:\n                c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8);\n                break;\n            case SCALED_BLOCK:\n                blk = get_value(c, BINK_SRC_SUB_BLOCK_TYPES);\n                switch (blk) {\n                case RUN_BLOCK:\n                    scan = bink_patterns[get_bits(gb, 4)];\n                    i = 0;\n                    do {\n                        int run = get_value(c, BINK_SRC_RUN) + 1;\n                        i += run;\n                        if (i > 64) {\n                            av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\\n");\n                            return -1;\n                        }\n                        if (get_bits1(gb)) {\n                            v = get_value(c, BINK_SRC_COLORS);\n                            for (j = 0; j < run; j++)\n                                ublock[*scan++] = v;\n                        } else {\n                            for (j = 0; j < run; j++)\n                                ublock[*scan++] = get_value(c, BINK_SRC_COLORS);\n                        }\n                    } while (i < 63);\n                    if (i == 63)\n                        ublock[*scan++] = get_value(c, BINK_SRC_COLORS);\n                    break;\n                case INTRA_BLOCK:\n                    c->dsp.clear_block(block);\n                    block[0] = get_value(c, BINK_SRC_INTRA_DC);\n                    read_dct_coeffs(gb, block, c->scantable.permutated, 1);\n                    c->dsp.idct(block);\n                    c->dsp.put_pixels_nonclamped(block, ublock, 8);\n                    break;\n                case FILL_BLOCK:\n                    v = get_value(c, BINK_SRC_COLORS);\n                    c->dsp.fill_block_tab[0](dst, v, stride, 16);\n                    break;\n                case PATTERN_BLOCK:\n                    for (i = 0; i < 2; i++)\n                        col[i] = get_value(c, BINK_SRC_COLORS);\n                    for (j = 0; j < 8; j++) {\n                        v = get_value(c, BINK_SRC_PATTERN);\n                        for (i = 0; i < 8; i++, v >>= 1)\n                            ublock[i + j*8] = col[v & 1];\n                    }\n                    break;\n                case RAW_BLOCK:\n                    for (j = 0; j < 8; j++)\n                        for (i = 0; i < 8; i++)\n                            ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);\n                    break;\n                default:\n                    av_log(c->avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\\n", blk);\n                    return -1;\n                }\n                if (blk != FILL_BLOCK)\n                c->dsp.scale_block(ublock, dst, stride);\n                bx++;\n                dst  += 8;\n                prev += 8;\n                break;\n            case MOTION_BLOCK:\n                xoff = get_value(c, BINK_SRC_X_OFF);\n                yoff = get_value(c, BINK_SRC_Y_OFF);\n                ref = prev + xoff + yoff * stride;\n                if (ref < ref_start || ref > ref_end) {\n                    av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\\n",\n                           bx*8 + xoff, by*8 + yoff);\n                    return -1;\n                }\n                c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);\n                break;\n            case RUN_BLOCK:\n                scan = bink_patterns[get_bits(gb, 4)];\n                i = 0;\n                do {\n                    int run = get_value(c, BINK_SRC_RUN) + 1;\n                    i += run;\n                    if (i > 64) {\n                        av_log(c->avctx, AV_LOG_ERROR, "Run went out of bounds\\n");\n                        return -1;\n                    }\n                    if (get_bits1(gb)) {\n                        v = get_value(c, BINK_SRC_COLORS);\n                        for (j = 0; j < run; j++)\n                            dst[coordmap[*scan++]] = v;\n                    } else {\n                        for (j = 0; j < run; j++)\n                            dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);\n                    }\n                } while (i < 63);\n                if (i == 63)\n                    dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);\n                break;\n            case RESIDUE_BLOCK:\n                xoff = get_value(c, BINK_SRC_X_OFF);\n                yoff = get_value(c, BINK_SRC_Y_OFF);\n                ref = prev + xoff + yoff * stride;\n                if (ref < ref_start || ref > ref_end) {\n                    av_log(c->avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\\n",\n                           bx*8 + xoff, by*8 + yoff);\n                    return -1;\n                }\n                c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);\n                c->dsp.clear_block(block);\n                v = get_bits(gb, 7);\n                read_residue(gb, block, v);\n                c->dsp.add_pixels8(dst, block, stride);\n                break;\n            case INTRA_BLOCK:\n                c->dsp.clear_block(block);\n                block[0] = get_value(c, BINK_SRC_INTRA_DC);\n                read_dct_coeffs(gb, block, c->scantable.permutated, 1);\n                c->dsp.idct_put(dst, stride, block);\n                break;\n            case FILL_BLOCK:\n                v = get_value(c, BINK_SRC_COLORS);\n                c->dsp.fill_block_tab[1](dst, v, stride, 8);\n                break;\n            case INTER_BLOCK:\n                xoff = get_value(c, BINK_SRC_X_OFF);\n                yoff = get_value(c, BINK_SRC_Y_OFF);\n                ref = prev + xoff + yoff * stride;\n                c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);\n                c->dsp.clear_block(block);\n                block[0] = get_value(c, BINK_SRC_INTER_DC);\n                read_dct_coeffs(gb, block, c->scantable.permutated, 0);\n                c->dsp.idct_add(dst, stride, block);\n                break;\n            case PATTERN_BLOCK:\n                for (i = 0; i < 2; i++)\n                    col[i] = get_value(c, BINK_SRC_COLORS);\n                for (i = 0; i < 8; i++) {\n                    v = get_value(c, BINK_SRC_PATTERN);\n                    for (j = 0; j < 8; j++, v >>= 1)\n                        dst[i*stride + j] = col[v & 1];\n                }\n                break;\n            case RAW_BLOCK:\n                for (i = 0; i < 8; i++)\n                    memcpy(dst + i*stride, c->bundle[BINK_SRC_COLORS].cur_ptr + i*8, 8);\n                c->bundle[BINK_SRC_COLORS].cur_ptr += 64;\n                break;\n            default:\n                av_log(c->avctx, AV_LOG_ERROR, "Unknown block type %d\\n", blk);\n                return -1;\n            }\n        }\n    }\n    if (get_bits_count(gb) & 0x1F)\n        skip_bits_long(gb, 32 - (get_bits_count(gb) & 0x1F));\n    return 0;\n}']