static int vmd_decode(VmdVideoContext *s, AVFrame *frame)

{

    int i;

    unsigned int *palette32;

    unsigned char r, g, b;



    GetByteContext gb;



    unsigned char meth;

    unsigned char *dp;   /* pointer to current frame */

    unsigned char *pp;   /* pointer to previous frame */

    unsigned char len;

    int ofs;



    int frame_x, frame_y;

    int frame_width, frame_height;



    frame_x = AV_RL16(&s->buf[6]);

    frame_y = AV_RL16(&s->buf[8]);

    frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;

    frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;



    if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&

        (frame_x || frame_y)) {



        s->x_off = frame_x;

        s->y_off = frame_y;

    }

    frame_x -= s->x_off;

    frame_y -= s->y_off;



    if (frame_x < 0 || frame_width < 0 ||

        frame_x >= s->avctx->width ||

        frame_width > s->avctx->width ||

        frame_x + frame_width > s->avctx->width) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Invalid horizontal range %d-%d\n",

               frame_x, frame_width);

        return AVERROR_INVALIDDATA;

    }

    if (frame_y < 0 || frame_height < 0 ||

        frame_y >= s->avctx->height ||

        frame_height > s->avctx->height ||

        frame_y + frame_height > s->avctx->height) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Invalid vertical range %d-%d\n",

               frame_x, frame_width);

        return AVERROR_INVALIDDATA;

    }



    /* if only a certain region will be updated, copy the entire previous

     * frame before the decode */

    if (s->prev_frame->data[0] &&

        (frame_x || frame_y || (frame_width != s->avctx->width) ||

        (frame_height != s->avctx->height))) {



        memcpy(frame->data[0], s->prev_frame->data[0],

            s->avctx->height * frame->linesize[0]);

    }



    /* check if there is a new palette */

    bytestream2_init(&gb, s->buf + 16, s->size - 16);

    if (s->buf[15] & 0x02) {

        bytestream2_skip(&gb, 2);

        palette32 = (unsigned int *)s->palette;

        if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) {

            for (i = 0; i < PALETTE_COUNT; i++) {

                r = bytestream2_get_byteu(&gb) * 4;

                g = bytestream2_get_byteu(&gb) * 4;

                b = bytestream2_get_byteu(&gb) * 4;

                palette32[i] = 0xFFU << 24 | (r << 16) | (g << 8) | (b);

                palette32[i] |= palette32[i] >> 6 & 0x30303;

            }

        } else {

            av_log(s->avctx, AV_LOG_ERROR, "Incomplete palette\n");

            return AVERROR_INVALIDDATA;

        }

    }



    if (!s->size)

        return 0;



    /* originally UnpackFrame in VAG's code */

    if (bytestream2_get_bytes_left(&gb) < 1)

        return AVERROR_INVALIDDATA;

    meth = bytestream2_get_byteu(&gb);

    if (meth & 0x80) {

        if (!s->unpack_buffer_size) {

            av_log(s->avctx, AV_LOG_ERROR,

                   "Trying to unpack LZ-compressed frame with no LZ buffer\n");

            return AVERROR_INVALIDDATA;

        }

        lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),

                  s->unpack_buffer, s->unpack_buffer_size);

        meth &= 0x7F;

        bytestream2_init(&gb, s->unpack_buffer, s->unpack_buffer_size);

    }



    dp = &frame->data[0][frame_y * frame->linesize[0] + frame_x];

    pp = &s->prev_frame->data[0][frame_y * s->prev_frame->linesize[0] + frame_x];

    switch (meth) {

    case 1:

        for (i = 0; i < frame_height; i++) {

            ofs = 0;

            do {

                len = bytestream2_get_byte(&gb);

                if (len & 0x80) {

                    len = (len & 0x7F) + 1;

                    if (ofs + len > frame_width ||

                        bytestream2_get_bytes_left(&gb) < len)

                        return AVERROR_INVALIDDATA;

                    bytestream2_get_bufferu(&gb, &dp[ofs], len);

                    ofs += len;

                } else {

                    /* interframe pixel copy */

                    if (ofs + len + 1 > frame_width || !s->prev_frame->data[0])

                        return AVERROR_INVALIDDATA;

                    memcpy(&dp[ofs], &pp[ofs], len + 1);

                    ofs += len + 1;

                }

            } while (ofs < frame_width);

            if (ofs > frame_width) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "offset > width (%d > %d)\n",

                       ofs, frame_width);

                return AVERROR_INVALIDDATA;

            }

            dp += frame->linesize[0];

            pp += s->prev_frame->linesize[0];

        }

        break;



    case 2:

        for (i = 0; i < frame_height; i++) {

            bytestream2_get_buffer(&gb, dp, frame_width);

            dp += frame->linesize[0];

            pp += s->prev_frame->linesize[0];

        }

        break;



    case 3:

        for (i = 0; i < frame_height; i++) {

            ofs = 0;

            do {

                len = bytestream2_get_byte(&gb);

                if (len & 0x80) {

                    len = (len & 0x7F) + 1;

                    if (bytestream2_peek_byte(&gb) == 0xFF) {

                        int slen = len;

                        bytestream2_get_byte(&gb);

                        len = rle_unpack(gb.buffer, &dp[ofs],

                                         len, bytestream2_get_bytes_left(&gb),

                                         frame_width - ofs);

                        ofs += slen;

                        bytestream2_skip(&gb, len);

                    } else {

                        bytestream2_get_buffer(&gb, &dp[ofs], len);

                        ofs += len;

                    }

                } else {

                    /* interframe pixel copy */

                    if (ofs + len + 1 > frame_width || !s->prev_frame->data[0])

                        return AVERROR_INVALIDDATA;

                    memcpy(&dp[ofs], &pp[ofs], len + 1);

                    ofs += len + 1;

                }

            } while (ofs < frame_width);

            if (ofs > frame_width) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "offset > width (%d > %d)\n",

                       ofs, frame_width);

                return AVERROR_INVALIDDATA;

            }

            dp += frame->linesize[0];

            pp += s->prev_frame->linesize[0];

        }

        break;

    }

    return 0;

}

