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

                        AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    NuvContext *c = avctx->priv_data;

    AVFrame *picture = data;

    int orig_size = buf_size;

    int keyframe;

    int result;

    enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',

          NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',

          NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} comptype;



    if (buf_size < 12) {

        av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");

        return -1;

    }



    // codec data (rtjpeg quant tables)

    if (buf[0] == 'D' && buf[1] == 'R') {

        int ret;

        // skip rest of the frameheader.

        buf = &buf[12];

        buf_size -= 12;

        ret = get_quant(avctx, c, buf, buf_size);

        if (ret < 0)

            return ret;

        ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height, c->lq, c->cq);

        return orig_size;

    }



    if (buf[0] != 'V' || buf_size < 12) {

        av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");

        return -1;

    }

    comptype = buf[1];

    switch (comptype) {

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG:

            keyframe = !buf[2]; break;

        case NUV_COPY_LAST:

            keyframe = 0; break;

        default:

            keyframe = 1; break;

    }

    // skip rest of the frameheader.

    buf = &buf[12];

    buf_size -= 12;

    if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {

        int outlen = c->decomp_size, inlen = buf_size;

        if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen))

            av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");

        buf = c->decomp_buf;

        buf_size = c->decomp_size;

    }

    if (c->codec_frameheader) {

        int w, h, q;

        if (buf_size < 12) {

            av_log(avctx, AV_LOG_ERROR, "invalid nuv video frame\n");

            return -1;

        }

        w = AV_RL16(&buf[6]);

        h = AV_RL16(&buf[8]);

        q = buf[10];

        if (!codec_reinit(avctx, w, h, q))

            return -1;

        buf = &buf[12];

        buf_size -= 12;

    }



    if (keyframe && c->pic.data[0])

        avctx->release_buffer(avctx, &c->pic);

    c->pic.reference = 3;

    c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |

                          FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

    result = avctx->reget_buffer(avctx, &c->pic);

    if (result < 0) {

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

        return -1;

    }



    c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

    c->pic.key_frame = keyframe;

    // decompress/copy/whatever data

    switch (comptype) {

        case NUV_LZO:

        case NUV_UNCOMPRESSED: {

            int height = c->height;

            if (buf_size < c->width * height * 3 / 2) {

                av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");

                height = buf_size / c->width / 3 * 2;

            }

            copy_frame(&c->pic, buf, c->width, height);

            break;

        }

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG: {

            ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, buf, buf_size);

            break;

        }

        case NUV_BLACK: {

            memset(c->pic.data[0], 0, c->width * c->height);

            memset(c->pic.data[1], 128, c->width * c->height / 4);

            memset(c->pic.data[2], 128, c->width * c->height / 4);

            break;

        }

        case NUV_COPY_LAST: {

            /* nothing more to do here */

            break;

        }

        default:

            av_log(avctx, AV_LOG_ERROR, "unknown compression\n");

            return -1;

    }



    *picture = c->pic;

    *data_size = sizeof(AVFrame);

    return orig_size;

}

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

                        AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    NuvContext *c = avctx->priv_data;

    AVFrame *picture = data;

    int orig_size = buf_size;

    int keyframe;

    int result;

    enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',

          NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',

          NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} comptype;



    if (buf_size < 12) {

        av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");

        return -1;

    }



    

    if (buf[0] == 'D' && buf[1] == 'R') {

        int ret;

        

        buf = &buf[12];

        buf_size -= 12;

        ret = get_quant(avctx, c, buf, buf_size);

        if (ret < 0)

            return ret;

        ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height, c->lq, c->cq);

        return orig_size;

    }



    if (buf[0] != 'V' || buf_size < 12) {

        av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");

        return -1;

    }

    comptype = buf[1];

    switch (comptype) {

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG:

            keyframe = !buf[2]; break;

        case NUV_COPY_LAST:

            keyframe = 0; break;

        default:

            keyframe = 1; break;

    }

    

    buf = &buf[12];

    buf_size -= 12;

    if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {

        int outlen = c->decomp_size, inlen = buf_size;

        if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen))

            av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");

        buf = c->decomp_buf;

        buf_size = c->decomp_size;

    }

    if (c->codec_frameheader) {

        int w, h, q;

        if (buf_size < 12) {

            av_log(avctx, AV_LOG_ERROR, "invalid nuv video frame\n");

            return -1;

        }

        w = AV_RL16(&buf[6]);

        h = AV_RL16(&buf[8]);

        q = buf[10];

        if (!codec_reinit(avctx, w, h, q))

            return -1;

        buf = &buf[12];

        buf_size -= 12;

    }



    if (keyframe && c->pic.data[0])

        avctx->release_buffer(avctx, &c->pic);

    c->pic.reference = 3;

    c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |

                          FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

    result = avctx->reget_buffer(avctx, &c->pic);

    if (result < 0) {

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

        return -1;

    }



    c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

    c->pic.key_frame = keyframe;

    

    switch (comptype) {

        case NUV_LZO:

        case NUV_UNCOMPRESSED: {

            int height = c->height;

            if (buf_size < c->width * height * 3 / 2) {

                av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");

                height = buf_size / c->width / 3 * 2;

            }

            copy_frame(&c->pic, buf, c->width, height);

            break;

        }

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG: {

            ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, buf, buf_size);

            break;

        }

        case NUV_BLACK: {

            memset(c->pic.data[0], 0, c->width * c->height);

            memset(c->pic.data[1], 128, c->width * c->height / 4);

            memset(c->pic.data[2], 128, c->width * c->height / 4);

            break;

        }

        case NUV_COPY_LAST: {

            

            break;

        }

        default:

            av_log(avctx, AV_LOG_ERROR, "unknown compression\n");

            return -1;

    }



    *picture = c->pic;

    *data_size = sizeof(AVFrame);

    return orig_size;

}

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;

    NuvContext *c = VAR_0->priv_data;

    AVFrame *picture = VAR_1;

    int VAR_6 = VAR_5;

    int VAR_7;

    int VAR_8;

    enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',

          NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',

          NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} VAR_9;



    if (VAR_5 < 12) {

        av_log(VAR_0, AV_LOG_ERROR, "coded frame too small\n");

        return -1;

    }



    

    if (VAR_4[0] == 'D' && VAR_4[1] == 'R') {

        int VAR_10;

        

        VAR_4 = &VAR_4[12];

        VAR_5 -= 12;

        VAR_10 = get_quant(VAR_0, c, VAR_4, VAR_5);

        if (VAR_10 < 0)

            return VAR_10;

        ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->VAR_16, c->lq, c->cq);

        return VAR_6;

    }



    if (VAR_4[0] != 'V' || VAR_5 < 12) {

        av_log(VAR_0, AV_LOG_ERROR, "not a nuv video frame\n");

        return -1;

    }

    VAR_9 = VAR_4[1];

    switch (VAR_9) {

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG:

            VAR_7 = !VAR_4[2]; break;

        case NUV_COPY_LAST:

            VAR_7 = 0; break;

        default:

            VAR_7 = 1; break;

    }

    

    VAR_4 = &VAR_4[12];

    VAR_5 -= 12;

    if (VAR_9 == NUV_RTJPEG_IN_LZO || VAR_9 == NUV_LZO) {

        int VAR_11 = c->decomp_size, VAR_12 = VAR_5;

        if (av_lzo1x_decode(c->decomp_buf, &VAR_11, VAR_4, &VAR_12))

            av_log(VAR_0, AV_LOG_ERROR, "error during lzo decompression\n");

        VAR_4 = c->decomp_buf;

        VAR_5 = c->decomp_size;

    }

    if (c->codec_frameheader) {

        int VAR_13, VAR_14, VAR_15;

        if (VAR_5 < 12) {

            av_log(VAR_0, AV_LOG_ERROR, "invalid nuv video frame\n");

            return -1;

        }

        VAR_13 = AV_RL16(&VAR_4[6]);

        VAR_14 = AV_RL16(&VAR_4[8]);

        VAR_15 = VAR_4[10];

        if (!codec_reinit(VAR_0, VAR_13, VAR_14, VAR_15))

            return -1;

        VAR_4 = &VAR_4[12];

        VAR_5 -= 12;

    }



    if (VAR_7 && c->pic.VAR_1[0])

        VAR_0->release_buffer(VAR_0, &c->pic);

    c->pic.reference = 3;

    c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |

                          FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

    VAR_8 = VAR_0->reget_buffer(VAR_0, &c->pic);

    if (VAR_8 < 0) {

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

        return -1;

    }



    c->pic.pict_type = VAR_7 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

    c->pic.key_frame = VAR_7;

    

    switch (VAR_9) {

        case NUV_LZO:

        case NUV_UNCOMPRESSED: {

            int VAR_16 = c->VAR_16;

            if (VAR_5 < c->width * VAR_16 * 3 / 2) {

                av_log(VAR_0, AV_LOG_ERROR, "uncompressed frame too short\n");

                VAR_16 = VAR_5 / c->width / 3 * 2;

            }

            copy_frame(&c->pic, VAR_4, c->width, VAR_16);

            break;

        }

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG: {

            ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, VAR_4, VAR_5);

            break;

        }

        case NUV_BLACK: {

            memset(c->pic.VAR_1[0], 0, c->width * c->VAR_16);

            memset(c->pic.VAR_1[1], 128, c->width * c->VAR_16 / 4);

            memset(c->pic.VAR_1[2], 128, c->width * c->VAR_16 / 4);

            break;

        }

        case NUV_COPY_LAST: {

            

            break;

        }

        default:

            av_log(VAR_0, AV_LOG_ERROR, "unknown compression\n");

            return -1;

    }



    *picture = c->pic;

    *VAR_2 = sizeof(AVFrame);

    return VAR_6;

}

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; NuvContext *c = VAR_0->priv_data; AVFrame *picture = VAR_1; int VAR_6 = VAR_5; int VAR_7; int VAR_8; enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1', NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',
NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} VAR_9; if (VAR_5 < 12) { av_log(VAR_0, AV_LOG_ERROR, "coded frame too small\n"); return -1; } if (VAR_4[0] == 'D' && VAR_4[1] == 'R') { int VAR_10; VAR_4 = &VAR_4[12]; VAR_5 -= 12; VAR_10 = get_quant(VAR_0, c, VAR_4, VAR_5); if (VAR_10 < 0)
return VAR_10; ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->VAR_16, c->lq, c->cq); return VAR_6; } if (VAR_4[0] != 'V' || VAR_5 < 12) { av_log(VAR_0, AV_LOG_ERROR, "not a nuv video frame\n"); return -1; } VAR_9 = VAR_4[1]; switch (VAR_9) { case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG:
VAR_7 = !VAR_4[2]; break; case NUV_COPY_LAST:
VAR_7 = 0; break; default:
VAR_7 = 1; break; } VAR_4 = &VAR_4[12]; VAR_5 -= 12; if (VAR_9 == NUV_RTJPEG_IN_LZO || VAR_9 == NUV_LZO) { int VAR_11 = c->decomp_size, VAR_12 = VAR_5; if (av_lzo1x_decode(c->decomp_buf, &VAR_11, VAR_4, &VAR_12))
av_log(VAR_0, AV_LOG_ERROR, "error during lzo decompression\n"); VAR_4 = c->decomp_buf; VAR_5 = c->decomp_size; } if (c->codec_frameheader) { int VAR_13, VAR_14, VAR_15; if (VAR_5 < 12) { av_log(VAR_0, AV_LOG_ERROR, "invalid nuv video frame\n"); return -1; } VAR_13 = AV_RL16(&VAR_4[6]); VAR_14 = AV_RL16(&VAR_4[8]); VAR_15 = VAR_4[10]; if (!codec_reinit(VAR_0, VAR_13, VAR_14, VAR_15))
return -1; VAR_4 = &VAR_4[12]; VAR_5 -= 12; } if (VAR_7 && c->pic.VAR_1[0])
VAR_0->release_buffer(VAR_0, &c->pic); c->pic.reference = 3; c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |
FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; VAR_8 = VAR_0->reget_buffer(VAR_0, &c->pic); if (VAR_8 < 0) { av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n"); return -1; } c->pic.pict_type = VAR_7 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; c->pic.key_frame = VAR_7; switch (VAR_9) { case NUV_LZO:
case NUV_UNCOMPRESSED: { int VAR_16 = c->VAR_16; if (VAR_5 < c->width * VAR_16 * 3 / 2) { av_log(VAR_0, AV_LOG_ERROR, "uncompressed frame too short\n"); VAR_16 = VAR_5 / c->width / 3 * 2; } copy_frame(&c->pic, VAR_4, c->width, VAR_16); break; } case NUV_RTJPEG_IN_LZO:
case NUV_RTJPEG: { ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, VAR_4, VAR_5); break; } case NUV_BLACK: { memset(c->pic.VAR_1[0], 0, c->width * c->VAR_16); memset(c->pic.VAR_1[1], 128, c->width * c->VAR_16 / 4); memset(c->pic.VAR_1[2], 128, c->width * c->VAR_16 / 4); break; } case NUV_COPY_LAST: { break; } default:
av_log(VAR_0, AV_LOG_ERROR, "unknown compression\n"); return -1; } *picture = c->pic; *VAR_2 = sizeof(AVFrame); return VAR_6; }