static int pcx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

                            AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    PCXContext * const s = avctx->priv_data;

    AVFrame *picture = data;

    AVFrame * const p = &s->picture;

    int compressed, xmin, ymin, xmax, ymax;

    unsigned int w, h, bits_per_pixel, bytes_per_line, nplanes, stride, y, x,

                 bytes_per_scanline;

    uint8_t *ptr;

    uint8_t const *bufstart = buf;

    uint8_t *scanline;

    int ret = -1;



    if (buf[0] != 0x0a || buf[1] > 5) {

        av_log(avctx, AV_LOG_ERROR, "this is not PCX encoded data\n");

        return AVERROR_INVALIDDATA;

    }



    compressed = buf[2];

    xmin = AV_RL16(buf+ 4);

    ymin = AV_RL16(buf+ 6);

    xmax = AV_RL16(buf+ 8);

    ymax = AV_RL16(buf+10);



    if (xmax < xmin || ymax < ymin) {

        av_log(avctx, AV_LOG_ERROR, "invalid image dimensions\n");

        return AVERROR_INVALIDDATA;

    }



    w = xmax - xmin + 1;

    h = ymax - ymin + 1;



    bits_per_pixel     = buf[3];

    bytes_per_line     = AV_RL16(buf+66);

    nplanes            = buf[65];

    bytes_per_scanline = nplanes * bytes_per_line;



    if (bytes_per_scanline < w * bits_per_pixel * nplanes / 8) {

        av_log(avctx, AV_LOG_ERROR, "PCX data is corrupted\n");

        return AVERROR_INVALIDDATA;

    }



    switch ((nplanes<<8) + bits_per_pixel) {

        case 0x0308:

            avctx->pix_fmt = AV_PIX_FMT_RGB24;

            break;

        case 0x0108:

        case 0x0104:

        case 0x0102:

        case 0x0101:

        case 0x0401:

        case 0x0301:

        case 0x0201:

            avctx->pix_fmt = AV_PIX_FMT_PAL8;

            break;

        default:

            av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");

            return AVERROR_INVALIDDATA;

    }



    buf += 128;



    if (p->data[0])

        avctx->release_buffer(avctx, p);



    if (av_image_check_size(w, h, 0, avctx))

        return AVERROR_INVALIDDATA;

    if (w != avctx->width || h != avctx->height)

        avcodec_set_dimensions(avctx, w, h);

    if ((ret = avctx->get_buffer(avctx, p)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

        return ret;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    ptr    = p->data[0];

    stride = p->linesize[0];



    scanline = av_malloc(bytes_per_scanline);

    if (!scanline)

        return AVERROR(ENOMEM);



    if (nplanes == 3 && bits_per_pixel == 8) {

        for (y=0; y<h; y++) {

            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);



            for (x=0; x<w; x++) {

                ptr[3*x  ] = scanline[x                    ];

                ptr[3*x+1] = scanline[x+ bytes_per_line    ];

                ptr[3*x+2] = scanline[x+(bytes_per_line<<1)];

            }



            ptr += stride;

        }



    } else if (nplanes == 1 && bits_per_pixel == 8) {

        const uint8_t *palstart = bufstart + buf_size - 769;



        for (y=0; y<h; y++, ptr+=stride) {

            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);

            memcpy(ptr, scanline, w);

        }



        if (buf != palstart) {

            av_log(avctx, AV_LOG_WARNING, "image data possibly corrupted\n");

            buf = palstart;

        }

        if (*buf++ != 12) {

            av_log(avctx, AV_LOG_ERROR, "expected palette after image data\n");

            ret = AVERROR_INVALIDDATA;

            goto end;

        }



    } else if (nplanes == 1) {   /* all packed formats, max. 16 colors */

        GetBitContext s;



        for (y=0; y<h; y++) {

            init_get_bits(&s, scanline, bytes_per_scanline<<3);



            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);



            for (x=0; x<w; x++)

                ptr[x] = get_bits(&s, bits_per_pixel);

            ptr += stride;

        }



    } else {    /* planar, 4, 8 or 16 colors */

        int i;



        for (y=0; y<h; y++) {

            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);



            for (x=0; x<w; x++) {

                int m = 0x80 >> (x&7), v = 0;

                for (i=nplanes - 1; i>=0; i--) {

                    v <<= 1;

                    v  += !!(scanline[i*bytes_per_line + (x>>3)] & m);

                }

                ptr[x] = v;

            }

            ptr += stride;

        }

    }



    if (nplanes == 1 && bits_per_pixel == 8) {

        pcx_palette(&buf, (uint32_t *) p->data[1], 256);

    } else if (bits_per_pixel * nplanes == 1) {

        AV_WN32A(p->data[1]  , 0xFF000000);

        AV_WN32A(p->data[1]+4, 0xFFFFFFFF);

    } else if (bits_per_pixel < 8) {

        const uint8_t *palette = bufstart+16;

        pcx_palette(&palette, (uint32_t *) p->data[1], 16);

    }



    *picture = s->picture;

    *data_size = sizeof(AVFrame);



    ret = buf - bufstart;