static int vmd_decode(VmdVideoContext *s, AVFrame *frame)

{

    int i;

    unsigned int *palette32;

    unsigned char r, g, b;



    GetByteContext gb;



    unsigned char meth;

    unsigned char *dp;   

    unsigned char *pp;   

    unsigned char len;

    int ofs;



    int frame_x, frame_y;

    int frame_width, frame_height;



    frame_x = AV_RL16(&s->buf[6]);

    frame_y = AV_RL16(&s->buf[8]);

    frame_width = AV_RL16(&s->buf[10]) - frame_x + 1;

    frame_height = AV_RL16(&s->buf[12]) - frame_y + 1;



    if ((frame_width == s->avctx->width && frame_height == s->avctx->height) &&

        (frame_x || frame_y)) {



        s->x_off = frame_x;

        s->y_off = frame_y;

    }

    frame_x -= s->x_off;

    frame_y -= s->y_off;



    if (frame_x < 0 || frame_width < 0 ||

        frame_x >= s->avctx->width ||

        frame_width > s->avctx->width ||

        frame_x + frame_width > s->avctx->width) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Invalid horizontal range %d-%d\n",

               frame_x, frame_width);

        return AVERROR_INVALIDDATA;

    }

    if (frame_y < 0 || frame_height < 0 ||

        frame_y >= s->avctx->height ||

        frame_height > s->avctx->height ||

        frame_y + frame_height > s->avctx->height) {

        av_log(s->avctx, AV_LOG_ERROR,

               "Invalid vertical range %d-%d\n",

               frame_x, frame_width);

        return AVERROR_INVALIDDATA;

    }



    



    if (s->prev_frame->data[0] &&

        (frame_x || frame_y || (frame_width != s->avctx->width) ||

        (frame_height != s->avctx->height))) {



        memcpy(frame->data[0], s->prev_frame->data[0],

            s->avctx->height * frame->linesize[0]);

    }



    

    bytestream2_init(&gb, s->buf + 16, s->size - 16);

    if (s->buf[15] & 0x02) {

        bytestream2_skip(&gb, 2);

        palette32 = (unsigned int *)s->palette;

        if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) {

            for (i = 0; i < PALETTE_COUNT; i++) {

                r = bytestream2_get_byteu(&gb) * 4;

                g = bytestream2_get_byteu(&gb) * 4;

                b = bytestream2_get_byteu(&gb) * 4;

                palette32[i] = 0xFFU << 24 | (r << 16) | (g << 8) | (b);

                palette32[i] |= palette32[i] >> 6 & 0x30303;

            }

        } else {

            av_log(s->avctx, AV_LOG_ERROR, "Incomplete palette\n");

            return AVERROR_INVALIDDATA;

        }

    }



    if (!s->size)

        return 0;



    

    if (bytestream2_get_bytes_left(&gb) < 1)

        return AVERROR_INVALIDDATA;

    meth = bytestream2_get_byteu(&gb);

    if (meth & 0x80) {

        if (!s->unpack_buffer_size) {

            av_log(s->avctx, AV_LOG_ERROR,

                   "Trying to unpack LZ-compressed frame with no LZ buffer\n");

            return AVERROR_INVALIDDATA;

        }

        lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),

                  s->unpack_buffer, s->unpack_buffer_size);

        meth &= 0x7F;

        bytestream2_init(&gb, s->unpack_buffer, s->unpack_buffer_size);

    }



    dp = &frame->data[0][frame_y * frame->linesize[0] + frame_x];

    pp = &s->prev_frame->data[0][frame_y * s->prev_frame->linesize[0] + frame_x];

    switch (meth) {

    case 1:

        for (i = 0; i < frame_height; i++) {

            ofs = 0;

            do {

                len = bytestream2_get_byte(&gb);

                if (len & 0x80) {

                    len = (len & 0x7F) + 1;

                    if (ofs + len > frame_width ||

                        bytestream2_get_bytes_left(&gb) < len)

                        return AVERROR_INVALIDDATA;

                    bytestream2_get_bufferu(&gb, &dp[ofs], len);

                    ofs += len;

                } else {

                    

                    if (ofs + len + 1 > frame_width || !s->prev_frame->data[0])

                        return AVERROR_INVALIDDATA;

                    memcpy(&dp[ofs], &pp[ofs], len + 1);

                    ofs += len + 1;

                }

            } while (ofs < frame_width);

            if (ofs > frame_width) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "offset > width (%d > %d)\n",

                       ofs, frame_width);

                return AVERROR_INVALIDDATA;

            }

            dp += frame->linesize[0];

            pp += s->prev_frame->linesize[0];

        }

        break;



    case 2:

        for (i = 0; i < frame_height; i++) {

            bytestream2_get_buffer(&gb, dp, frame_width);

            dp += frame->linesize[0];

            pp += s->prev_frame->linesize[0];

        }

        break;



    case 3:

        for (i = 0; i < frame_height; i++) {

            ofs = 0;

            do {

                len = bytestream2_get_byte(&gb);

                if (len & 0x80) {

                    len = (len & 0x7F) + 1;

                    if (bytestream2_peek_byte(&gb) == 0xFF) {

                        int slen = len;

                        bytestream2_get_byte(&gb);

                        len = rle_unpack(gb.buffer, &dp[ofs],

                                         len, bytestream2_get_bytes_left(&gb),

                                         frame_width - ofs);

                        ofs += slen;

                        bytestream2_skip(&gb, len);

                    } else {

                        bytestream2_get_buffer(&gb, &dp[ofs], len);

                        ofs += len;

                    }

                } else {

                    

                    if (ofs + len + 1 > frame_width || !s->prev_frame->data[0])

                        return AVERROR_INVALIDDATA;

                    memcpy(&dp[ofs], &pp[ofs], len + 1);

                    ofs += len + 1;

                }

            } while (ofs < frame_width);

            if (ofs > frame_width) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "offset > width (%d > %d)\n",

                       ofs, frame_width);

                return AVERROR_INVALIDDATA;

            }

            dp += frame->linesize[0];

            pp += s->prev_frame->linesize[0];

        }

        break;

    }

    return 0;

}

        lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),                   s->unpack_buffer, s->unpack_buffer_size);         bytestream2_init(&gb, s->unpack_buffer, s->unpack_buffer_size);
