static int sunrast_decode_frame(AVCodecContext *avctx, void *data,

                                int *data_size, AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    SUNRASTContext * const s = avctx->priv_data;

    AVFrame *picture = data;

    AVFrame * const p = &s->picture;

    unsigned int w, h, depth, type, maptype, maplength, stride, x, y, len, alen;

    uint8_t *ptr;

    const uint8_t *bufstart = buf;



    if (AV_RB32(buf) != 0x59a66a95) {

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

        return -1;

    }



    w         = AV_RB32(buf+4);

    h         = AV_RB32(buf+8);

    depth     = AV_RB32(buf+12);

    type      = AV_RB32(buf+20);

    maptype   = AV_RB32(buf+24);

    maplength = AV_RB32(buf+28);



    if (type == RT_FORMAT_TIFF || type == RT_FORMAT_IFF) {

        av_log(avctx, AV_LOG_ERROR, "unsupported (compression) type\n");

        return -1;

    }

    if (type > RT_FORMAT_IFF) {

        av_log(avctx, AV_LOG_ERROR, "invalid (compression) type\n");

        return -1;

    }

    if (maptype & ~1) {

        av_log(avctx, AV_LOG_ERROR, "invalid colormap type\n");

        return -1;

    }



    buf += 32;



    switch (depth) {

        case 1:

            avctx->pix_fmt = PIX_FMT_MONOWHITE;

            break;

        case 8:

            avctx->pix_fmt = PIX_FMT_PAL8;

            break;

        case 24:

            avctx->pix_fmt = (type == RT_FORMAT_RGB) ? PIX_FMT_RGB24 : PIX_FMT_BGR24;

            break;

        default:

            av_log(avctx, AV_LOG_ERROR, "invalid depth\n");

            return -1;

    }



    if (p->data[0])

        avctx->release_buffer(avctx, p);



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

        return -1;

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

        avcodec_set_dimensions(avctx, w, h);

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

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

        return -1;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    if (depth != 8 && maplength) {

        av_log(avctx, AV_LOG_WARNING, "useless colormap found or file is corrupted, trying to recover\n");



    } else if (depth == 8) {

        unsigned int len = maplength / 3;



        if (!maplength) {

            av_log(avctx, AV_LOG_ERROR, "colormap expected\n");

            return -1;

        }

        if (maplength % 3 || maplength > 768) {

            av_log(avctx, AV_LOG_WARNING, "invalid colormap length\n");

            return -1;

        }



        ptr = p->data[1];

        for (x=0; x<len; x++, ptr+=4)

            *(uint32_t *)ptr = (buf[x]<<16) + (buf[len+x]<<8) + buf[len+len+x];

    }



    buf += maplength;



    ptr    = p->data[0];

    stride = p->linesize[0];



    /* scanlines are aligned on 16 bit boundaries */

    len  = (depth * w + 7) >> 3;

    alen = len + (len&1);



    if (type == RT_BYTE_ENCODED) {

        int value, run;

        uint8_t *end = ptr + h*stride;



        x = 0;

        while (ptr != end) {

            run = 1;

            if ((value = *buf++) == 0x80) {

                run = *buf++ + 1;

                if (run != 1)

                    value = *buf++;

            }

            while (run--) {

                if (x < len)

                    ptr[x] = value;

                if (++x >= alen) {

                    x = 0;

                    ptr += stride;

                    if (ptr == end)

                        break;

                }

            }

        }

    } else {

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

            memcpy(ptr, buf, len);

            ptr += stride;

            buf += alen;

        }

    }



    *picture = s->picture;

    *data_size = sizeof(AVFrame);



    return buf - bufstart;

}