end:

    av_free(scanline);

    return ret;

}

static int pcx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

                            AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    PCXContext * const s = avctx->priv_data;

    AVFrame *picture = data;

    AVFrame * const p = &s->picture;

    int compressed, xmin, ymin, xmax, ymax;

    unsigned int w, h, bits_per_pixel, bytes_per_line, nplanes, stride, y, x,

                 bytes_per_scanline;

    uint8_t *ptr;

    uint8_t const *bufstart = buf;

    uint8_t *scanline;

    int ret = -1;



    if (buf[0] != 0x0a || buf[1] > 5) {

        av_log(avctx, AV_LOG_ERROR, "this is not PCX encoded data\n");

        return AVERROR_INVALIDDATA;

    }



    compressed = buf[2];

    xmin = AV_RL16(buf+ 4);

    ymin = AV_RL16(buf+ 6);

    xmax = AV_RL16(buf+ 8);

    ymax = AV_RL16(buf+10);



    if (xmax < xmin || ymax < ymin) {

        av_log(avctx, AV_LOG_ERROR, "invalid image dimensions\n");

        return AVERROR_INVALIDDATA;

    }



    w = xmax - xmin + 1;

    h = ymax - ymin + 1;



    bits_per_pixel     = buf[3];

    bytes_per_line     = AV_RL16(buf+66);

    nplanes            = buf[65];

    bytes_per_scanline = nplanes * bytes_per_line;



    if (bytes_per_scanline < w * bits_per_pixel * nplanes / 8) {

        av_log(avctx, AV_LOG_ERROR, "PCX data is corrupted\n");

        return AVERROR_INVALIDDATA;

    }



    switch ((nplanes<<8) + bits_per_pixel) {

        case 0x0308:

            avctx->pix_fmt = AV_PIX_FMT_RGB24;

            break;

        case 0x0108:

        case 0x0104:

        case 0x0102:

        case 0x0101:

        case 0x0401:

        case 0x0301:

        case 0x0201:

            avctx->pix_fmt = AV_PIX_FMT_PAL8;

            break;

        default:

            av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");

            return AVERROR_INVALIDDATA;

    }



    buf += 128;



    if (p->data[0])

        avctx->release_buffer(avctx, p);



    if (av_image_check_size(w, h, 0, avctx))

        return AVERROR_INVALIDDATA;

    if (w != avctx->width || h != avctx->height)

        avcodec_set_dimensions(avctx, w, h);

    if ((ret = avctx->get_buffer(avctx, p)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

        return ret;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    ptr    = p->data[0];

    stride = p->linesize[0];



    scanline = av_malloc(bytes_per_scanline);

    if (!scanline)

        return AVERROR(ENOMEM);



    if (nplanes == 3 && bits_per_pixel == 8) {

        for (y=0; y<h; y++) {

            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);



            for (x=0; x<w; x++) {

                ptr[3*x  ] = scanline[x                    ];

                ptr[3*x+1] = scanline[x+ bytes_per_line    ];

                ptr[3*x+2] = scanline[x+(bytes_per_line<<1)];

            }



            ptr += stride;

        }



    } else if (nplanes == 1 && bits_per_pixel == 8) {

        const uint8_t *palstart = bufstart + buf_size - 769;



        for (y=0; y<h; y++, ptr+=stride) {

            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);

            memcpy(ptr, scanline, w);

        }



        if (buf != palstart) {

            av_log(avctx, AV_LOG_WARNING, "image data possibly corrupted\n");

            buf = palstart;

        }

        if (*buf++ != 12) {

            av_log(avctx, AV_LOG_ERROR, "expected palette after image data\n");

            ret = AVERROR_INVALIDDATA;

            goto end;

        }



    } else if (nplanes == 1) {   

        GetBitContext s;



        for (y=0; y<h; y++) {

            init_get_bits(&s, scanline, bytes_per_scanline<<3);



            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);



            for (x=0; x<w; x++)

                ptr[x] = get_bits(&s, bits_per_pixel);

            ptr += stride;

        }



    } else {    

        int i;



        for (y=0; y<h; y++) {

            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);



            for (x=0; x<w; x++) {

                int m = 0x80 >> (x&7), v = 0;

                for (i=nplanes - 1; i>=0; i--) {

                    v <<= 1;

                    v  += !!(scanline[i*bytes_per_line + (x>>3)] & m);

                }

                ptr[x] = v;

            }

            ptr += stride;

        }

    }



    if (nplanes == 1 && bits_per_pixel == 8) {

        pcx_palette(&buf, (uint32_t *) p->data[1], 256);

    } else if (bits_per_pixel * nplanes == 1) {

        AV_WN32A(p->data[1]  , 0xFF000000);

        AV_WN32A(p->data[1]+4, 0xFFFFFFFF);

    } else if (bits_per_pixel < 8) {

        const uint8_t *palette = bufstart+16;

        pcx_palette(&palette, (uint32_t *) p->data[1], 16);

    }



    *picture = s->picture;

    *data_size = sizeof(AVFrame);



    ret = buf - bufstart;