static int FUNC_0(VmdVideoContext *VAR_0, AVFrame *VAR_1)

{

    int VAR_2;

    unsigned int *VAR_3;

    unsigned char VAR_4, VAR_5, VAR_6;



    GetByteContext gb;



    unsigned char VAR_7;

    unsigned char *VAR_8;   

    unsigned char *VAR_9;   

    unsigned char VAR_10;

    int VAR_11;



    int VAR_12, VAR_13;

    int VAR_14, VAR_15;



    VAR_12 = AV_RL16(&VAR_0->buf[6]);

    VAR_13 = AV_RL16(&VAR_0->buf[8]);

    VAR_14 = AV_RL16(&VAR_0->buf[10]) - VAR_12 + 1;

    VAR_15 = AV_RL16(&VAR_0->buf[12]) - VAR_13 + 1;



    if ((VAR_14 == VAR_0->avctx->width && VAR_15 == VAR_0->avctx->height) &&

        (VAR_12 || VAR_13)) {



        VAR_0->x_off = VAR_12;

        VAR_0->y_off = VAR_13;

    }

    VAR_12 -= VAR_0->x_off;

    VAR_13 -= VAR_0->y_off;



    if (VAR_12 < 0 || VAR_14 < 0 ||

        VAR_12 >= VAR_0->avctx->width ||

        VAR_14 > VAR_0->avctx->width ||

        VAR_12 + VAR_14 > VAR_0->avctx->width) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Invalid horizontal range %d-%d\n",

               VAR_12, VAR_14);

        return AVERROR_INVALIDDATA;

    }

    if (VAR_13 < 0 || VAR_15 < 0 ||

        VAR_13 >= VAR_0->avctx->height ||

        VAR_15 > VAR_0->avctx->height ||

        VAR_13 + VAR_15 > VAR_0->avctx->height) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Invalid vertical range %d-%d\n",

               VAR_12, VAR_14);

        return AVERROR_INVALIDDATA;

    }



    



    if (VAR_0->prev_frame->data[0] &&

        (VAR_12 || VAR_13 || (VAR_14 != VAR_0->avctx->width) ||

        (VAR_15 != VAR_0->avctx->height))) {



        memcpy(VAR_1->data[0], VAR_0->prev_frame->data[0],

            VAR_0->avctx->height * VAR_1->linesize[0]);

    }



    

    bytestream2_init(&gb, VAR_0->buf + 16, VAR_0->size - 16);

    if (VAR_0->buf[15] & 0x02) {

        bytestream2_skip(&gb, 2);

        VAR_3 = (unsigned int *)VAR_0->palette;

        if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) {

            for (VAR_2 = 0; VAR_2 < PALETTE_COUNT; VAR_2++) {

                VAR_4 = bytestream2_get_byteu(&gb) * 4;

                VAR_5 = bytestream2_get_byteu(&gb) * 4;

                VAR_6 = bytestream2_get_byteu(&gb) * 4;

                VAR_3[VAR_2] = 0xFFU << 24 | (VAR_4 << 16) | (VAR_5 << 8) | (VAR_6);

                VAR_3[VAR_2] |= VAR_3[VAR_2] >> 6 & 0x30303;

            }

        } else {

            av_log(VAR_0->avctx, AV_LOG_ERROR, "Incomplete palette\n");

            return AVERROR_INVALIDDATA;

        }

    }



    if (!VAR_0->size)

        return 0;



    

    if (bytestream2_get_bytes_left(&gb) < 1)

        return AVERROR_INVALIDDATA;

    VAR_7 = bytestream2_get_byteu(&gb);

    if (VAR_7 & 0x80) {

        if (!VAR_0->unpack_buffer_size) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "Trying to unpack LZ-compressed VAR_1 with no LZ buffer\n");

            return AVERROR_INVALIDDATA;

        }

        lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),

                  VAR_0->unpack_buffer, VAR_0->unpack_buffer_size);

        VAR_7 &= 0x7F;

        bytestream2_init(&gb, VAR_0->unpack_buffer, VAR_0->unpack_buffer_size);

    }



    VAR_8 = &VAR_1->data[0][VAR_13 * VAR_1->linesize[0] + VAR_12];

    VAR_9 = &VAR_0->prev_frame->data[0][VAR_13 * VAR_0->prev_frame->linesize[0] + VAR_12];

    switch (VAR_7) {

    case 1:

        for (VAR_2 = 0; VAR_2 < VAR_15; VAR_2++) {

            VAR_11 = 0;

            do {

                VAR_10 = bytestream2_get_byte(&gb);

                if (VAR_10 & 0x80) {

                    VAR_10 = (VAR_10 & 0x7F) + 1;

                    if (VAR_11 + VAR_10 > VAR_14 ||

                        bytestream2_get_bytes_left(&gb) < VAR_10)

                        return AVERROR_INVALIDDATA;

                    bytestream2_get_bufferu(&gb, &VAR_8[VAR_11], VAR_10);

                    VAR_11 += VAR_10;

                } else {

                    

                    if (VAR_11 + VAR_10 + 1 > VAR_14 || !VAR_0->prev_frame->data[0])

                        return AVERROR_INVALIDDATA;

                    memcpy(&VAR_8[VAR_11], &VAR_9[VAR_11], VAR_10 + 1);

                    VAR_11 += VAR_10 + 1;

                }

            } while (VAR_11 < VAR_14);

            if (VAR_11 > VAR_14) {

                av_log(VAR_0->avctx, AV_LOG_ERROR,

                       "offset > width (%d > %d)\n",

                       VAR_11, VAR_14);

                return AVERROR_INVALIDDATA;

            }

            VAR_8 += VAR_1->linesize[0];

            VAR_9 += VAR_0->prev_frame->linesize[0];

        }

        break;



    case 2:

        for (VAR_2 = 0; VAR_2 < VAR_15; VAR_2++) {

            bytestream2_get_buffer(&gb, VAR_8, VAR_14);

            VAR_8 += VAR_1->linesize[0];

            VAR_9 += VAR_0->prev_frame->linesize[0];

        }

        break;



    case 3:

        for (VAR_2 = 0; VAR_2 < VAR_15; VAR_2++) {

            VAR_11 = 0;

            do {

                VAR_10 = bytestream2_get_byte(&gb);

                if (VAR_10 & 0x80) {

                    VAR_10 = (VAR_10 & 0x7F) + 1;

                    if (bytestream2_peek_byte(&gb) == 0xFF) {

                        int VAR_16 = VAR_10;

                        bytestream2_get_byte(&gb);

                        VAR_10 = rle_unpack(gb.buffer, &VAR_8[VAR_11],

                                         VAR_10, bytestream2_get_bytes_left(&gb),

                                         VAR_14 - VAR_11);

                        VAR_11 += VAR_16;

                        bytestream2_skip(&gb, VAR_10);

                    } else {

                        bytestream2_get_buffer(&gb, &VAR_8[VAR_11], VAR_10);

                        VAR_11 += VAR_10;

                    }

                } else {

                    

                    if (VAR_11 + VAR_10 + 1 > VAR_14 || !VAR_0->prev_frame->data[0])

                        return AVERROR_INVALIDDATA;

                    memcpy(&VAR_8[VAR_11], &VAR_9[VAR_11], VAR_10 + 1);

                    VAR_11 += VAR_10 + 1;

                }

            } while (VAR_11 < VAR_14);

            if (VAR_11 > VAR_14) {

                av_log(VAR_0->avctx, AV_LOG_ERROR,

                       "offset > width (%d > %d)\n",

                       VAR_11, VAR_14);

                return AVERROR_INVALIDDATA;

            }

            VAR_8 += VAR_1->linesize[0];

            VAR_9 += VAR_0->prev_frame->linesize[0];

        }

        break;

    }

    return 0;

}

