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

                                int *data_size, AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    const uint8_t *buf_end = avpkt->data + avpkt->size;

    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 (avpkt->size < 32)

        return AVERROR_INVALIDDATA;



    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);

    buf      += 32;



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

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

        return -1;

    }

    if (type < RT_OLD || type > RT_FORMAT_IFF) {

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

        return -1;

    }

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

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

        return -1;

    }

    if (maptype & ~1) {

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

        return -1;

    }





    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 (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 (buf_end - buf < maplength)

        return AVERROR_INVALIDDATA;



    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 && buf < buf_end) {

            run = 1;

            if (buf_end - buf < 1)

                return AVERROR_INVALIDDATA;



            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++) {

            if (buf_end - buf < len)

                break;

            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;

    const uint8_t *buf_end = avpkt->data + avpkt->size;

    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 (avpkt->size < 32)

        return AVERROR_INVALIDDATA;



    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);

    buf      += 32;



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

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

        return -1;

    }

    if (type < RT_OLD || type > RT_FORMAT_IFF) {

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

        return -1;

    }

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

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

        return -1;

    }

    if (maptype & ~1) {

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

        return -1;

    }





    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 (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 (buf_end - buf < maplength)

        return AVERROR_INVALIDDATA;



    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 && buf < buf_end) {

            run = 1;

            if (buf_end - buf < 1)

                return AVERROR_INVALIDDATA;



            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++) {

            if (buf_end - buf < len)

                break;

            memcpy(ptr, buf, len);

            ptr += stride;

            buf += alen;

        }

    }



    *picture = s->picture;

    *data_size = sizeof(AVFrame);



    return 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;

    const uint8_t *VAR_5 = VAR_3->VAR_1 + VAR_3->size;

    SUNRASTContext * const s = VAR_0->priv_data;

    AVFrame *picture = VAR_1;

    AVFrame * const p = &s->picture;

    unsigned int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_18, VAR_16;

    uint8_t *ptr;

    const uint8_t *VAR_17 = VAR_4;



    if (VAR_3->size < 32)

        return AVERROR_INVALIDDATA;



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

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

        return -1;

    }



    VAR_6         = AV_RB32(VAR_4+4);

    VAR_7         = AV_RB32(VAR_4+8);

    VAR_8     = AV_RB32(VAR_4+12);

    VAR_9      = AV_RB32(VAR_4+20);

    VAR_10   = AV_RB32(VAR_4+24);

    VAR_11 = AV_RB32(VAR_4+28);

    VAR_4      += 32;



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

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

        return -1;

    }

    if (VAR_9 < RT_OLD || VAR_9 > RT_FORMAT_IFF) {

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

        return -1;

    }

    if (av_image_check_size(VAR_6, VAR_7, 0, VAR_0)) {

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

        return -1;

    }

    if (VAR_10 & ~1) {

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

        return -1;

    }





    switch (VAR_8) {

        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_9 == RT_FORMAT_RGB) ? PIX_FMT_RGB24 : PIX_FMT_BGR24;

            break;

        default:

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

            return -1;

    }



    if (p->VAR_1[0])

        VAR_0->release_buffer(VAR_0, p);



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

        avcodec_set_dimensions(VAR_0, VAR_6, VAR_7);

    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_5 - VAR_4 < VAR_11)

        return AVERROR_INVALIDDATA;



    if (VAR_8 != 8 && VAR_11) {

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



    } else if (VAR_8 == 8) {

        unsigned int VAR_18 = VAR_11 / 3;



        if (!VAR_11) {

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

            return -1;

        }

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

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

            return -1;

        }



        ptr = p->VAR_1[1];

        for (VAR_13=0; VAR_13<VAR_18; VAR_13++, ptr+=4)

            *(uint32_t *)ptr = (VAR_4[VAR_13]<<16) + (VAR_4[VAR_18+VAR_13]<<8) + VAR_4[VAR_18+VAR_18+VAR_13];

    }



    VAR_4 += VAR_11;



    ptr    = p->VAR_1[0];

    VAR_12 = p->linesize[0];



    

    VAR_18  = (VAR_8 * VAR_6 + 7) >> 3;

    VAR_16 = VAR_18 + (VAR_18&1);



    if (VAR_9 == RT_BYTE_ENCODED) {

        int VAR_18, VAR_19;

        uint8_t *end = ptr + VAR_7*VAR_12;



        VAR_13 = 0;

        while (ptr != end && VAR_4 < VAR_5) {

            VAR_19 = 1;

            if (VAR_5 - VAR_4 < 1)

                return AVERROR_INVALIDDATA;



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

                VAR_19 = *VAR_4++ + 1;

                if (VAR_19 != 1)

                    VAR_18 = *VAR_4++;

            }

            while (VAR_19--) {

                if (VAR_13 < VAR_18)

                    ptr[VAR_13] = VAR_18;

                if (++VAR_13 >= VAR_16) {

                    VAR_13 = 0;

                    ptr += VAR_12;

                    if (ptr == end)

                        break;

                }

            }

        }

    } else {

        for (VAR_14=0; VAR_14<VAR_7; VAR_14++) {

            if (VAR_5 - VAR_4 < VAR_18)

                break;

            memcpy(ptr, VAR_4, VAR_18);

            ptr += VAR_12;

            VAR_4 += VAR_16;

        }

    }



    *picture = s->picture;

    *VAR_2 = sizeof(AVFrame);



    return VAR_4 - VAR_17;

}

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