static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)

{

    SCPRContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    int cx = 0, cx1 = 0, k = 0, clr = 0;

    int run, r, g, b, off, y = 0, x = 0, z, ret;

    unsigned backstep = linesize - avctx->width;

    const int cxshift = s->cxshift;

    unsigned lx, ly, ptype;



    reinit_tables(s);

    bytestream2_skip(gb, 2);

    init_rangecoder(&s->rc, gb);



    while (k < avctx->width + 1) {

        ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);

        if (ret < 0)

            return ret;



        cx1 = (cx << 6) & 0xFC0;

        cx = r >> cxshift;

        ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);

        if (ret < 0)

            return ret;



        cx1 = (cx << 6) & 0xFC0;

        cx = g >> cxshift;

        ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);

        if (ret < 0)

            return ret;



        cx1 = (cx << 6) & 0xFC0;

        cx = b >> cxshift;



        ret = decode_value(s, s->run_model[0], 256, 400, &run);

        if (ret < 0)

            return ret;



        clr = (b << 16) + (g << 8) + r;

        k += run;

        while (run-- > 0) {

            if (y >= avctx->height)

                return AVERROR_INVALIDDATA;



            dst[y * linesize + x] = clr;

            lx = x;

            ly = y;

            x++;

            if (x >= avctx->width) {

                x = 0;

                y++;

            }

        }

    }

    off = -linesize - 1;

    ptype = 0;



    while (x < avctx->width && y < avctx->height) {

        ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);

        if (ret < 0)

            return ret;

        if (ptype == 0) {

            ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);

            if (ret < 0)

                return ret;



            cx1 = (cx << 6) & 0xFC0;

            cx = r >> cxshift;

            ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);

            if (ret < 0)

                return ret;



            cx1 = (cx << 6) & 0xFC0;

            cx = g >> cxshift;

            ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);

            if (ret < 0)

                return ret;



            clr = (b << 16) + (g << 8) + r;

        }

        if (ptype > 5)

            return AVERROR_INVALIDDATA;

        ret = decode_value(s, s->run_model[ptype], 256, 400, &run);

        if (ret < 0)

            return ret;



        switch (ptype) {

        case 0:

            while (run-- > 0) {

                if (y >= avctx->height)

                    return AVERROR_INVALIDDATA;



                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        case 1:

            while (run-- > 0) {

                if (y >= avctx->height)

                    return AVERROR_INVALIDDATA;



                dst[y * linesize + x] = dst[ly * linesize + lx];

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            clr = dst[ly * linesize + lx];

            break;

        case 2:

            while (run-- > 0) {

                if (y < 1 || y >= avctx->height)

                    return AVERROR_INVALIDDATA;



                clr = dst[y * linesize + x + off + 1];

                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        case 4:

            while (run-- > 0) {

                uint8_t *odst = (uint8_t *)dst;



                if (y < 1 || y >= avctx->height ||

                    (y == 1 && x == 0))

                    return AVERROR_INVALIDDATA;



                if (x == 0) {

                    z = backstep;

                } else {

                    z = 0;

                }



                r = odst[(ly * linesize + lx) * 4] +

                    odst[((y * linesize + x) + off - z) * 4 + 4] -

                    odst[((y * linesize + x) + off - z) * 4];

                g = odst[(ly * linesize + lx) * 4 + 1] +

                    odst[((y * linesize + x) + off - z) * 4 + 5] -

                    odst[((y * linesize + x) + off - z) * 4 + 1];

                b = odst[(ly * linesize + lx) * 4 + 2] +

                    odst[((y * linesize + x) + off - z) * 4 + 6] -

                    odst[((y * linesize + x) + off - z) * 4 + 2];

                clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);

                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        case 5:

            while (run-- > 0) {

                if (y < 1 || y >= avctx->height ||

                    (y == 1 && x == 0))

                    return AVERROR_INVALIDDATA;



                if (x == 0) {

                    z = backstep;

                } else {

                    z = 0;

                }



                clr = dst[y * linesize + x + off - z];

                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        }



        if (avctx->bits_per_coded_sample == 16) {

            cx1 = (clr & 0x3F00) >> 2;

            cx = (clr & 0xFFFFFF) >> 16;

        } else {

            cx1 = (clr & 0xFC00) >> 4;

            cx = (clr & 0xFFFFFF) >> 18;

        }

    }



    return 0;

}

static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)

{

    SCPRContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    int cx = 0, cx1 = 0, k = 0, clr = 0;

    int run, r, g, b, off, y = 0, x = 0, z, ret;

    unsigned backstep = linesize - avctx->width;

    const int cxshift = s->cxshift;

    unsigned lx, ly, ptype;



    reinit_tables(s);

    bytestream2_skip(gb, 2);

    init_rangecoder(&s->rc, gb);



    while (k < avctx->width + 1) {

        ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);

        if (ret < 0)

            return ret;



        cx1 = (cx << 6) & 0xFC0;

        cx = r >> cxshift;

        ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);

        if (ret < 0)

            return ret;



        cx1 = (cx << 6) & 0xFC0;

        cx = g >> cxshift;

        ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);

        if (ret < 0)

            return ret;



        cx1 = (cx << 6) & 0xFC0;

        cx = b >> cxshift;



        ret = decode_value(s, s->run_model[0], 256, 400, &run);

        if (ret < 0)

            return ret;



        clr = (b << 16) + (g << 8) + r;

        k += run;

        while (run-- > 0) {

            if (y >= avctx->height)

                return AVERROR_INVALIDDATA;



            dst[y * linesize + x] = clr;

            lx = x;

            ly = y;

            x++;

            if (x >= avctx->width) {

                x = 0;

                y++;

            }

        }

    }

    off = -linesize - 1;

    ptype = 0;



    while (x < avctx->width && y < avctx->height) {

        ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);

        if (ret < 0)

            return ret;

        if (ptype == 0) {

            ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);

            if (ret < 0)

                return ret;



            cx1 = (cx << 6) & 0xFC0;

            cx = r >> cxshift;

            ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);

            if (ret < 0)

                return ret;



            cx1 = (cx << 6) & 0xFC0;

            cx = g >> cxshift;

            ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);

            if (ret < 0)

                return ret;



            clr = (b << 16) + (g << 8) + r;

        }

        if (ptype > 5)

            return AVERROR_INVALIDDATA;

        ret = decode_value(s, s->run_model[ptype], 256, 400, &run);

        if (ret < 0)

            return ret;



        switch (ptype) {

        case 0:

            while (run-- > 0) {

                if (y >= avctx->height)

                    return AVERROR_INVALIDDATA;



                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        case 1:

            while (run-- > 0) {

                if (y >= avctx->height)

                    return AVERROR_INVALIDDATA;



                dst[y * linesize + x] = dst[ly * linesize + lx];

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            clr = dst[ly * linesize + lx];

            break;

        case 2:

            while (run-- > 0) {

                if (y < 1 || y >= avctx->height)

                    return AVERROR_INVALIDDATA;



                clr = dst[y * linesize + x + off + 1];

                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        case 4:

            while (run-- > 0) {

                uint8_t *odst = (uint8_t *)dst;



                if (y < 1 || y >= avctx->height ||

                    (y == 1 && x == 0))

                    return AVERROR_INVALIDDATA;



                if (x == 0) {

                    z = backstep;

                } else {

                    z = 0;

                }



                r = odst[(ly * linesize + lx) * 4] +

                    odst[((y * linesize + x) + off - z) * 4 + 4] -

                    odst[((y * linesize + x) + off - z) * 4];

                g = odst[(ly * linesize + lx) * 4 + 1] +

                    odst[((y * linesize + x) + off - z) * 4 + 5] -

                    odst[((y * linesize + x) + off - z) * 4 + 1];

                b = odst[(ly * linesize + lx) * 4 + 2] +

                    odst[((y * linesize + x) + off - z) * 4 + 6] -

                    odst[((y * linesize + x) + off - z) * 4 + 2];

                clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);

                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        case 5:

            while (run-- > 0) {

                if (y < 1 || y >= avctx->height ||

                    (y == 1 && x == 0))

                    return AVERROR_INVALIDDATA;



                if (x == 0) {

                    z = backstep;

                } else {

                    z = 0;

                }



                clr = dst[y * linesize + x + off - z];

                dst[y * linesize + x] = clr;

                lx = x;

                ly = y;

                x++;

                if (x >= avctx->width) {

                    x = 0;

                    y++;

                }

            }

            break;

        }



        if (avctx->bits_per_coded_sample == 16) {

            cx1 = (clr & 0x3F00) >> 2;

            cx = (clr & 0xFFFFFF) >> 16;

        } else {

            cx1 = (clr & 0xFC00) >> 4;

            cx = (clr & 0xFFFFFF) >> 18;

        }

    }



    return 0;

}

            cx = (clr & 0xFFFFFF) >> 16;
static int FUNC_0(AVCodecContext *VAR_0, uint32_t *VAR_1, int VAR_2)

{

    SCPRContext *s = VAR_0->priv_data;

    GetByteContext *gb = &s->gb;

    int VAR_3 = 0, VAR_4 = 0, VAR_5 = 0, VAR_6 = 0;

    int VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12 = 0, VAR_13 = 0, VAR_14, VAR_15;

    unsigned VAR_16 = VAR_2 - VAR_0->width;

    const int VAR_17 = s->VAR_17;

    unsigned VAR_18, VAR_19, VAR_20;



    reinit_tables(s);

    bytestream2_skip(gb, 2);

    init_rangecoder(&s->rc, gb);



    while (VAR_5 < VAR_0->width + 1) {

        VAR_15 = decode_unit(s, &s->pixel_model[0][VAR_3 + VAR_4], 400, &VAR_8);

        if (VAR_15 < 0)

            return VAR_15;



        VAR_4 = (VAR_3 << 6) & 0xFC0;

        VAR_3 = VAR_8 >> VAR_17;

        VAR_15 = decode_unit(s, &s->pixel_model[1][VAR_3 + VAR_4], 400, &VAR_9);

        if (VAR_15 < 0)

            return VAR_15;



        VAR_4 = (VAR_3 << 6) & 0xFC0;

        VAR_3 = VAR_9 >> VAR_17;

        VAR_15 = decode_unit(s, &s->pixel_model[2][VAR_3 + VAR_4], 400, &VAR_10);

        if (VAR_15 < 0)

            return VAR_15;



        VAR_4 = (VAR_3 << 6) & 0xFC0;

        VAR_3 = VAR_10 >> VAR_17;



        VAR_15 = decode_value(s, s->run_model[0], 256, 400, &VAR_7);

        if (VAR_15 < 0)

            return VAR_15;



        VAR_6 = (VAR_10 << 16) + (VAR_9 << 8) + VAR_8;

        VAR_5 += VAR_7;

        while (VAR_7-- > 0) {

            if (VAR_12 >= VAR_0->height)

                return AVERROR_INVALIDDATA;



            VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6;

            VAR_18 = VAR_13;

            VAR_19 = VAR_12;

            VAR_13++;

            if (VAR_13 >= VAR_0->width) {

                VAR_13 = 0;

                VAR_12++;

            }

        }

    }

    VAR_11 = -VAR_2 - 1;

    VAR_20 = 0;



    while (VAR_13 < VAR_0->width && VAR_12 < VAR_0->height) {

        VAR_15 = decode_value(s, s->op_model[VAR_20], 6, 1000, &VAR_20);

        if (VAR_15 < 0)

            return VAR_15;

        if (VAR_20 == 0) {

            VAR_15 = decode_unit(s, &s->pixel_model[0][VAR_3 + VAR_4], 400, &VAR_8);

            if (VAR_15 < 0)

                return VAR_15;



            VAR_4 = (VAR_3 << 6) & 0xFC0;

            VAR_3 = VAR_8 >> VAR_17;

            VAR_15 = decode_unit(s, &s->pixel_model[1][VAR_3 + VAR_4], 400, &VAR_9);

            if (VAR_15 < 0)

                return VAR_15;



            VAR_4 = (VAR_3 << 6) & 0xFC0;

            VAR_3 = VAR_9 >> VAR_17;

            VAR_15 = decode_unit(s, &s->pixel_model[2][VAR_3 + VAR_4], 400, &VAR_10);

            if (VAR_15 < 0)

                return VAR_15;



            VAR_6 = (VAR_10 << 16) + (VAR_9 << 8) + VAR_8;

        }

        if (VAR_20 > 5)

            return AVERROR_INVALIDDATA;

        VAR_15 = decode_value(s, s->run_model[VAR_20], 256, 400, &VAR_7);

        if (VAR_15 < 0)

            return VAR_15;



        switch (VAR_20) {

        case 0:

            while (VAR_7-- > 0) {

                if (VAR_12 >= VAR_0->height)

                    return AVERROR_INVALIDDATA;



                VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6;

                VAR_18 = VAR_13;

                VAR_19 = VAR_12;

                VAR_13++;

                if (VAR_13 >= VAR_0->width) {

                    VAR_13 = 0;

                    VAR_12++;

                }

            }

            break;

        case 1:

            while (VAR_7-- > 0) {

                if (VAR_12 >= VAR_0->height)

                    return AVERROR_INVALIDDATA;



                VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_1[VAR_19 * VAR_2 + VAR_18];

                VAR_18 = VAR_13;

                VAR_19 = VAR_12;

                VAR_13++;

                if (VAR_13 >= VAR_0->width) {

                    VAR_13 = 0;

                    VAR_12++;

                }

            }

            VAR_6 = VAR_1[VAR_19 * VAR_2 + VAR_18];

            break;

        case 2:

            while (VAR_7-- > 0) {

                if (VAR_12 < 1 || VAR_12 >= VAR_0->height)

                    return AVERROR_INVALIDDATA;



                VAR_6 = VAR_1[VAR_12 * VAR_2 + VAR_13 + VAR_11 + 1];

                VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6;

                VAR_18 = VAR_13;

                VAR_19 = VAR_12;

                VAR_13++;

                if (VAR_13 >= VAR_0->width) {

                    VAR_13 = 0;

                    VAR_12++;

                }

            }

            break;

        case 4:

            while (VAR_7-- > 0) {

                uint8_t *odst = (uint8_t *)VAR_1;



                if (VAR_12 < 1 || VAR_12 >= VAR_0->height ||

                    (VAR_12 == 1 && VAR_13 == 0))

                    return AVERROR_INVALIDDATA;



                if (VAR_13 == 0) {

                    VAR_14 = VAR_16;

                } else {

                    VAR_14 = 0;

                }



                VAR_8 = odst[(VAR_19 * VAR_2 + VAR_18) * 4] +

                    odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 4] -

                    odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4];

                VAR_9 = odst[(VAR_19 * VAR_2 + VAR_18) * 4 + 1] +

                    odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 5] -

                    odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 1];

                VAR_10 = odst[(VAR_19 * VAR_2 + VAR_18) * 4 + 2] +

                    odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 6] -

                    odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 2];

                VAR_6 = ((VAR_10 & 0xFF) << 16) + ((VAR_9 & 0xFF) << 8) + (VAR_8 & 0xFF);

                VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6;

                VAR_18 = VAR_13;

                VAR_19 = VAR_12;

                VAR_13++;

                if (VAR_13 >= VAR_0->width) {

                    VAR_13 = 0;

                    VAR_12++;

                }

            }

            break;

        case 5:

            while (VAR_7-- > 0) {

                if (VAR_12 < 1 || VAR_12 >= VAR_0->height ||

                    (VAR_12 == 1 && VAR_13 == 0))

                    return AVERROR_INVALIDDATA;



                if (VAR_13 == 0) {

                    VAR_14 = VAR_16;

                } else {

                    VAR_14 = 0;

                }



                VAR_6 = VAR_1[VAR_12 * VAR_2 + VAR_13 + VAR_11 - VAR_14];

                VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6;

                VAR_18 = VAR_13;

                VAR_19 = VAR_12;

                VAR_13++;

                if (VAR_13 >= VAR_0->width) {

                    VAR_13 = 0;

                    VAR_12++;

                }

            }

            break;

        }



        if (VAR_0->bits_per_coded_sample == 16) {

            VAR_4 = (VAR_6 & 0x3F00) >> 2;

            VAR_3 = (VAR_6 & 0xFFFFFF) >> 16;

        } else {

            VAR_4 = (VAR_6 & 0xFC00) >> 4;

            VAR_3 = (VAR_6 & 0xFFFFFF) >> 18;

        }

    }



    return 0;

}