end:

    av_free(scanline);

    return ret;

}

                            AVPacket *avpkt) {     const uint8_t *buf = avpkt->data;     int buf_size = avpkt->size;     int compressed, xmin, ymin, xmax, ymax;     uint8_t *ptr;     uint8_t const *bufstart = buf;     uint8_t *scanline;     int ret = -1;     if (buf[0] != 0x0a || buf[1] > 5) {     compressed = buf[2];     xmin = AV_RL16(buf+ 4);     ymin = AV_RL16(buf+ 6);     xmax = AV_RL16(buf+ 8);     ymax = AV_RL16(buf+10);     bits_per_pixel     = buf[3];     bytes_per_line     = AV_RL16(buf+66);     nplanes            = buf[65];     buf += 128;             buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);         const uint8_t *palstart = bufstart + buf_size - 769;             buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);         if (buf != palstart) {             buf = palstart;         if (*buf++ != 12) {             buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);             buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);         pcx_palette(&buf, (uint32_t *) p->data[1], 256);         const uint8_t *palette = bufstart+16;         pcx_palette(&palette, (uint32_t *) p->data[1], 16);     ret = buf - bufstart;
static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,

                            AVPacket *VAR_3) {

    const uint8_t *VAR_4 = VAR_3->VAR_1;

    int VAR_5 = VAR_3->size;

    PCXContext * const s = VAR_0->priv_data;

    AVFrame *picture = VAR_1;

    AVFrame * const p = &s->picture;

    int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;

    unsigned int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18,

                 VAR_19;

    uint8_t *ptr;

    uint8_t const *bufstart = VAR_4;

    uint8_t *scanline;

    int VAR_20 = -1;



    if (VAR_4[0] != 0x0a || VAR_4[1] > 5) {

        av_log(VAR_0, AV_LOG_ERROR, "this is not PCX encoded VAR_1\n");

        return AVERROR_INVALIDDATA;

    }



    VAR_6 = VAR_4[2];

    VAR_7 = AV_RL16(VAR_4+ 4);

    VAR_8 = AV_RL16(VAR_4+ 6);

    VAR_9 = AV_RL16(VAR_4+ 8);

    VAR_10 = AV_RL16(VAR_4+10);



    if (VAR_9 < VAR_7 || VAR_10 < VAR_8) {

        av_log(VAR_0, AV_LOG_ERROR, "invalid image dimensions\n");

        return AVERROR_INVALIDDATA;

    }



    VAR_11 = VAR_9 - VAR_7 + 1;

    VAR_12 = VAR_10 - VAR_8 + 1;



    VAR_13     = VAR_4[3];

    VAR_14     = AV_RL16(VAR_4+66);

    VAR_15            = VAR_4[65];

    VAR_19 = VAR_15 * VAR_14;



    if (VAR_19 < VAR_11 * VAR_13 * VAR_15 / 8) {

        av_log(VAR_0, AV_LOG_ERROR, "PCX VAR_1 is corrupted\n");

        return AVERROR_INVALIDDATA;

    }



    switch ((VAR_15<<8) + VAR_13) {

        case 0x0308:

            VAR_0->pix_fmt = AV_PIX_FMT_RGB24;

            break;

        case 0x0108:

        case 0x0104:

        case 0x0102:

        case 0x0101:

        case 0x0401:

        case 0x0301:

        case 0x0201:

            VAR_0->pix_fmt = AV_PIX_FMT_PAL8;

            break;

        default:

            av_log(VAR_0, AV_LOG_ERROR, "invalid PCX file\n");

            return AVERROR_INVALIDDATA;

    }



    VAR_4 += 128;



    if (p->VAR_1[0])

        VAR_0->release_buffer(VAR_0, p);



    if (av_image_check_size(VAR_11, VAR_12, 0, VAR_0))

        return AVERROR_INVALIDDATA;

    if (VAR_11 != VAR_0->width || VAR_12 != VAR_0->height)

        avcodec_set_dimensions(VAR_0, VAR_11, VAR_12);

    if ((VAR_20 = VAR_0->get_buffer(VAR_0, p)) < 0) {

        av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");

        return VAR_20;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    ptr    = p->VAR_1[0];

    VAR_16 = p->linesize[0];



    scanline = av_malloc(VAR_19);

    if (!scanline)

        return AVERROR(ENOMEM);



    if (VAR_15 == 3 && VAR_13 == 8) {

        for (VAR_17=0; VAR_17<VAR_12; VAR_17++) {

            VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6);



            for (VAR_18=0; VAR_18<VAR_11; VAR_18++) {

                ptr[3*VAR_18  ] = scanline[VAR_18                    ];

                ptr[3*VAR_18+1] = scanline[VAR_18+ VAR_14    ];

                ptr[3*VAR_18+2] = scanline[VAR_18+(VAR_14<<1)];

            }



            ptr += VAR_16;

        }



    } else if (VAR_15 == 1 && VAR_13 == 8) {

        const uint8_t *VAR_21 = bufstart + VAR_5 - 769;



        for (VAR_17=0; VAR_17<VAR_12; VAR_17++, ptr+=VAR_16) {

            VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6);

            memcpy(ptr, scanline, VAR_11);

        }



        if (VAR_4 != VAR_21) {

            av_log(VAR_0, AV_LOG_WARNING, "image VAR_1 possibly corrupted\n");

            VAR_4 = VAR_21;

        }

        if (*VAR_4++ != 12) {

            av_log(VAR_0, AV_LOG_ERROR, "expected VAR_25 after image VAR_1\n");

            VAR_20 = AVERROR_INVALIDDATA;

            goto end;

        }



    } else if (VAR_15 == 1) {   

        GetBitContext s;



        for (VAR_17=0; VAR_17<VAR_12; VAR_17++) {

            init_get_bits(&s, scanline, VAR_19<<3);



            VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6);



            for (VAR_18=0; VAR_18<VAR_11; VAR_18++)

                ptr[VAR_18] = get_bits(&s, VAR_13);

            ptr += VAR_16;

        }



    } else {    

        int VAR_22;



        for (VAR_17=0; VAR_17<VAR_12; VAR_17++) {

            VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6);



            for (VAR_18=0; VAR_18<VAR_11; VAR_18++) {

                int VAR_23 = 0x80 >> (VAR_18&7), VAR_24 = 0;

                for (VAR_22=VAR_15 - 1; VAR_22>=0; VAR_22--) {

                    VAR_24 <<= 1;

                    VAR_24  += !!(scanline[VAR_22*VAR_14 + (VAR_18>>3)] & VAR_23);

                }

                ptr[VAR_18] = VAR_24;

            }

            ptr += VAR_16;

        }

    }



    if (VAR_15 == 1 && VAR_13 == 8) {

        pcx_palette(&VAR_4, (uint32_t *) p->VAR_1[1], 256);

    } else if (VAR_13 * VAR_15 == 1) {

        AV_WN32A(p->VAR_1[1]  , 0xFF000000);

        AV_WN32A(p->VAR_1[1]+4, 0xFFFFFFFF);

    } else if (VAR_13 < 8) {

        const uint8_t *VAR_25 = bufstart+16;

        pcx_palette(&VAR_25, (uint32_t *) p->VAR_1[1], 16);

    }



    *picture = s->picture;

    *VAR_2 = sizeof(AVFrame);



    VAR_20 = VAR_4 - bufstart;