static int sunrast_decode_frame(AVCodecContext *avctx, void *data,

                                int *data_size, AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    SUNRASTContext * const s = avctx->priv_data;

    AVFrame *picture = data;

    AVFrame * const p = &s->picture;

    unsigned int w, h, depth, type, maptype, maplength, stride, x, y, len, alen;

    uint8_t *ptr;

    const uint8_t *bufstart = buf;



    if (AV_RB32(buf) != 0x59a66a95) {

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

        return -1;

    }



    w         = AV_RB32(buf+4);

    h         = AV_RB32(buf+8);

    depth     = AV_RB32(buf+12);

    type      = AV_RB32(buf+20);

    maptype   = AV_RB32(buf+24);

    maplength = AV_RB32(buf+28);



    if (type == RT_FORMAT_TIFF || type == RT_FORMAT_IFF) {

        av_log(avctx, AV_LOG_ERROR, "unsupported (compression) type\n");

        return -1;

    }

    if (type > RT_FORMAT_IFF) {

        av_log(avctx, AV_LOG_ERROR, "invalid (compression) type\n");

        return -1;

    }

    if (maptype & ~1) {

        av_log(avctx, AV_LOG_ERROR, "invalid colormap type\n");

        return -1;

    }



    buf += 32;



    switch (depth) {

        case 1:

            avctx->pix_fmt = PIX_FMT_MONOWHITE;

            break;

        case 8:

            avctx->pix_fmt = PIX_FMT_PAL8;

            break;

        case 24:

            avctx->pix_fmt = (type == RT_FORMAT_RGB) ? PIX_FMT_RGB24 : PIX_FMT_BGR24;

            break;

        default:

            av_log(avctx, AV_LOG_ERROR, "invalid depth\n");

            return -1;

    }



    if (p->data[0])

        avctx->release_buffer(avctx, p);



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

        return -1;

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

        avcodec_set_dimensions(avctx, w, h);

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

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

        return -1;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    if (depth != 8 && maplength) {

        av_log(avctx, AV_LOG_WARNING, "useless colormap found or file is corrupted, trying to recover\n");



    } else if (depth == 8) {

        unsigned int len = maplength / 3;



        if (!maplength) {

            av_log(avctx, AV_LOG_ERROR, "colormap expected\n");

            return -1;

        }

        if (maplength % 3 || maplength > 768) {

            av_log(avctx, AV_LOG_WARNING, "invalid colormap length\n");

            return -1;

        }



        ptr = p->data[1];

        for (x=0; x<len; x++, ptr+=4)

            *(uint32_t *)ptr = (buf[x]<<16) + (buf[len+x]<<8) + buf[len+len+x];

    }



    buf += maplength;



    ptr    = p->data[0];

    stride = p->linesize[0];



    

    len  = (depth * w + 7) >> 3;

    alen = len + (len&1);



    if (type == RT_BYTE_ENCODED) {

        int value, run;

        uint8_t *end = ptr + h*stride;



        x = 0;

        while (ptr != end) {

            run = 1;

            if ((value = *buf++) == 0x80) {

                run = *buf++ + 1;

                if (run != 1)

                    value = *buf++;

            }

            while (run--) {

                if (x < len)

                    ptr[x] = value;

                if (++x >= alen) {

                    x = 0;

                    ptr += stride;

                    if (ptr == end)

                        break;

                }

            }

        }

    } else {

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

            memcpy(ptr, buf, len);

            ptr += stride;

            buf += alen;

        }

    }



    *picture = s->picture;

    *data_size = sizeof(AVFrame);



    return buf - bufstart;

}

        while (ptr != end) {
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;

    SUNRASTContext * const s = VAR_0->priv_data;

    AVFrame *picture = VAR_1;

    AVFrame * const p = &s->picture;

    unsigned int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_17, VAR_15;

    uint8_t *ptr;

    const uint8_t *VAR_16 = VAR_4;



    if (AV_RB32(VAR_4) != 0x59a66a95) {

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

        return -1;

    }



    VAR_5         = AV_RB32(VAR_4+4);

    VAR_6         = AV_RB32(VAR_4+8);

    VAR_7     = AV_RB32(VAR_4+12);

    VAR_8      = AV_RB32(VAR_4+20);

    VAR_9   = AV_RB32(VAR_4+24);

    VAR_10 = AV_RB32(VAR_4+28);



    if (VAR_8 == RT_FORMAT_TIFF || VAR_8 == RT_FORMAT_IFF) {

        av_log(VAR_0, AV_LOG_ERROR, "unsupported (compression) VAR_8\n");

        return -1;

    }

    if (VAR_8 > RT_FORMAT_IFF) {

        av_log(VAR_0, AV_LOG_ERROR, "invalid (compression) VAR_8\n");

        return -1;

    }

    if (VAR_9 & ~1) {

        av_log(VAR_0, AV_LOG_ERROR, "invalid colormap VAR_8\n");

        return -1;

    }



    VAR_4 += 32;



    switch (VAR_7) {

        case 1:

            VAR_0->pix_fmt = PIX_FMT_MONOWHITE;

            break;

        case 8:

            VAR_0->pix_fmt = PIX_FMT_PAL8;

            break;

        case 24:

            VAR_0->pix_fmt = (VAR_8 == RT_FORMAT_RGB) ? PIX_FMT_RGB24 : PIX_FMT_BGR24;

            break;

        default:

            av_log(VAR_0, AV_LOG_ERROR, "invalid VAR_7\n");

            return -1;

    }



    if (p->VAR_1[0])

        VAR_0->release_buffer(VAR_0, p);



    if (av_image_check_size(VAR_5, VAR_6, 0, VAR_0))

        return -1;

    if (VAR_5 != VAR_0->width || VAR_6 != VAR_0->height)

        avcodec_set_dimensions(VAR_0, VAR_5, VAR_6);

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

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

        return -1;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    if (VAR_7 != 8 && VAR_10) {

        av_log(VAR_0, AV_LOG_WARNING, "useless colormap found or file is corrupted, trying to recover\n");



    } else if (VAR_7 == 8) {

        unsigned int VAR_17 = VAR_10 / 3;



        if (!VAR_10) {

            av_log(VAR_0, AV_LOG_ERROR, "colormap expected\n");

            return -1;

        }

        if (VAR_10 % 3 || VAR_10 > 768) {

            av_log(VAR_0, AV_LOG_WARNING, "invalid colormap length\n");

            return -1;

        }



        ptr = p->VAR_1[1];

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

            *(uint32_t *)ptr = (VAR_4[VAR_12]<<16) + (VAR_4[VAR_17+VAR_12]<<8) + VAR_4[VAR_17+VAR_17+VAR_12];

    }



    VAR_4 += VAR_10;



    ptr    = p->VAR_1[0];

    VAR_11 = p->linesize[0];



    

    VAR_17  = (VAR_7 * VAR_5 + 7) >> 3;

    VAR_15 = VAR_17 + (VAR_17&1);



    if (VAR_8 == RT_BYTE_ENCODED) {

        int VAR_17, VAR_18;

        uint8_t *end = ptr + VAR_6*VAR_11;



        VAR_12 = 0;

        while (ptr != end) {

            VAR_18 = 1;

            if ((VAR_17 = *VAR_4++) == 0x80) {

                VAR_18 = *VAR_4++ + 1;

                if (VAR_18 != 1)

                    VAR_17 = *VAR_4++;

            }

            while (VAR_18--) {

                if (VAR_12 < VAR_17)

                    ptr[VAR_12] = VAR_17;

                if (++VAR_12 >= VAR_15) {

                    VAR_12 = 0;

                    ptr += VAR_11;

                    if (ptr == end)

                        break;

                }

            }

        }

    } else {

        for (VAR_13=0; VAR_13<VAR_6; VAR_13++) {

            memcpy(ptr, VAR_4, VAR_17);

            ptr += VAR_11;

            VAR_4 += VAR_15;

        }

    }



    *picture = s->picture;

    *VAR_2 = sizeof(AVFrame);



    return VAR_4 - VAR_16;

}

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; SUNRASTContext * const s = VAR_0->priv_data; AVFrame *picture = VAR_1; AVFrame * const p = &s->picture; unsigned int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_17, VAR_15; uint8_t *ptr; const uint8_t *VAR_16 = VAR_4; if (AV_RB32(VAR_4) != 0x59a66a95) { av_log(VAR_0, AV_LOG_ERROR, "this is not sunras encoded VAR_1\n"); return -1; } VAR_5         = AV_RB32(VAR_4+4); VAR_6         = AV_RB32(VAR_4+8); VAR_7     = AV_RB32(VAR_4+12); VAR_8      = AV_RB32(VAR_4+20); VAR_9   = AV_RB32(VAR_4+24); VAR_10 = AV_RB32(VAR_4+28); if (VAR_8 == RT_FORMAT_TIFF || VAR_8 == RT_FORMAT_IFF) { av_log(VAR_0, AV_LOG_ERROR, "unsupported (compression) VAR_8\n"); return -1; } if (VAR_8 > RT_FORMAT_IFF) { av_log(VAR_0, AV_LOG_ERROR, "invalid (compression) VAR_8\n"); return -1; } if (VAR_9 & ~1) { av_log(VAR_0, AV_LOG_ERROR, "invalid colormap VAR_8\n"); return -1; } VAR_4 += 32; switch (VAR_7) { case 1:
VAR_0->pix_fmt = PIX_FMT_MONOWHITE; break; case 8:
VAR_0->pix_fmt = PIX_FMT_PAL8; break; case 24:
VAR_0->pix_fmt = (VAR_8 == RT_FORMAT_RGB) ? PIX_FMT_RGB24 : PIX_FMT_BGR24; break; default:
av_log(VAR_0, AV_LOG_ERROR, "invalid VAR_7\n"); return -1; } if (p->VAR_1[0])
VAR_0->release_buffer(VAR_0, p); if (av_image_check_size(VAR_5, VAR_6, 0, VAR_0))
return -1; if (VAR_5 != VAR_0->width || VAR_6 != VAR_0->height)
avcodec_set_dimensions(VAR_0, VAR_5, VAR_6); if (VAR_0->get_buffer(VAR_0, p) < 0) { av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n"); return -1; } p->pict_type = AV_PICTURE_TYPE_I; if (VAR_7 != 8 && VAR_10) { av_log(VAR_0, AV_LOG_WARNING, "useless colormap found or file is corrupted, trying to recover\n"); } else if (VAR_7 == 8) { unsigned int VAR_17 = VAR_10 / 3; if (!VAR_10) { av_log(VAR_0, AV_LOG_ERROR, "colormap expected\n"); return -1; } if (VAR_10 % 3 || VAR_10 > 768) { av_log(VAR_0, AV_LOG_WARNING, "invalid colormap length\n"); return -1; } ptr = p->VAR_1[1]; for (VAR_12=0; VAR_12<VAR_17; VAR_12++, ptr+=4) *(uint32_t *)ptr = (VAR_4[VAR_12]<<16) + (VAR_4[VAR_17+VAR_12]<<8) + VAR_4[VAR_17+VAR_17+VAR_12]; } VAR_4 += VAR_10; ptr    = p->VAR_1[0]; VAR_11 = p->linesize[0]; VAR_17  = (VAR_7 * VAR_5 + 7) >> 3; VAR_15 = VAR_17 + (VAR_17&1); if (VAR_8 == RT_BYTE_ENCODED) { int VAR_17, VAR_18; uint8_t *end = ptr + VAR_6*VAR_11; VAR_12 = 0; while (ptr != end) { VAR_18 = 1; if ((VAR_17 = *VAR_4++) == 0x80) { VAR_18 = *VAR_4++ + 1; if (VAR_18 != 1)
VAR_17 = *VAR_4++; } while (VAR_18--) { if (VAR_12 < VAR_17)
ptr[VAR_12] = VAR_17; if (++VAR_12 >= VAR_15) { VAR_12 = 0; ptr += VAR_11; if (ptr == end)
break; } } } } else { for (VAR_13=0; VAR_13<VAR_6; VAR_13++) { memcpy(ptr, VAR_4, VAR_17); ptr += VAR_11; VAR_4 += VAR_15; } } *picture = s->picture; *VAR_2 = sizeof(AVFrame); return VAR_4 - VAR_16; }