static int FUNC_0(VmdVideoContext *VAR_0, AVFrame *VAR_1)
{ int VAR_2; unsigned int *VAR_3; unsigned char VAR_4, VAR_5, VAR_6; GetByteContext gb; unsigned char VAR_7; unsigned char *VAR_8; unsigned char *VAR_9; unsigned char VAR_10; int VAR_11; int VAR_12, VAR_13; int VAR_14, VAR_15; VAR_12 = AV_RL16(&VAR_0->buf[6]); VAR_13 = AV_RL16(&VAR_0->buf[8]); VAR_14 = AV_RL16(&VAR_0->buf[10]) - VAR_12 + 1; VAR_15 = AV_RL16(&VAR_0->buf[12]) - VAR_13 + 1; if ((VAR_14 == VAR_0->avctx->width && VAR_15 == VAR_0->avctx->height) &&
(VAR_12 || VAR_13)) { VAR_0->x_off = VAR_12; VAR_0->y_off = VAR_13; } VAR_12 -= VAR_0->x_off; VAR_13 -= VAR_0->y_off; if (VAR_12 < 0 || VAR_14 < 0 ||
VAR_12 >= VAR_0->avctx->width ||
VAR_14 > VAR_0->avctx->width ||
VAR_12 + VAR_14 > VAR_0->avctx->width) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Invalid horizontal range %d-%d\n",
VAR_12, VAR_14); return AVERROR_INVALIDDATA; } if (VAR_13 < 0 || VAR_15 < 0 ||
VAR_13 >= VAR_0->avctx->height ||
VAR_15 > VAR_0->avctx->height ||
VAR_13 + VAR_15 > VAR_0->avctx->height) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Invalid vertical range %d-%d\n",
VAR_12, VAR_14); return AVERROR_INVALIDDATA; } if (VAR_0->prev_frame->data[0] &&
(VAR_12 || VAR_13 || (VAR_14 != VAR_0->avctx->width) ||
(VAR_15 != VAR_0->avctx->height))) { memcpy(VAR_1->data[0], VAR_0->prev_frame->data[0],
VAR_0->avctx->height * VAR_1->linesize[0]); } bytestream2_init(&gb, VAR_0->buf + 16, VAR_0->size - 16); if (VAR_0->buf[15] & 0x02) { bytestream2_skip(&gb, 2); VAR_3 = (unsigned int *)VAR_0->palette; if (bytestream2_get_bytes_left(&gb) >= PALETTE_COUNT * 3) { for (VAR_2 = 0; VAR_2 < PALETTE_COUNT; VAR_2++) { VAR_4 = bytestream2_get_byteu(&gb) * 4; VAR_5 = bytestream2_get_byteu(&gb) * 4; VAR_6 = bytestream2_get_byteu(&gb) * 4; VAR_3[VAR_2] = 0xFFU << 24 | (VAR_4 << 16) | (VAR_5 << 8) | (VAR_6); VAR_3[VAR_2] |= VAR_3[VAR_2] >> 6 & 0x30303; } } else { av_log(VAR_0->avctx, AV_LOG_ERROR, "Incomplete palette\n"); return AVERROR_INVALIDDATA; } } if (!VAR_0->size)
return 0; if (bytestream2_get_bytes_left(&gb) < 1)
return AVERROR_INVALIDDATA; VAR_7 = bytestream2_get_byteu(&gb); if (VAR_7 & 0x80) { if (!VAR_0->unpack_buffer_size) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Trying to unpack LZ-compressed VAR_1 with no LZ buffer\n"); return AVERROR_INVALIDDATA; } lz_unpack(gb.buffer, bytestream2_get_bytes_left(&gb),
VAR_0->unpack_buffer, VAR_0->unpack_buffer_size); VAR_7 &= 0x7F; bytestream2_init(&gb, VAR_0->unpack_buffer, VAR_0->unpack_buffer_size); } VAR_8 = &VAR_1->data[0][VAR_13 * VAR_1->linesize[0] + VAR_12]; VAR_9 = &VAR_0->prev_frame->data[0][VAR_13 * VAR_0->prev_frame->linesize[0] + VAR_12]; switch (VAR_7) { case 1:
for (VAR_2 = 0; VAR_2 < VAR_15; VAR_2++) { VAR_11 = 0; do { VAR_10 = bytestream2_get_byte(&gb); if (VAR_10 & 0x80) { VAR_10 = (VAR_10 & 0x7F) + 1; if (VAR_11 + VAR_10 > VAR_14 ||
bytestream2_get_bytes_left(&gb) < VAR_10)
return AVERROR_INVALIDDATA; bytestream2_get_bufferu(&gb, &VAR_8[VAR_11], VAR_10); VAR_11 += VAR_10; } else { if (VAR_11 + VAR_10 + 1 > VAR_14 || !VAR_0->prev_frame->data[0])
return AVERROR_INVALIDDATA; memcpy(&VAR_8[VAR_11], &VAR_9[VAR_11], VAR_10 + 1); VAR_11 += VAR_10 + 1; } } while (VAR_11 < VAR_14); if (VAR_11 > VAR_14) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"offset > width (%d > %d)\n",
VAR_11, VAR_14); return AVERROR_INVALIDDATA; } VAR_8 += VAR_1->linesize[0]; VAR_9 += VAR_0->prev_frame->linesize[0]; } break; case 2:
for (VAR_2 = 0; VAR_2 < VAR_15; VAR_2++) { bytestream2_get_buffer(&gb, VAR_8, VAR_14); VAR_8 += VAR_1->linesize[0]; VAR_9 += VAR_0->prev_frame->linesize[0]; } break; case 3:
for (VAR_2 = 0; VAR_2 < VAR_15; VAR_2++) { VAR_11 = 0; do { VAR_10 = bytestream2_get_byte(&gb); if (VAR_10 & 0x80) { VAR_10 = (VAR_10 & 0x7F) + 1; if (bytestream2_peek_byte(&gb) == 0xFF) { int VAR_16 = VAR_10; bytestream2_get_byte(&gb); VAR_10 = rle_unpack(gb.buffer, &VAR_8[VAR_11],
VAR_10, bytestream2_get_bytes_left(&gb),
VAR_14 - VAR_11); VAR_11 += VAR_16; bytestream2_skip(&gb, VAR_10); } else { bytestream2_get_buffer(&gb, &VAR_8[VAR_11], VAR_10); VAR_11 += VAR_10; } } else { if (VAR_11 + VAR_10 + 1 > VAR_14 || !VAR_0->prev_frame->data[0])
return AVERROR_INVALIDDATA; memcpy(&VAR_8[VAR_11], &VAR_9[VAR_11], VAR_10 + 1); VAR_11 += VAR_10 + 1; } } while (VAR_11 < VAR_14); if (VAR_11 > VAR_14) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"offset > width (%d > %d)\n",
VAR_11, VAR_14); return AVERROR_INVALIDDATA; } VAR_8 += VAR_1->linesize[0]; VAR_9 += VAR_0->prev_frame->linesize[0]; } break; } return 0; }