static int FUNC_0(AVCodecContext *VAR_0, uint32_t *VAR_1, int VAR_2)
{ SCPRContext *s = VAR_0->priv_data; GetByteContext *gb = &s->gb; int VAR_3 = 0, VAR_4 = 0, VAR_5 = 0, VAR_6 = 0; int VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12 = 0, VAR_13 = 0, VAR_14, VAR_15; unsigned VAR_16 = VAR_2 - VAR_0->width; const int VAR_17 = s->VAR_17; unsigned VAR_18, VAR_19, VAR_20; reinit_tables(s); bytestream2_skip(gb, 2); init_rangecoder(&s->rc, gb); while (VAR_5 < VAR_0->width + 1) { VAR_15 = decode_unit(s, &s->pixel_model[0][VAR_3 + VAR_4], 400, &VAR_8); if (VAR_15 < 0)
return VAR_15; VAR_4 = (VAR_3 << 6) & 0xFC0; VAR_3 = VAR_8 >> VAR_17; VAR_15 = decode_unit(s, &s->pixel_model[1][VAR_3 + VAR_4], 400, &VAR_9); if (VAR_15 < 0)
return VAR_15; VAR_4 = (VAR_3 << 6) & 0xFC0; VAR_3 = VAR_9 >> VAR_17; VAR_15 = decode_unit(s, &s->pixel_model[2][VAR_3 + VAR_4], 400, &VAR_10); if (VAR_15 < 0)
return VAR_15; VAR_4 = (VAR_3 << 6) & 0xFC0; VAR_3 = VAR_10 >> VAR_17; VAR_15 = decode_value(s, s->run_model[0], 256, 400, &VAR_7); if (VAR_15 < 0)
return VAR_15; VAR_6 = (VAR_10 << 16) + (VAR_9 << 8) + VAR_8; VAR_5 += VAR_7; while (VAR_7-- > 0) { if (VAR_12 >= VAR_0->height)
return AVERROR_INVALIDDATA; VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6; VAR_18 = VAR_13; VAR_19 = VAR_12; VAR_13++; if (VAR_13 >= VAR_0->width) { VAR_13 = 0; VAR_12++; } } } VAR_11 = -VAR_2 - 1; VAR_20 = 0; while (VAR_13 < VAR_0->width && VAR_12 < VAR_0->height) { VAR_15 = decode_value(s, s->op_model[VAR_20], 6, 1000, &VAR_20); if (VAR_15 < 0)
return VAR_15; if (VAR_20 == 0) { VAR_15 = decode_unit(s, &s->pixel_model[0][VAR_3 + VAR_4], 400, &VAR_8); if (VAR_15 < 0)
return VAR_15; VAR_4 = (VAR_3 << 6) & 0xFC0; VAR_3 = VAR_8 >> VAR_17; VAR_15 = decode_unit(s, &s->pixel_model[1][VAR_3 + VAR_4], 400, &VAR_9); if (VAR_15 < 0)
return VAR_15; VAR_4 = (VAR_3 << 6) & 0xFC0; VAR_3 = VAR_9 >> VAR_17; VAR_15 = decode_unit(s, &s->pixel_model[2][VAR_3 + VAR_4], 400, &VAR_10); if (VAR_15 < 0)
return VAR_15; VAR_6 = (VAR_10 << 16) + (VAR_9 << 8) + VAR_8; } if (VAR_20 > 5)
return AVERROR_INVALIDDATA; VAR_15 = decode_value(s, s->run_model[VAR_20], 256, 400, &VAR_7); if (VAR_15 < 0)
return VAR_15; switch (VAR_20) { case 0:
while (VAR_7-- > 0) { if (VAR_12 >= VAR_0->height)
return AVERROR_INVALIDDATA; VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6; VAR_18 = VAR_13; VAR_19 = VAR_12; VAR_13++; if (VAR_13 >= VAR_0->width) { VAR_13 = 0; VAR_12++; } } break; case 1:
while (VAR_7-- > 0) { if (VAR_12 >= VAR_0->height)
return AVERROR_INVALIDDATA; VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_1[VAR_19 * VAR_2 + VAR_18]; VAR_18 = VAR_13; VAR_19 = VAR_12; VAR_13++; if (VAR_13 >= VAR_0->width) { VAR_13 = 0; VAR_12++; } } VAR_6 = VAR_1[VAR_19 * VAR_2 + VAR_18]; break; case 2:
while (VAR_7-- > 0) { if (VAR_12 < 1 || VAR_12 >= VAR_0->height)
return AVERROR_INVALIDDATA; VAR_6 = VAR_1[VAR_12 * VAR_2 + VAR_13 + VAR_11 + 1]; VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6; VAR_18 = VAR_13; VAR_19 = VAR_12; VAR_13++; if (VAR_13 >= VAR_0->width) { VAR_13 = 0; VAR_12++; } } break; case 4:
while (VAR_7-- > 0) { uint8_t *odst = (uint8_t *)VAR_1; if (VAR_12 < 1 || VAR_12 >= VAR_0->height ||
(VAR_12 == 1 && VAR_13 == 0))
return AVERROR_INVALIDDATA; if (VAR_13 == 0) { VAR_14 = VAR_16; } else { VAR_14 = 0; } VAR_8 = odst[(VAR_19 * VAR_2 + VAR_18) * 4] +
odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 4] -
odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4]; VAR_9 = odst[(VAR_19 * VAR_2 + VAR_18) * 4 + 1] +
odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 5] -
odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 1]; VAR_10 = odst[(VAR_19 * VAR_2 + VAR_18) * 4 + 2] +
odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 6] -
odst[((VAR_12 * VAR_2 + VAR_13) + VAR_11 - VAR_14) * 4 + 2]; VAR_6 = ((VAR_10 & 0xFF) << 16) + ((VAR_9 & 0xFF) << 8) + (VAR_8 & 0xFF); VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6; VAR_18 = VAR_13; VAR_19 = VAR_12; VAR_13++; if (VAR_13 >= VAR_0->width) { VAR_13 = 0; VAR_12++; } } break; case 5:
while (VAR_7-- > 0) { if (VAR_12 < 1 || VAR_12 >= VAR_0->height ||
(VAR_12 == 1 && VAR_13 == 0))
return AVERROR_INVALIDDATA; if (VAR_13 == 0) { VAR_14 = VAR_16; } else { VAR_14 = 0; } VAR_6 = VAR_1[VAR_12 * VAR_2 + VAR_13 + VAR_11 - VAR_14]; VAR_1[VAR_12 * VAR_2 + VAR_13] = VAR_6; VAR_18 = VAR_13; VAR_19 = VAR_12; VAR_13++; if (VAR_13 >= VAR_0->width) { VAR_13 = 0; VAR_12++; } } break; } if (VAR_0->bits_per_coded_sample == 16) { VAR_4 = (VAR_6 & 0x3F00) >> 2; VAR_3 = (VAR_6 & 0xFFFFFF) >> 16; } else { VAR_4 = (VAR_6 & 0xFC00) >> 4; VAR_3 = (VAR_6 & 0xFFFFFF) >> 18; } } return 0; }