end:

    av_free(scanline);

    return VAR_20;

}

static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,
AVPacket *VAR_3) { const uint8_t *VAR_4 = VAR_3->VAR_1; int VAR_5 = VAR_3->size; PCXContext * const s = VAR_0->priv_data; AVFrame *picture = VAR_1; AVFrame * const p = &s->picture; int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10; unsigned int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18,
VAR_19; uint8_t *ptr; uint8_t const *bufstart = VAR_4; uint8_t *scanline; int VAR_20 = -1; if (VAR_4[0] != 0x0a || VAR_4[1] > 5) { av_log(VAR_0, AV_LOG_ERROR, "this is not PCX encoded VAR_1\n"); return AVERROR_INVALIDDATA; } VAR_6 = VAR_4[2]; VAR_7 = AV_RL16(VAR_4+ 4); VAR_8 = AV_RL16(VAR_4+ 6); VAR_9 = AV_RL16(VAR_4+ 8); VAR_10 = AV_RL16(VAR_4+10); if (VAR_9 < VAR_7 || VAR_10 < VAR_8) { av_log(VAR_0, AV_LOG_ERROR, "invalid image dimensions\n"); return AVERROR_INVALIDDATA; } VAR_11 = VAR_9 - VAR_7 + 1; VAR_12 = VAR_10 - VAR_8 + 1; VAR_13     = VAR_4[3]; VAR_14     = AV_RL16(VAR_4+66); VAR_15            = VAR_4[65]; VAR_19 = VAR_15 * VAR_14; if (VAR_19 < VAR_11 * VAR_13 * VAR_15 / 8) { av_log(VAR_0, AV_LOG_ERROR, "PCX VAR_1 is corrupted\n"); return AVERROR_INVALIDDATA; } switch ((VAR_15<<8) + VAR_13) { case 0x0308:
VAR_0->pix_fmt = AV_PIX_FMT_RGB24; break; case 0x0108:
case 0x0104:
case 0x0102:
case 0x0101:
case 0x0401:
case 0x0301:
case 0x0201:
VAR_0->pix_fmt = AV_PIX_FMT_PAL8; break; default:
av_log(VAR_0, AV_LOG_ERROR, "invalid PCX file\n"); return AVERROR_INVALIDDATA; } VAR_4 += 128; if (p->VAR_1[0])
VAR_0->release_buffer(VAR_0, p); if (av_image_check_size(VAR_11, VAR_12, 0, VAR_0))
return AVERROR_INVALIDDATA; if (VAR_11 != VAR_0->width || VAR_12 != VAR_0->height)
avcodec_set_dimensions(VAR_0, VAR_11, VAR_12); if ((VAR_20 = VAR_0->get_buffer(VAR_0, p)) < 0) { av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n"); return VAR_20; } p->pict_type = AV_PICTURE_TYPE_I; ptr    = p->VAR_1[0]; VAR_16 = p->linesize[0]; scanline = av_malloc(VAR_19); if (!scanline)
return AVERROR(ENOMEM); if (VAR_15 == 3 && VAR_13 == 8) { for (VAR_17=0; VAR_17<VAR_12; VAR_17++) { VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6); for (VAR_18=0; VAR_18<VAR_11; VAR_18++) { ptr[3*VAR_18  ] = scanline[VAR_18                    ]; ptr[3*VAR_18+1] = scanline[VAR_18+ VAR_14    ]; ptr[3*VAR_18+2] = scanline[VAR_18+(VAR_14<<1)]; } ptr += VAR_16; } } else if (VAR_15 == 1 && VAR_13 == 8) { const uint8_t *VAR_21 = bufstart + VAR_5 - 769; for (VAR_17=0; VAR_17<VAR_12; VAR_17++, ptr+=VAR_16) { VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6); memcpy(ptr, scanline, VAR_11); } if (VAR_4 != VAR_21) { av_log(VAR_0, AV_LOG_WARNING, "image VAR_1 possibly corrupted\n"); VAR_4 = VAR_21; } if (*VAR_4++ != 12) { av_log(VAR_0, AV_LOG_ERROR, "expected VAR_25 after image VAR_1\n"); VAR_20 = AVERROR_INVALIDDATA; goto end; } } else if (VAR_15 == 1) { GetBitContext s; for (VAR_17=0; VAR_17<VAR_12; VAR_17++) { init_get_bits(&s, scanline, VAR_19<<3); VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6); for (VAR_18=0; VAR_18<VAR_11; VAR_18++) ptr[VAR_18] = get_bits(&s, VAR_13); ptr += VAR_16; } } else { int VAR_22; for (VAR_17=0; VAR_17<VAR_12; VAR_17++) { VAR_4 = pcx_rle_decode(VAR_4, scanline, VAR_19, VAR_6); for (VAR_18=0; VAR_18<VAR_11; VAR_18++) { int VAR_23 = 0x80 >> (VAR_18&7), VAR_24 = 0; for (VAR_22=VAR_15 - 1; VAR_22>=0; VAR_22--) { VAR_24 <<= 1; VAR_24  += !!(scanline[VAR_22*VAR_14 + (VAR_18>>3)] & VAR_23); } ptr[VAR_18] = VAR_24; } ptr += VAR_16; } } if (VAR_15 == 1 && VAR_13 == 8) { pcx_palette(&VAR_4, (uint32_t *) p->VAR_1[1], 256); } else if (VAR_13 * VAR_15 == 1) { AV_WN32A(p->VAR_1[1]  , 0xFF000000); AV_WN32A(p->VAR_1[1]+4, 0xFFFFFFFF); } else if (VAR_13 < 8) { const uint8_t *VAR_25 = bufstart+16; pcx_palette(&VAR_25, (uint32_t *) p->VAR_1[1], 16); } *picture = s->picture; *VAR_2 = sizeof(AVFrame); VAR_20 = VAR_4 - bufstart; end:
av_free(scanline); return VAR_20; }