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

libavcodec/bink.c:794:33: 
792.                             v = get_value(c, BINK_SRC_PATTERN);
793.                             for (i = 0; i < 8; i++, v >>= 1)
794.                                 ublock[i + j*8] = col[v & 1];
                                     ^
795.                         }
796.                         break;

static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
{
    BinkContext * const c = avctx->priv_data;
    GetBitContext gb;
    int blk;
    int i, j, plane, plane_idx, 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];
    if(c->pic.data[0])
        avctx->release_buffer(avctx, &c->pic);
    if(avctx->get_buffer(avctx, &c->pic) < 0){
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return -1;
    }
    init_get_bits(&gb, pkt->data, pkt->size*8);
    if (c->version >= 'i')
        skip_bits_long(&gb, 32);
    for (plane = 0; plane < 3; plane++) {
        const int stride = c->pic.linesize[plane];
        int bw = plane ? (avctx->width  + 15) >> 4 : (avctx->width  + 7) >> 3;
        int bh = plane ? (avctx->height + 15) >> 4 : (avctx->height + 7) >> 3;
        init_lengths(c, avctx->width >> !!plane, bw);
        for (i = 0; i < BINK_NB_SRC; i++)
            read_bundle(&gb, c, i);
        plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);
        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(avctx, &gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)
                return -1;
            if (read_block_types(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(avctx, &gb, &c->bundle[BINK_SRC_PATTERN]) < 0)
                return -1;
            if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_X_OFF]) < 0)
                return -1;
            if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)
                return -1;
            if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)
                return -1;
            if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)
                return -1;
            if (read_runs(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(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(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(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(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(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(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));
    }
    emms_c();
    *data_size = sizeof(AVFrame);
    *(AVFrame*)data = c->pic;
    FFSWAP(AVFrame, c->pic, c->last);
    return pkt->size;
}
['static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)\n{\n    BinkContext * const c = avctx->priv_data;\n    GetBitContext gb;\n    int blk;\n    int i, j, plane, plane_idx, 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    if(c->pic.data[0])\n        avctx->release_buffer(avctx, &c->pic);\n    if(avctx->get_buffer(avctx, &c->pic) < 0){\n        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\\n");\n        return -1;\n    }\n    init_get_bits(&gb, pkt->data, pkt->size*8);\n    if (c->version >= \'i\')\n        skip_bits_long(&gb, 32);\n    for (plane = 0; plane < 3; plane++) {\n        const int stride = c->pic.linesize[plane];\n        int bw = plane ? (avctx->width  + 15) >> 4 : (avctx->width  + 7) >> 3;\n        int bh = plane ? (avctx->height + 15) >> 4 : (avctx->height + 7) >> 3;\n        init_lengths(c, avctx->width >> !!plane, bw);\n        for (i = 0; i < BINK_NB_SRC; i++)\n            read_bundle(&gb, c, i);\n        plane_idx = (!plane || !c->swap_planes) ? plane : (plane ^ 3);\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(avctx, &gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)\n                return -1;\n            if (read_block_types(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(avctx, &gb, &c->bundle[BINK_SRC_PATTERN]) < 0)\n                return -1;\n            if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_X_OFF]) < 0)\n                return -1;\n            if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)\n                return -1;\n            if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)\n                return -1;\n            if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)\n                return -1;\n            if (read_runs(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(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(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(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(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(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(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    }\n    emms_c();\n    *data_size = sizeof(AVFrame);\n    *(AVFrame*)data = c->pic;\n    FFSWAP(AVFrame, c->pic, c->last);\n    return pkt->size;\n}']