static int flic_decode_frame_8BPP(AVCodecContext *avctx,
                                  void *data, int *got_frame,
                                  const uint8_t *buf, int buf_size)
{
    FlicDecodeContext *s = avctx->priv_data;
    GetByteContext g2;
    int pixel_ptr;
    int palette_ptr;
    unsigned char palette_idx1;
    unsigned char palette_idx2;
    unsigned int frame_size;
    int num_chunks;
    unsigned int chunk_size;
    int chunk_type;
    int i, j, ret;
    int color_packets;
    int color_changes;
    int color_shift;
    unsigned char r, g, b;
    int lines;
    int compressed_lines;
    int starting_line;
    signed short line_packets;
    int y_ptr;
    int byte_run;
    int pixel_skip;
    int pixel_countdown;
    unsigned char *pixels;
    unsigned int pixel_limit;
    bytestream2_init(&g2, buf, buf_size);
    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
        return ret;
    pixels = s->frame->data[0];
    pixel_limit = s->avctx->height * s->frame->linesize[0];
    if (buf_size < 16 || buf_size > INT_MAX - (3 * 256 + AV_INPUT_BUFFER_PADDING_SIZE))
    frame_size = bytestream2_get_le32(&g2);
    if (frame_size > buf_size)
        frame_size = buf_size;
    bytestream2_skip(&g2, 2); /* skip the magic number */
    num_chunks = bytestream2_get_le16(&g2);
    bytestream2_skip(&g2, 8);  /* skip padding */
    frame_size -= 16;
    /* iterate through the chunks */
    while ((frame_size >= 6) && (num_chunks > 0) &&
            bytestream2_get_bytes_left(&g2) >= 4) {
        int stream_ptr_after_chunk;
        chunk_size = bytestream2_get_le32(&g2);
        if (chunk_size > frame_size) {
            av_log(avctx, AV_LOG_WARNING,
                   "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);
            chunk_size = frame_size;
        }
        stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size;
        chunk_type = bytestream2_get_le16(&g2);
        switch (chunk_type) {
        case FLI_256_COLOR:
        case FLI_COLOR:
            /* check special case: If this file is from the Magic Carpet
             * game and uses 6-bit colors even though it reports 256-color
             * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during
             * initialization) */
            if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
                color_shift = 0;
            else
                color_shift = 2;
            /* set up the palette */
            color_packets = bytestream2_get_le16(&g2);
            palette_ptr = 0;
            for (i = 0; i < color_packets; i++) {
                /* first byte is how many colors to skip */
                palette_ptr += bytestream2_get_byte(&g2);
                /* next byte indicates how many entries to change */
                color_changes = bytestream2_get_byte(&g2);
                /* if there are 0 color changes, there are actually 256 */
                if (color_changes == 0)
                    color_changes = 256;
                if (bytestream2_tell(&g2) + color_changes * 3 > stream_ptr_after_chunk)
                    break;
                for (j = 0; j < color_changes; j++) {
                    unsigned int entry;
                    /* wrap around, for good measure */
                    if ((unsigned)palette_ptr >= 256)
                        palette_ptr = 0;
                    r = bytestream2_get_byte(&g2) << color_shift;
                    g = bytestream2_get_byte(&g2) << color_shift;
                    b = bytestream2_get_byte(&g2) << color_shift;
                    entry = 0xFFU << 24 | r << 16 | g << 8 | b;
                    if (color_shift == 2)
                        entry |= entry >> 6 & 0x30303;
                    if (s->palette[palette_ptr] != entry)
                        s->new_palette = 1;
                    s->palette[palette_ptr++] = entry;
                }
            }
            break;
        case FLI_DELTA:
            y_ptr = 0;
            compressed_lines = bytestream2_get_le16(&g2);
            while (compressed_lines > 0) {
                if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                    break;
                line_packets = bytestream2_get_le16(&g2);
                if ((line_packets & 0xC000) == 0xC000) {
                    // line skip opcode
                    line_packets = -line_packets;
                    y_ptr += line_packets * s->frame->linesize[0];
                } else if ((line_packets & 0xC000) == 0x4000) {
                    av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);
                } else if ((line_packets & 0xC000) == 0x8000) {
                    // "last byte" opcode
                    pixel_ptr= y_ptr + s->frame->linesize[0] - 1;
                    CHECK_PIXEL_PTR(0);
                    pixels[pixel_ptr] = line_packets & 0xff;
                } else {
                    compressed_lines--;
                    pixel_ptr = y_ptr;
                    CHECK_PIXEL_PTR(0);
                    pixel_countdown = s->avctx->width;
                    for (i = 0; i < line_packets; i++) {
                        if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                            break;
                        /* account for the skip bytes */
                        pixel_skip = bytestream2_get_byte(&g2);
                        pixel_ptr += pixel_skip;
                        pixel_countdown -= pixel_skip;
                        byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
                        if (byte_run < 0) {
                            byte_run = -byte_run;
                            palette_idx1 = bytestream2_get_byte(&g2);
                            palette_idx2 = bytestream2_get_byte(&g2);
                            CHECK_PIXEL_PTR(byte_run * 2);
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
                                pixels[pixel_ptr++] = palette_idx1;
                                pixels[pixel_ptr++] = palette_idx2;
                            }
                        } else {
                            CHECK_PIXEL_PTR(byte_run * 2);
                            if (bytestream2_tell(&g2) + byte_run * 2 > stream_ptr_after_chunk)
                                break;
                            for (j = 0; j < byte_run * 2; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
                            }
                        }
                    }
                    y_ptr += s->frame->linesize[0];
                }
            }
            break;
        case FLI_LC:
            /* line compressed */
            starting_line = bytestream2_get_le16(&g2);
            y_ptr = 0;
            y_ptr += starting_line * s->frame->linesize[0];
            compressed_lines = bytestream2_get_le16(&g2);
            while (compressed_lines > 0) {
                pixel_ptr = y_ptr;
                CHECK_PIXEL_PTR(0);
                pixel_countdown = s->avctx->width;
                if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
                    break;
                line_packets = bytestream2_get_byte(&g2);
                if (line_packets > 0) {
                    for (i = 0; i < line_packets; i++) {
                        /* account for the skip bytes */
                        if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
                            break;
                        pixel_skip = bytestream2_get_byte(&g2);
                        pixel_ptr += pixel_skip;
                        pixel_countdown -= pixel_skip;
                        byte_run = sign_extend(bytestream2_get_byte(&g2),8);
                        if (byte_run > 0) {
                            CHECK_PIXEL_PTR(byte_run);
                            if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
                                break;
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
                            }
                        } else if (byte_run < 0) {
                            byte_run = -byte_run;
                            palette_idx1 = bytestream2_get_byte(&g2);
                            CHECK_PIXEL_PTR(byte_run);
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = palette_idx1;
                            }
                        }
                    }
                }
                y_ptr += s->frame->linesize[0];
                compressed_lines--;
            }
            break;
        case FLI_BLACK:
            /* set the whole frame to color 0 (which is usually black) */
            memset(pixels, 0,
                s->frame->linesize[0] * s->avctx->height);
            break;
        case FLI_BRUN:
            /* Byte run compression: This chunk type only occurs in the first
             * FLI frame and it will update the entire frame. */
            y_ptr = 0;
            for (lines = 0; lines < s->avctx->height; lines++) {
                pixel_ptr = y_ptr;
                /* disregard the line packets; instead, iterate through all
                 * pixels on a row */
                 bytestream2_skip(&g2, 1);
                pixel_countdown = s->avctx->width;
                while (pixel_countdown > 0) {
                    if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
                        break;
                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
                    if (!byte_run) {
                        av_log(avctx, AV_LOG_ERROR, "Invalid byte run value.\n");
                    }
                    if (byte_run > 0) {
                        palette_idx1 = bytestream2_get_byte(&g2);
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
                        }
                    } else {  /* copy bytes if byte_run < 0 */
                        byte_run = -byte_run;
                        CHECK_PIXEL_PTR(byte_run);
                        if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
                            break;
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
                            pixel_countdown--;
                            if (pixel_countdown < 0)
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
                        }
                    }
                }
                y_ptr += s->frame->linesize[0];
            }
            break;
        case FLI_COPY:
            /* copy the chunk (uncompressed frame) */
            if (chunk_size - 6 != FFALIGN(s->avctx->width, 4) * s->avctx->height) {
                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
                       "has incorrect size, skipping chunk\n", chunk_size - 6);
                bytestream2_skip(&g2, chunk_size - 6);
            } else {
                for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height;
                     y_ptr += s->frame->linesize[0]) {
                    bytestream2_get_buffer(&g2, &pixels[y_ptr],
                                           s->avctx->width);
                    if (s->avctx->width & 3)
                        bytestream2_skip(&g2, 4 - (s->avctx->width & 3));
                }
            }
            break;
        case FLI_MINI:
            /* some sort of a thumbnail? disregard this chunk... */
            break;
        default:
            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
            break;
        }
        if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
            bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
        } else {
            av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
            break;
        }
        frame_size -= chunk_size;
        num_chunks--;
    }
    /* by the end of the chunk, the stream ptr should equal the frame
     * size (minus 1 or 2, possibly); if it doesn't, issue a warning */
    if (bytestream2_get_bytes_left(&g2) > 2)
        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
               "and final chunk ptr = %d\n", buf_size,
               buf_size - bytestream2_get_bytes_left(&g2));
    /* make the palette available on the way out */
    memcpy(s->frame->data[1], s->palette, AVPALETTE_SIZE);
    if (s->new_palette) {
        s->frame->palette_has_changed = 1;
        s->new_palette = 0;
    }
    if ((ret = av_frame_ref(data, s->frame)) < 0)
        return ret;
    *got_frame = 1;
    return buf_size;
}
static int flic_decode_frame_8BPP(AVCodecContext *avctx,
                                  void *data, int *got_frame,
                                  const uint8_t *buf, int buf_size)
{
    FlicDecodeContext *s = avctx->priv_data;
    GetByteContext g2;
    int pixel_ptr;
    int palette_ptr;
    unsigned char palette_idx1;
    unsigned char palette_idx2;
    unsigned int frame_size;
    int num_chunks;
    unsigned int chunk_size;
    int chunk_type;
    int i, j, ret;
    int color_packets;
    int color_changes;
    int color_shift;
    unsigned char r, g, b;
    int lines;
    int compressed_lines;
    int starting_line;
    signed short line_packets;
    int y_ptr;
    int byte_run;
    int pixel_skip;
    int pixel_countdown;
    unsigned char *pixels;
    unsigned int pixel_limit;
    bytestream2_init(&g2, buf, buf_size);
    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
        return ret;
    pixels = s->frame->data[0];
    pixel_limit = s->avctx->height * s->frame->linesize[0];
    if (buf_size < 16 || buf_size > INT_MAX - (3 * 256 + AV_INPUT_BUFFER_PADDING_SIZE))
    frame_size = bytestream2_get_le32(&g2);
    if (frame_size > buf_size)
        frame_size = buf_size;
    bytestream2_skip(&g2, 2); 
    num_chunks = bytestream2_get_le16(&g2);
    bytestream2_skip(&g2, 8);  
    frame_size -= 16;
    
    while ((frame_size >= 6) && (num_chunks > 0) &&
            bytestream2_get_bytes_left(&g2) >= 4) {
        int stream_ptr_after_chunk;
        chunk_size = bytestream2_get_le32(&g2);
        if (chunk_size > frame_size) {
            av_log(avctx, AV_LOG_WARNING,
                   "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);
            chunk_size = frame_size;
        }
        stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size;
        chunk_type = bytestream2_get_le16(&g2);
        switch (chunk_type) {
        case FLI_256_COLOR:
        case FLI_COLOR:
            



            if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
                color_shift = 0;
            else
                color_shift = 2;
            
            color_packets = bytestream2_get_le16(&g2);
            palette_ptr = 0;
            for (i = 0; i < color_packets; i++) {
                
                palette_ptr += bytestream2_get_byte(&g2);
                
                color_changes = bytestream2_get_byte(&g2);
                
                if (color_changes == 0)
                    color_changes = 256;
                if (bytestream2_tell(&g2) + color_changes * 3 > stream_ptr_after_chunk)
                    break;
                for (j = 0; j < color_changes; j++) {
                    unsigned int entry;
                    
                    if ((unsigned)palette_ptr >= 256)
                        palette_ptr = 0;
                    r = bytestream2_get_byte(&g2) << color_shift;
                    g = bytestream2_get_byte(&g2) << color_shift;
                    b = bytestream2_get_byte(&g2) << color_shift;
                    entry = 0xFFU << 24 | r << 16 | g << 8 | b;
                    if (color_shift == 2)
                        entry |= entry >> 6 & 0x30303;
                    if (s->palette[palette_ptr] != entry)
                        s->new_palette = 1;
                    s->palette[palette_ptr++] = entry;
                }
            }
            break;
        case FLI_DELTA:
            y_ptr = 0;
            compressed_lines = bytestream2_get_le16(&g2);
            while (compressed_lines > 0) {
                if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                    break;
                line_packets = bytestream2_get_le16(&g2);
                if ((line_packets & 0xC000) == 0xC000) {
                    
                    line_packets = -line_packets;
                    y_ptr += line_packets * s->frame->linesize[0];
                } else if ((line_packets & 0xC000) == 0x4000) {
                    av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);
                } else if ((line_packets & 0xC000) == 0x8000) {
                    
                    pixel_ptr= y_ptr + s->frame->linesize[0] - 1;
                    CHECK_PIXEL_PTR(0);
                    pixels[pixel_ptr] = line_packets & 0xff;
                } else {
                    compressed_lines--;
                    pixel_ptr = y_ptr;
                    CHECK_PIXEL_PTR(0);
                    pixel_countdown = s->avctx->width;
                    for (i = 0; i < line_packets; i++) {
                        if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                            break;
                        
                        pixel_skip = bytestream2_get_byte(&g2);
                        pixel_ptr += pixel_skip;
                        pixel_countdown -= pixel_skip;
                        byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
                        if (byte_run < 0) {
                            byte_run = -byte_run;
                            palette_idx1 = bytestream2_get_byte(&g2);
                            palette_idx2 = bytestream2_get_byte(&g2);
                            CHECK_PIXEL_PTR(byte_run * 2);
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
                                pixels[pixel_ptr++] = palette_idx1;
                                pixels[pixel_ptr++] = palette_idx2;
                            }
                        } else {
                            CHECK_PIXEL_PTR(byte_run * 2);
                            if (bytestream2_tell(&g2) + byte_run * 2 > stream_ptr_after_chunk)
                                break;
                            for (j = 0; j < byte_run * 2; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
                            }
                        }
                    }
                    y_ptr += s->frame->linesize[0];
                }
            }
            break;
        case FLI_LC:
            
            starting_line = bytestream2_get_le16(&g2);
            y_ptr = 0;
            y_ptr += starting_line * s->frame->linesize[0];
            compressed_lines = bytestream2_get_le16(&g2);
            while (compressed_lines > 0) {
                pixel_ptr = y_ptr;
                CHECK_PIXEL_PTR(0);
                pixel_countdown = s->avctx->width;
                if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
                    break;
                line_packets = bytestream2_get_byte(&g2);
                if (line_packets > 0) {
                    for (i = 0; i < line_packets; i++) {
                        
                        if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
                            break;
                        pixel_skip = bytestream2_get_byte(&g2);
                        pixel_ptr += pixel_skip;
                        pixel_countdown -= pixel_skip;
                        byte_run = sign_extend(bytestream2_get_byte(&g2),8);
                        if (byte_run > 0) {
                            CHECK_PIXEL_PTR(byte_run);
                            if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
                                break;
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
                            }
                        } else if (byte_run < 0) {
                            byte_run = -byte_run;
                            palette_idx1 = bytestream2_get_byte(&g2);
                            CHECK_PIXEL_PTR(byte_run);
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = palette_idx1;
                            }
                        }
                    }
                }
                y_ptr += s->frame->linesize[0];
                compressed_lines--;
            }
            break;
        case FLI_BLACK:
            
            memset(pixels, 0,
                s->frame->linesize[0] * s->avctx->height);
            break;
        case FLI_BRUN:
            

            y_ptr = 0;
            for (lines = 0; lines < s->avctx->height; lines++) {
                pixel_ptr = y_ptr;
                

                 bytestream2_skip(&g2, 1);
                pixel_countdown = s->avctx->width;
                while (pixel_countdown > 0) {
                    if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
                        break;
                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
                    if (!byte_run) {
                        av_log(avctx, AV_LOG_ERROR, "Invalid byte run value.\n");
                    }
                    if (byte_run > 0) {
                        palette_idx1 = bytestream2_get_byte(&g2);
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
                        }
                    } else {  
                        byte_run = -byte_run;
                        CHECK_PIXEL_PTR(byte_run);
                        if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
                            break;
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
                            pixel_countdown--;
                            if (pixel_countdown < 0)
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
                        }
                    }
                }
                y_ptr += s->frame->linesize[0];
            }
            break;
        case FLI_COPY:
            
            if (chunk_size - 6 != FFALIGN(s->avctx->width, 4) * s->avctx->height) {
                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
                       "has incorrect size, skipping chunk\n", chunk_size - 6);
                bytestream2_skip(&g2, chunk_size - 6);
            } else {
                for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height;
                     y_ptr += s->frame->linesize[0]) {
                    bytestream2_get_buffer(&g2, &pixels[y_ptr],
                                           s->avctx->width);
                    if (s->avctx->width & 3)
                        bytestream2_skip(&g2, 4 - (s->avctx->width & 3));
                }
            }
            break;
        case FLI_MINI:
            
            break;
        default:
            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
            break;
        }
        if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
            bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
        } else {
            av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
            break;
        }
        frame_size -= chunk_size;
        num_chunks--;
    }
    

    if (bytestream2_get_bytes_left(&g2) > 2)
        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
               "and final chunk ptr = %d\n", buf_size,
               buf_size - bytestream2_get_bytes_left(&g2));
    
    memcpy(s->frame->data[1], s->palette, AVPALETTE_SIZE);
    if (s->new_palette) {
        s->frame->palette_has_changed = 1;
        s->new_palette = 0;
    }
    if ((ret = av_frame_ref(data, s->frame)) < 0)
        return ret;
    *got_frame = 1;
    return buf_size;
}
static int FUNC_0(AVCodecContext *VAR_0,
                                  void *VAR_1, int *VAR_2,
                                  const uint8_t *VAR_3, int VAR_4)
{
    FlicDecodeContext *s = VAR_0->priv_data;
    GetByteContext g2;
    int VAR_5;
    int VAR_6;
    unsigned char VAR_7;
    unsigned char VAR_8;
    unsigned int VAR_9;
    int VAR_10;
    unsigned int VAR_11;
    int VAR_12;
    int VAR_13, VAR_14, VAR_15;
    int VAR_16;
    int VAR_17;
    int VAR_18;
    unsigned char VAR_19, VAR_20, VAR_21;
    int VAR_22;
    int VAR_23;
    int VAR_24;
    signed short VAR_25;
    int VAR_26;
    int VAR_27;
    int VAR_28;
    int VAR_29;
    unsigned char *VAR_30;
    unsigned int VAR_31;
    bytestream2_init(&g2, VAR_3, VAR_4);
    if ((VAR_15 = ff_reget_buffer(VAR_0, s->frame)) < 0)
        return VAR_15;
    VAR_30 = s->frame->VAR_1[0];
    VAR_31 = s->VAR_0->height * s->frame->linesize[0];
    if (VAR_4 < 16 || VAR_4 > INT_MAX - (3 * 256 + AV_INPUT_BUFFER_PADDING_SIZE))
    VAR_9 = bytestream2_get_le32(&g2);
    if (VAR_9 > VAR_4)
        VAR_9 = VAR_4;
    bytestream2_skip(&g2, 2); 
    VAR_10 = bytestream2_get_le16(&g2);
    bytestream2_skip(&g2, 8);  
    VAR_9 -= 16;
    
    while ((VAR_9 >= 6) && (VAR_10 > 0) &&
            bytestream2_get_bytes_left(&g2) >= 4) {
        int VAR_32;
        VAR_11 = bytestream2_get_le32(&g2);
        if (VAR_11 > VAR_9) {
            av_log(VAR_0, AV_LOG_WARNING,
                   "Invalid VAR_11 = %u > VAR_9 = %u\n", VAR_11, VAR_9);
            VAR_11 = VAR_9;
        }
        VAR_32 = bytestream2_tell(&g2) - 4 + VAR_11;
        VAR_12 = bytestream2_get_le16(&g2);
        switch (VAR_12) {
        case FLI_256_COLOR:
        case FLI_COLOR:
            



            if ((VAR_12 == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
                VAR_18 = 0;
            else
                VAR_18 = 2;
            
            VAR_16 = bytestream2_get_le16(&g2);
            VAR_6 = 0;
            for (VAR_13 = 0; VAR_13 < VAR_16; VAR_13++) {
                
                VAR_6 += bytestream2_get_byte(&g2);
                
                VAR_17 = bytestream2_get_byte(&g2);
                
                if (VAR_17 == 0)
                    VAR_17 = 256;
                if (bytestream2_tell(&g2) + VAR_17 * 3 > VAR_32)
                    break;
                for (VAR_14 = 0; VAR_14 < VAR_17; VAR_14++) {
                    unsigned int VAR_33;
                    
                    if ((unsigned)VAR_6 >= 256)
                        VAR_6 = 0;
                    VAR_19 = bytestream2_get_byte(&g2) << VAR_18;
                    VAR_20 = bytestream2_get_byte(&g2) << VAR_18;
                    VAR_21 = bytestream2_get_byte(&g2) << VAR_18;
                    VAR_33 = 0xFFU << 24 | VAR_19 << 16 | VAR_20 << 8 | VAR_21;
                    if (VAR_18 == 2)
                        VAR_33 |= VAR_33 >> 6 & 0x30303;
                    if (s->palette[VAR_6] != VAR_33)
                        s->new_palette = 1;
                    s->palette[VAR_6++] = VAR_33;
                }
            }
            break;
        case FLI_DELTA:
            VAR_26 = 0;
            VAR_23 = bytestream2_get_le16(&g2);
            while (VAR_23 > 0) {
                if (bytestream2_tell(&g2) + 2 > VAR_32)
                    break;
                VAR_25 = bytestream2_get_le16(&g2);
                if ((VAR_25 & 0xC000) == 0xC000) {
                    
                    VAR_25 = -VAR_25;
                    VAR_26 += VAR_25 * s->frame->linesize[0];
                } else if ((VAR_25 & 0xC000) == 0x4000) {
                    av_log(VAR_0, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", VAR_25);
                } else if ((VAR_25 & 0xC000) == 0x8000) {
                    
                    VAR_5= VAR_26 + s->frame->linesize[0] - 1;
                    CHECK_PIXEL_PTR(0);
                    VAR_30[VAR_5] = VAR_25 & 0xff;
                } else {
                    VAR_23--;
                    VAR_5 = VAR_26;
                    CHECK_PIXEL_PTR(0);
                    VAR_29 = s->VAR_0->width;
                    for (VAR_13 = 0; VAR_13 < VAR_25; VAR_13++) {
                        if (bytestream2_tell(&g2) + 2 > VAR_32)
                            break;
                        
                        VAR_28 = bytestream2_get_byte(&g2);
                        VAR_5 += VAR_28;
                        VAR_29 -= VAR_28;
                        VAR_27 = sign_extend(bytestream2_get_byte(&g2), 8);
                        if (VAR_27 < 0) {
                            VAR_27 = -VAR_27;
                            VAR_7 = bytestream2_get_byte(&g2);
                            VAR_8 = bytestream2_get_byte(&g2);
                            CHECK_PIXEL_PTR(VAR_27 * 2);
                            for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++, VAR_29 -= 2) {
                                VAR_30[VAR_5++] = VAR_7;
                                VAR_30[VAR_5++] = VAR_8;
                            }
                        } else {
                            CHECK_PIXEL_PTR(VAR_27 * 2);
                            if (bytestream2_tell(&g2) + VAR_27 * 2 > VAR_32)
                                break;
                            for (VAR_14 = 0; VAR_14 < VAR_27 * 2; VAR_14++, VAR_29--) {
                                VAR_30[VAR_5++] = bytestream2_get_byte(&g2);
                            }
                        }
                    }
                    VAR_26 += s->frame->linesize[0];
                }
            }
            break;
        case FLI_LC:
            
            VAR_24 = bytestream2_get_le16(&g2);
            VAR_26 = 0;
            VAR_26 += VAR_24 * s->frame->linesize[0];
            VAR_23 = bytestream2_get_le16(&g2);
            while (VAR_23 > 0) {
                VAR_5 = VAR_26;
                CHECK_PIXEL_PTR(0);
                VAR_29 = s->VAR_0->width;
                if (bytestream2_tell(&g2) + 1 > VAR_32)
                    break;
                VAR_25 = bytestream2_get_byte(&g2);
                if (VAR_25 > 0) {
                    for (VAR_13 = 0; VAR_13 < VAR_25; VAR_13++) {
                        
                        if (bytestream2_tell(&g2) + 1 > VAR_32)
                            break;
                        VAR_28 = bytestream2_get_byte(&g2);
                        VAR_5 += VAR_28;
                        VAR_29 -= VAR_28;
                        VAR_27 = sign_extend(bytestream2_get_byte(&g2),8);
                        if (VAR_27 > 0) {
                            CHECK_PIXEL_PTR(VAR_27);
                            if (bytestream2_tell(&g2) + VAR_27 > VAR_32)
                                break;
                            for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++, VAR_29--) {
                                VAR_30[VAR_5++] = bytestream2_get_byte(&g2);
                            }
                        } else if (VAR_27 < 0) {
                            VAR_27 = -VAR_27;
                            VAR_7 = bytestream2_get_byte(&g2);
                            CHECK_PIXEL_PTR(VAR_27);
                            for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++, VAR_29--) {
                                VAR_30[VAR_5++] = VAR_7;
                            }
                        }
                    }
                }
                VAR_26 += s->frame->linesize[0];
                VAR_23--;
            }
            break;
        case FLI_BLACK:
            
            memset(VAR_30, 0,
                s->frame->linesize[0] * s->VAR_0->height);
            break;
        case FLI_BRUN:
            

            VAR_26 = 0;
            for (VAR_22 = 0; VAR_22 < s->VAR_0->height; VAR_22++) {
                VAR_5 = VAR_26;
                

                 bytestream2_skip(&g2, 1);
                VAR_29 = s->VAR_0->width;
                while (VAR_29 > 0) {
                    if (bytestream2_tell(&g2) + 1 > VAR_32)
                        break;
                    VAR_27 = sign_extend(bytestream2_get_byte(&g2), 8);
                    if (!VAR_27) {
                        av_log(VAR_0, AV_LOG_ERROR, "Invalid byte run value.\n");
                    }
                    if (VAR_27 > 0) {
                        VAR_7 = bytestream2_get_byte(&g2);
                        CHECK_PIXEL_PTR(VAR_27);
                        for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++) {
                            VAR_30[VAR_5++] = VAR_7;
                            VAR_29--;
                            if (VAR_29 < 0)
                                av_log(VAR_0, AV_LOG_ERROR, "VAR_29 < 0 (%d) at line %d\n",
                                       VAR_29, VAR_22);
                        }
                    } else {  
                        VAR_27 = -VAR_27;
                        CHECK_PIXEL_PTR(VAR_27);
                        if (bytestream2_tell(&g2) + VAR_27 > VAR_32)
                            break;
                        for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++) {
                            VAR_30[VAR_5++] = bytestream2_get_byte(&g2);
                            VAR_29--;
                            if (VAR_29 < 0)
                                av_log(VAR_0, AV_LOG_ERROR, "VAR_29 < 0 (%d) at line %d\n",
                                       VAR_29, VAR_22);
                        }
                    }
                }
                VAR_26 += s->frame->linesize[0];
            }
            break;
        case FLI_COPY:
            
            if (VAR_11 - 6 != FFALIGN(s->VAR_0->width, 4) * s->VAR_0->height) {
                av_log(VAR_0, AV_LOG_ERROR, "In chunk FLI_COPY : source VAR_1 (%d bytes) " \
                       "has incorrect size, skipping chunk\n", VAR_11 - 6);
                bytestream2_skip(&g2, VAR_11 - 6);
            } else {
                for (VAR_26 = 0; VAR_26 < s->frame->linesize[0] * s->VAR_0->height;
                     VAR_26 += s->frame->linesize[0]) {
                    bytestream2_get_buffer(&g2, &VAR_30[VAR_26],
                                           s->VAR_0->width);
                    if (s->VAR_0->width & 3)
                        bytestream2_skip(&g2, 4 - (s->VAR_0->width & 3));
                }
            }
            break;
        case FLI_MINI:
            
            break;
        default:
            av_log(VAR_0, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", VAR_12);
            break;
        }
        if (VAR_32 - bytestream2_tell(&g2) >= 0) {
            bytestream2_skip(&g2, VAR_32 - bytestream2_tell(&g2));
        } else {
            av_log(VAR_0, AV_LOG_ERROR, "Chunk overread\n");
            break;
        }
        VAR_9 -= VAR_11;
        VAR_10--;
    }
    

    if (bytestream2_get_bytes_left(&g2) > 2)
        av_log(VAR_0, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
               "and final chunk ptr = %d\n", VAR_4,
               VAR_4 - bytestream2_get_bytes_left(&g2));
    
    memcpy(s->frame->VAR_1[1], s->palette, AVPALETTE_SIZE);
    if (s->new_palette) {
        s->frame->palette_has_changed = 1;
        s->new_palette = 0;
    }
    if ((VAR_15 = av_frame_ref(VAR_1, s->frame)) < 0)
        return VAR_15;
    *VAR_2 = 1;
    return VAR_4;
}
static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
const uint8_t *VAR_3, int VAR_4)
{ FlicDecodeContext *s = VAR_0->priv_data; GetByteContext g2; int VAR_5; int VAR_6; unsigned char VAR_7; unsigned char VAR_8; unsigned int VAR_9; int VAR_10; unsigned int VAR_11; int VAR_12; int VAR_13, VAR_14, VAR_15; int VAR_16; int VAR_17; int VAR_18; unsigned char VAR_19, VAR_20, VAR_21; int VAR_22; int VAR_23; int VAR_24; signed short VAR_25; int VAR_26; int VAR_27; int VAR_28; int VAR_29; unsigned char *VAR_30; unsigned int VAR_31; bytestream2_init(&g2, VAR_3, VAR_4); if ((VAR_15 = ff_reget_buffer(VAR_0, s->frame)) < 0)
return VAR_15; VAR_30 = s->frame->VAR_1[0]; VAR_31 = s->VAR_0->height * s->frame->linesize[0]; if (VAR_4 < 16 || VAR_4 > INT_MAX - (3 * 256 + AV_INPUT_BUFFER_PADDING_SIZE))
VAR_9 = bytestream2_get_le32(&g2); if (VAR_9 > VAR_4)
VAR_9 = VAR_4; bytestream2_skip(&g2, 2); VAR_10 = bytestream2_get_le16(&g2); bytestream2_skip(&g2, 8); VAR_9 -= 16; while ((VAR_9 >= 6) && (VAR_10 > 0) &&
bytestream2_get_bytes_left(&g2) >= 4) { int VAR_32; VAR_11 = bytestream2_get_le32(&g2); if (VAR_11 > VAR_9) { av_log(VAR_0, AV_LOG_WARNING,
"Invalid VAR_11 = %u > VAR_9 = %u\n", VAR_11, VAR_9); VAR_11 = VAR_9; } VAR_32 = bytestream2_tell(&g2) - 4 + VAR_11; VAR_12 = bytestream2_get_le16(&g2); switch (VAR_12) { case FLI_256_COLOR:
case FLI_COLOR:
if ((VAR_12 == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
VAR_18 = 0; else
VAR_18 = 2; VAR_16 = bytestream2_get_le16(&g2); VAR_6 = 0; for (VAR_13 = 0; VAR_13 < VAR_16; VAR_13++) { VAR_6 += bytestream2_get_byte(&g2); VAR_17 = bytestream2_get_byte(&g2); if (VAR_17 == 0)
VAR_17 = 256; if (bytestream2_tell(&g2) + VAR_17 * 3 > VAR_32)
break; for (VAR_14 = 0; VAR_14 < VAR_17; VAR_14++) { unsigned int VAR_33; if ((unsigned)VAR_6 >= 256)
VAR_6 = 0; VAR_19 = bytestream2_get_byte(&g2) << VAR_18; VAR_20 = bytestream2_get_byte(&g2) << VAR_18; VAR_21 = bytestream2_get_byte(&g2) << VAR_18; VAR_33 = 0xFFU << 24 | VAR_19 << 16 | VAR_20 << 8 | VAR_21; if (VAR_18 == 2)
VAR_33 |= VAR_33 >> 6 & 0x30303; if (s->palette[VAR_6] != VAR_33)
s->new_palette = 1; s->palette[VAR_6++] = VAR_33; } } break; case FLI_DELTA:
VAR_26 = 0; VAR_23 = bytestream2_get_le16(&g2); while (VAR_23 > 0) { if (bytestream2_tell(&g2) + 2 > VAR_32)
break; VAR_25 = bytestream2_get_le16(&g2); if ((VAR_25 & 0xC000) == 0xC000) { VAR_25 = -VAR_25; VAR_26 += VAR_25 * s->frame->linesize[0]; } else if ((VAR_25 & 0xC000) == 0x4000) { av_log(VAR_0, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", VAR_25); } else if ((VAR_25 & 0xC000) == 0x8000) { VAR_5= VAR_26 + s->frame->linesize[0] - 1; CHECK_PIXEL_PTR(0); VAR_30[VAR_5] = VAR_25 & 0xff; } else { VAR_23--; VAR_5 = VAR_26; CHECK_PIXEL_PTR(0); VAR_29 = s->VAR_0->width; for (VAR_13 = 0; VAR_13 < VAR_25; VAR_13++) { if (bytestream2_tell(&g2) + 2 > VAR_32)
break; VAR_28 = bytestream2_get_byte(&g2); VAR_5 += VAR_28; VAR_29 -= VAR_28; VAR_27 = sign_extend(bytestream2_get_byte(&g2), 8); if (VAR_27 < 0) { VAR_27 = -VAR_27; VAR_7 = bytestream2_get_byte(&g2); VAR_8 = bytestream2_get_byte(&g2); CHECK_PIXEL_PTR(VAR_27 * 2); for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++, VAR_29 -= 2) { VAR_30[VAR_5++] = VAR_7; VAR_30[VAR_5++] = VAR_8; } } else { CHECK_PIXEL_PTR(VAR_27 * 2); if (bytestream2_tell(&g2) + VAR_27 * 2 > VAR_32)
break; for (VAR_14 = 0; VAR_14 < VAR_27 * 2; VAR_14++, VAR_29--) { VAR_30[VAR_5++] = bytestream2_get_byte(&g2); } } } VAR_26 += s->frame->linesize[0]; } } break; case FLI_LC:
VAR_24 = bytestream2_get_le16(&g2); VAR_26 = 0; VAR_26 += VAR_24 * s->frame->linesize[0]; VAR_23 = bytestream2_get_le16(&g2); while (VAR_23 > 0) { VAR_5 = VAR_26; CHECK_PIXEL_PTR(0); VAR_29 = s->VAR_0->width; if (bytestream2_tell(&g2) + 1 > VAR_32)
break; VAR_25 = bytestream2_get_byte(&g2); if (VAR_25 > 0) { for (VAR_13 = 0; VAR_13 < VAR_25; VAR_13++) { if (bytestream2_tell(&g2) + 1 > VAR_32)
break; VAR_28 = bytestream2_get_byte(&g2); VAR_5 += VAR_28; VAR_29 -= VAR_28; VAR_27 = sign_extend(bytestream2_get_byte(&g2),8); if (VAR_27 > 0) { CHECK_PIXEL_PTR(VAR_27); if (bytestream2_tell(&g2) + VAR_27 > VAR_32)
break; for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++, VAR_29--) { VAR_30[VAR_5++] = bytestream2_get_byte(&g2); } } else if (VAR_27 < 0) { VAR_27 = -VAR_27; VAR_7 = bytestream2_get_byte(&g2); CHECK_PIXEL_PTR(VAR_27); for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++, VAR_29--) { VAR_30[VAR_5++] = VAR_7; } } } } VAR_26 += s->frame->linesize[0]; VAR_23--; } break; case FLI_BLACK:
memset(VAR_30, 0,
s->frame->linesize[0] * s->VAR_0->height); break; case FLI_BRUN:
VAR_26 = 0; for (VAR_22 = 0; VAR_22 < s->VAR_0->height; VAR_22++) { VAR_5 = VAR_26; bytestream2_skip(&g2, 1); VAR_29 = s->VAR_0->width; while (VAR_29 > 0) { if (bytestream2_tell(&g2) + 1 > VAR_32)
break; VAR_27 = sign_extend(bytestream2_get_byte(&g2), 8); if (!VAR_27) { av_log(VAR_0, AV_LOG_ERROR, "Invalid byte run value.\n"); } if (VAR_27 > 0) { VAR_7 = bytestream2_get_byte(&g2); CHECK_PIXEL_PTR(VAR_27); for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++) { VAR_30[VAR_5++] = VAR_7; VAR_29--; if (VAR_29 < 0)
av_log(VAR_0, AV_LOG_ERROR, "VAR_29 < 0 (%d) at line %d\n",
VAR_29, VAR_22); } } else { VAR_27 = -VAR_27; CHECK_PIXEL_PTR(VAR_27); if (bytestream2_tell(&g2) + VAR_27 > VAR_32)
break; for (VAR_14 = 0; VAR_14 < VAR_27; VAR_14++) { VAR_30[VAR_5++] = bytestream2_get_byte(&g2); VAR_29--; if (VAR_29 < 0)
av_log(VAR_0, AV_LOG_ERROR, "VAR_29 < 0 (%d) at line %d\n",
VAR_29, VAR_22); } } } VAR_26 += s->frame->linesize[0]; } break; case FLI_COPY:
if (VAR_11 - 6 != FFALIGN(s->VAR_0->width, 4) * s->VAR_0->height) { av_log(VAR_0, AV_LOG_ERROR, "In chunk FLI_COPY : source VAR_1 (%d bytes) " \
"has incorrect size, skipping chunk\n", VAR_11 - 6); bytestream2_skip(&g2, VAR_11 - 6); } else { for (VAR_26 = 0; VAR_26 < s->frame->linesize[0] * s->VAR_0->height; VAR_26 += s->frame->linesize[0]) { bytestream2_get_buffer(&g2, &VAR_30[VAR_26],
s->VAR_0->width); if (s->VAR_0->width & 3)
bytestream2_skip(&g2, 4 - (s->VAR_0->width & 3)); } } break; case FLI_MINI:
break; default:
av_log(VAR_0, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", VAR_12); break; } if (VAR_32 - bytestream2_tell(&g2) >= 0) { bytestream2_skip(&g2, VAR_32 - bytestream2_tell(&g2)); } else { av_log(VAR_0, AV_LOG_ERROR, "Chunk overread\n"); break; } VAR_9 -= VAR_11; VAR_10--; } if (bytestream2_get_bytes_left(&g2) > 2)
av_log(VAR_0, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
"and final chunk ptr = %d\n", VAR_4,
VAR_4 - bytestream2_get_bytes_left(&g2)); memcpy(s->frame->VAR_1[1], s->palette, AVPALETTE_SIZE); if (s->new_palette) { s->frame->palette_has_changed = 1; s->new_palette = 0; } if ((VAR_15 = av_frame_ref(VAR_1, s->frame)) < 0)
return VAR_15; *VAR_2 = 1; return VAR_4; }