static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

                        const AVFrame *frame, int *got_packet)

{

    SgiContext *s = avctx->priv_data;

    const AVFrame * const p = frame;

    PutByteContext pbc;

    uint8_t *in_buf, *encode_buf;

    int x, y, z, length, tablesize, ret;

    unsigned int width, height, depth, dimension;

    unsigned int bytes_per_channel, pixmax, put_be;



#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

    avctx->coded_frame->key_frame = 1;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



#if FF_API_CODER_TYPE

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->coder_type == FF_CODER_TYPE_RAW)

        s->rle = 0;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    width  = avctx->width;

    height = avctx->height;

    bytes_per_channel = 1;

    pixmax = 0xFF;

    put_be = HAVE_BIGENDIAN;



    switch (avctx->pix_fmt) {

    case AV_PIX_FMT_GRAY8:

        dimension = SGI_SINGLE_CHAN;

        depth     = SGI_GRAYSCALE;

        break;

    case AV_PIX_FMT_RGB24:

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGB;

        break;

    case AV_PIX_FMT_RGBA:

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGBA;

        break;

    case AV_PIX_FMT_GRAY16LE:

        put_be = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_GRAY16BE:

        bytes_per_channel = 2;

        pixmax = 0xFFFF;

        dimension = SGI_SINGLE_CHAN;

        depth     = SGI_GRAYSCALE;

        break;

    case AV_PIX_FMT_RGB48LE:

        put_be = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_RGB48BE:

        bytes_per_channel = 2;

        pixmax = 0xFFFF;

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGB;

        break;

    case AV_PIX_FMT_RGBA64LE:

        put_be = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_RGBA64BE:

        bytes_per_channel = 2;

        pixmax = 0xFFFF;

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGBA;

        break;

    default:

        return AVERROR_INVALIDDATA;

    }



    tablesize = depth * height * 4;

    length = SGI_HEADER_SIZE;

    if (!s->rle)

        length += depth * height * width;

    else // assume sgi_rle_encode() produces at most 2x size of input

        length += tablesize * 2 + depth * height * (2 * width + 1);



    if ((ret = ff_alloc_packet(pkt, bytes_per_channel * length)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", length);

        return ret;

    }



    bytestream2_init_writer(&pbc, pkt->data, pkt->size);



    /* Encode header. */

    bytestream2_put_be16(&pbc, SGI_MAGIC);

    bytestream2_put_byte(&pbc, s->rle); /* RLE 1 - VERBATIM 0 */

    bytestream2_put_byte(&pbc, bytes_per_channel);

    bytestream2_put_be16(&pbc, dimension);

    bytestream2_put_be16(&pbc, width);

    bytestream2_put_be16(&pbc, height);

    bytestream2_put_be16(&pbc, depth);



    bytestream2_put_be32(&pbc, 0L); /* pixmin */

    bytestream2_put_be32(&pbc, pixmax);

    bytestream2_put_be32(&pbc, 0L); /* dummy */



    /* name */

    bytestream2_skip_p(&pbc, 80);



    /* colormap */

    bytestream2_put_be32(&pbc, 0L);



    /* The rest of the 512 byte header is unused. */

    bytestream2_skip_p(&pbc, 404);



    if (s->rle) {

        PutByteContext taboff_pcb, tablen_pcb;



        /* Skip RLE offset table. */

        bytestream2_init_writer(&taboff_pcb, pbc.buffer, tablesize);

        bytestream2_skip_p(&pbc, tablesize);



        /* Skip RLE length table. */

        bytestream2_init_writer(&tablen_pcb, pbc.buffer, tablesize);

        bytestream2_skip_p(&pbc, tablesize);



        /* Make an intermediate consecutive buffer. */

        if (!(encode_buf = av_malloc(width * bytes_per_channel)))

            return AVERROR(ENOMEM);



        for (z = 0; z < depth; z++) {

            in_buf = p->data[0] + p->linesize[0] * (height - 1) + z * bytes_per_channel;



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

                bytestream2_put_be32(&taboff_pcb, bytestream2_tell_p(&pbc));



                for (x = 0; x < width * bytes_per_channel; x += bytes_per_channel)

                    encode_buf[x] = in_buf[depth * x];



                length = sgi_rle_encode(&pbc, encode_buf, width,

                                        bytes_per_channel);

                if (length < 1) {

                    av_free(encode_buf);

                    return AVERROR_INVALIDDATA;

                }



                bytestream2_put_be32(&tablen_pcb, length);

                in_buf -= p->linesize[0];

            }

        }



        av_free(encode_buf);

    } else {

        for (z = 0; z < depth; z++) {

            in_buf = p->data[0] + p->linesize[0] * (height - 1) + z * bytes_per_channel;



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

                for (x = 0; x < width * depth; x += depth)

                    if (bytes_per_channel == 1)

                        bytestream2_put_byte(&pbc, in_buf[x]);

                    else

                        if (put_be)

                            bytestream2_put_be16(&pbc, ((uint16_t *)in_buf)[x]);

                        else

                            bytestream2_put_le16(&pbc, ((uint16_t *)in_buf)[x]);



                in_buf -= p->linesize[0];

            }

        }

    }



    /* total length */

    pkt->size   = bytestream2_tell_p(&pbc);

    pkt->flags |= AV_PKT_FLAG_KEY;

    *got_packet = 1;



    return 0;

}

static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

                        const AVFrame *frame, int *got_packet)

{

    SgiContext *s = avctx->priv_data;

    const AVFrame * const p = frame;

    PutByteContext pbc;

    uint8_t *in_buf, *encode_buf;

    int x, y, z, length, tablesize, ret;

    unsigned int width, height, depth, dimension;

    unsigned int bytes_per_channel, pixmax, put_be;



#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

    avctx->coded_frame->key_frame = 1;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



#if FF_API_CODER_TYPE

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->coder_type == FF_CODER_TYPE_RAW)

        s->rle = 0;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    width  = avctx->width;

    height = avctx->height;

    bytes_per_channel = 1;

    pixmax = 0xFF;

    put_be = HAVE_BIGENDIAN;



    switch (avctx->pix_fmt) {

    case AV_PIX_FMT_GRAY8:

        dimension = SGI_SINGLE_CHAN;

        depth     = SGI_GRAYSCALE;

        break;

    case AV_PIX_FMT_RGB24:

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGB;

        break;

    case AV_PIX_FMT_RGBA:

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGBA;

        break;

    case AV_PIX_FMT_GRAY16LE:

        put_be = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_GRAY16BE:

        bytes_per_channel = 2;

        pixmax = 0xFFFF;

        dimension = SGI_SINGLE_CHAN;

        depth     = SGI_GRAYSCALE;

        break;

    case AV_PIX_FMT_RGB48LE:

        put_be = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_RGB48BE:

        bytes_per_channel = 2;

        pixmax = 0xFFFF;

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGB;

        break;

    case AV_PIX_FMT_RGBA64LE:

        put_be = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_RGBA64BE:

        bytes_per_channel = 2;

        pixmax = 0xFFFF;

        dimension = SGI_MULTI_CHAN;

        depth     = SGI_RGBA;

        break;

    default:

        return AVERROR_INVALIDDATA;

    }



    tablesize = depth * height * 4;

    length = SGI_HEADER_SIZE;

    if (!s->rle)

        length += depth * height * width;

    else 

        length += tablesize * 2 + depth * height * (2 * width + 1);



    if ((ret = ff_alloc_packet(pkt, bytes_per_channel * length)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", length);

        return ret;

    }



    bytestream2_init_writer(&pbc, pkt->data, pkt->size);



    

    bytestream2_put_be16(&pbc, SGI_MAGIC);

    bytestream2_put_byte(&pbc, s->rle); 

    bytestream2_put_byte(&pbc, bytes_per_channel);

    bytestream2_put_be16(&pbc, dimension);

    bytestream2_put_be16(&pbc, width);

    bytestream2_put_be16(&pbc, height);

    bytestream2_put_be16(&pbc, depth);



    bytestream2_put_be32(&pbc, 0L); 

    bytestream2_put_be32(&pbc, pixmax);

    bytestream2_put_be32(&pbc, 0L); 



    

    bytestream2_skip_p(&pbc, 80);



    

    bytestream2_put_be32(&pbc, 0L);



    

    bytestream2_skip_p(&pbc, 404);



    if (s->rle) {

        PutByteContext taboff_pcb, tablen_pcb;



        

        bytestream2_init_writer(&taboff_pcb, pbc.buffer, tablesize);

        bytestream2_skip_p(&pbc, tablesize);



        

        bytestream2_init_writer(&tablen_pcb, pbc.buffer, tablesize);

        bytestream2_skip_p(&pbc, tablesize);



        

        if (!(encode_buf = av_malloc(width * bytes_per_channel)))

            return AVERROR(ENOMEM);



        for (z = 0; z < depth; z++) {

            in_buf = p->data[0] + p->linesize[0] * (height - 1) + z * bytes_per_channel;



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

                bytestream2_put_be32(&taboff_pcb, bytestream2_tell_p(&pbc));



                for (x = 0; x < width * bytes_per_channel; x += bytes_per_channel)

                    encode_buf[x] = in_buf[depth * x];



                length = sgi_rle_encode(&pbc, encode_buf, width,

                                        bytes_per_channel);

                if (length < 1) {

                    av_free(encode_buf);

                    return AVERROR_INVALIDDATA;

                }



                bytestream2_put_be32(&tablen_pcb, length);

                in_buf -= p->linesize[0];

            }

        }



        av_free(encode_buf);

    } else {

        for (z = 0; z < depth; z++) {

            in_buf = p->data[0] + p->linesize[0] * (height - 1) + z * bytes_per_channel;



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

                for (x = 0; x < width * depth; x += depth)

                    if (bytes_per_channel == 1)

                        bytestream2_put_byte(&pbc, in_buf[x]);

                    else

                        if (put_be)

                            bytestream2_put_be16(&pbc, ((uint16_t *)in_buf)[x]);

                        else

                            bytestream2_put_le16(&pbc, ((uint16_t *)in_buf)[x]);



                in_buf -= p->linesize[0];

            }

        }

    }



    

    pkt->size   = bytestream2_tell_p(&pbc);

    pkt->flags |= AV_PKT_FLAG_KEY;

    *got_packet = 1;



    return 0;

}

static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,

                        const AVFrame *VAR_2, int *VAR_3)

{

    SgiContext *s = VAR_0->priv_data;

    const AVFrame * const VAR_4 = VAR_2;

    PutByteContext pbc;

    uint8_t *in_buf, *encode_buf;

    int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;

    unsigned int VAR_11, VAR_12, VAR_13, VAR_14;

    unsigned int VAR_15, VAR_16, VAR_17;



#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

    VAR_0->coded_frame->pict_type = AV_PICTURE_TYPE_I;

    VAR_0->coded_frame->key_frame = 1;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



#if FF_API_CODER_TYPE

FF_DISABLE_DEPRECATION_WARNINGS

    if (VAR_0->coder_type == FF_CODER_TYPE_RAW)

        s->rle = 0;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    VAR_11  = VAR_0->VAR_11;

    VAR_12 = VAR_0->VAR_12;

    VAR_15 = 1;

    VAR_16 = 0xFF;

    VAR_17 = HAVE_BIGENDIAN;



    switch (VAR_0->pix_fmt) {

    case AV_PIX_FMT_GRAY8:

        VAR_14 = SGI_SINGLE_CHAN;

        VAR_13     = SGI_GRAYSCALE;

        break;

    case AV_PIX_FMT_RGB24:

        VAR_14 = SGI_MULTI_CHAN;

        VAR_13     = SGI_RGB;

        break;

    case AV_PIX_FMT_RGBA:

        VAR_14 = SGI_MULTI_CHAN;

        VAR_13     = SGI_RGBA;

        break;

    case AV_PIX_FMT_GRAY16LE:

        VAR_17 = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_GRAY16BE:

        VAR_15 = 2;

        VAR_16 = 0xFFFF;

        VAR_14 = SGI_SINGLE_CHAN;

        VAR_13     = SGI_GRAYSCALE;

        break;

    case AV_PIX_FMT_RGB48LE:

        VAR_17 = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_RGB48BE:

        VAR_15 = 2;

        VAR_16 = 0xFFFF;

        VAR_14 = SGI_MULTI_CHAN;

        VAR_13     = SGI_RGB;

        break;

    case AV_PIX_FMT_RGBA64LE:

        VAR_17 = !HAVE_BIGENDIAN;

    case AV_PIX_FMT_RGBA64BE:

        VAR_15 = 2;

        VAR_16 = 0xFFFF;

        VAR_14 = SGI_MULTI_CHAN;

        VAR_13     = SGI_RGBA;

        break;

    default:

        return AVERROR_INVALIDDATA;

    }



    VAR_9 = VAR_13 * VAR_12 * 4;

    VAR_8 = SGI_HEADER_SIZE;

    if (!s->rle)

        VAR_8 += VAR_13 * VAR_12 * VAR_11;

    else 

        VAR_8 += VAR_9 * 2 + VAR_13 * VAR_12 * (2 * VAR_11 + 1);



    if ((VAR_10 = ff_alloc_packet(VAR_1, VAR_15 * VAR_8)) < 0) {

        av_log(VAR_0, AV_LOG_ERROR, "Error getting output packet of size %d.\n", VAR_8);

        return VAR_10;

    }



    bytestream2_init_writer(&pbc, VAR_1->data, VAR_1->size);



    

    bytestream2_put_be16(&pbc, SGI_MAGIC);

    bytestream2_put_byte(&pbc, s->rle); 

    bytestream2_put_byte(&pbc, VAR_15);

    bytestream2_put_be16(&pbc, VAR_14);

    bytestream2_put_be16(&pbc, VAR_11);

    bytestream2_put_be16(&pbc, VAR_12);

    bytestream2_put_be16(&pbc, VAR_13);



    bytestream2_put_be32(&pbc, 0L); 

    bytestream2_put_be32(&pbc, VAR_16);

    bytestream2_put_be32(&pbc, 0L); 



    

    bytestream2_skip_p(&pbc, 80);



    

    bytestream2_put_be32(&pbc, 0L);



    

    bytestream2_skip_p(&pbc, 404);



    if (s->rle) {

        PutByteContext taboff_pcb, tablen_pcb;



        

        bytestream2_init_writer(&taboff_pcb, pbc.buffer, VAR_9);

        bytestream2_skip_p(&pbc, VAR_9);



        

        bytestream2_init_writer(&tablen_pcb, pbc.buffer, VAR_9);

        bytestream2_skip_p(&pbc, VAR_9);



        

        if (!(encode_buf = av_malloc(VAR_11 * VAR_15)))

            return AVERROR(ENOMEM);



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

            in_buf = VAR_4->data[0] + VAR_4->linesize[0] * (VAR_12 - 1) + VAR_7 * VAR_15;



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

                bytestream2_put_be32(&taboff_pcb, bytestream2_tell_p(&pbc));



                for (VAR_5 = 0; VAR_5 < VAR_11 * VAR_15; VAR_5 += VAR_15)

                    encode_buf[VAR_5] = in_buf[VAR_13 * VAR_5];



                VAR_8 = sgi_rle_encode(&pbc, encode_buf, VAR_11,

                                        VAR_15);

                if (VAR_8 < 1) {

                    av_free(encode_buf);

                    return AVERROR_INVALIDDATA;

                }



                bytestream2_put_be32(&tablen_pcb, VAR_8);

                in_buf -= VAR_4->linesize[0];

            }

        }



        av_free(encode_buf);

    } else {

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

            in_buf = VAR_4->data[0] + VAR_4->linesize[0] * (VAR_12 - 1) + VAR_7 * VAR_15;



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

                for (VAR_5 = 0; VAR_5 < VAR_11 * VAR_13; VAR_5 += VAR_13)

                    if (VAR_15 == 1)

                        bytestream2_put_byte(&pbc, in_buf[VAR_5]);

                    else

                        if (VAR_17)

                            bytestream2_put_be16(&pbc, ((uint16_t *)in_buf)[VAR_5]);

                        else

                            bytestream2_put_le16(&pbc, ((uint16_t *)in_buf)[VAR_5]);



                in_buf -= VAR_4->linesize[0];

            }

        }

    }



    

    VAR_1->size   = bytestream2_tell_p(&pbc);

    VAR_1->flags |= AV_PKT_FLAG_KEY;

    *VAR_3 = 1;



    return 0;

}

static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,
const AVFrame *VAR_2, int *VAR_3)
{ SgiContext *s = VAR_0->priv_data; const AVFrame * const VAR_4 = VAR_2; PutByteContext pbc; uint8_t *in_buf, *encode_buf; int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9, VAR_10; unsigned int VAR_11, VAR_12, VAR_13, VAR_14; unsigned int VAR_15, VAR_16, VAR_17; #if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
VAR_0->coded_frame->pict_type = AV_PICTURE_TYPE_I; VAR_0->coded_frame->key_frame = 1; FF_ENABLE_DEPRECATION_WARNINGS
#endif
#if FF_API_CODER_TYPE
FF_DISABLE_DEPRECATION_WARNINGS
if (VAR_0->coder_type == FF_CODER_TYPE_RAW)
s->rle = 0; FF_ENABLE_DEPRECATION_WARNINGS
#endif
VAR_11  = VAR_0->VAR_11; VAR_12 = VAR_0->VAR_12; VAR_15 = 1; VAR_16 = 0xFF; VAR_17 = HAVE_BIGENDIAN; switch (VAR_0->pix_fmt) { case AV_PIX_FMT_GRAY8:
VAR_14 = SGI_SINGLE_CHAN; VAR_13     = SGI_GRAYSCALE; break; case AV_PIX_FMT_RGB24:
VAR_14 = SGI_MULTI_CHAN; VAR_13     = SGI_RGB; break; case AV_PIX_FMT_RGBA:
VAR_14 = SGI_MULTI_CHAN; VAR_13     = SGI_RGBA; break; case AV_PIX_FMT_GRAY16LE:
VAR_17 = !HAVE_BIGENDIAN; case AV_PIX_FMT_GRAY16BE:
VAR_15 = 2; VAR_16 = 0xFFFF; VAR_14 = SGI_SINGLE_CHAN; VAR_13     = SGI_GRAYSCALE; break; case AV_PIX_FMT_RGB48LE:
VAR_17 = !HAVE_BIGENDIAN; case AV_PIX_FMT_RGB48BE:
VAR_15 = 2; VAR_16 = 0xFFFF; VAR_14 = SGI_MULTI_CHAN; VAR_13     = SGI_RGB; break; case AV_PIX_FMT_RGBA64LE:
VAR_17 = !HAVE_BIGENDIAN; case AV_PIX_FMT_RGBA64BE:
VAR_15 = 2; VAR_16 = 0xFFFF; VAR_14 = SGI_MULTI_CHAN; VAR_13     = SGI_RGBA; break; default:
return AVERROR_INVALIDDATA; } VAR_9 = VAR_13 * VAR_12 * 4; VAR_8 = SGI_HEADER_SIZE; if (!s->rle)
VAR_8 += VAR_13 * VAR_12 * VAR_11; else
VAR_8 += VAR_9 * 2 + VAR_13 * VAR_12 * (2 * VAR_11 + 1); if ((VAR_10 = ff_alloc_packet(VAR_1, VAR_15 * VAR_8)) < 0) { av_log(VAR_0, AV_LOG_ERROR, "Error getting output packet of size %d.\n", VAR_8); return VAR_10; } bytestream2_init_writer(&pbc, VAR_1->data, VAR_1->size); bytestream2_put_be16(&pbc, SGI_MAGIC); bytestream2_put_byte(&pbc, s->rle); bytestream2_put_byte(&pbc, VAR_15); bytestream2_put_be16(&pbc, VAR_14); bytestream2_put_be16(&pbc, VAR_11); bytestream2_put_be16(&pbc, VAR_12); bytestream2_put_be16(&pbc, VAR_13); bytestream2_put_be32(&pbc, 0L); bytestream2_put_be32(&pbc, VAR_16); bytestream2_put_be32(&pbc, 0L); bytestream2_skip_p(&pbc, 80); bytestream2_put_be32(&pbc, 0L); bytestream2_skip_p(&pbc, 404); if (s->rle) { PutByteContext taboff_pcb, tablen_pcb; bytestream2_init_writer(&taboff_pcb, pbc.buffer, VAR_9); bytestream2_skip_p(&pbc, VAR_9); bytestream2_init_writer(&tablen_pcb, pbc.buffer, VAR_9); bytestream2_skip_p(&pbc, VAR_9); if (!(encode_buf = av_malloc(VAR_11 * VAR_15)))
return AVERROR(ENOMEM); for (VAR_7 = 0; VAR_7 < VAR_13; VAR_7++) { in_buf = VAR_4->data[0] + VAR_4->linesize[0] * (VAR_12 - 1) + VAR_7 * VAR_15; for (VAR_6 = 0; VAR_6 < VAR_12; VAR_6++) { bytestream2_put_be32(&taboff_pcb, bytestream2_tell_p(&pbc)); for (VAR_5 = 0; VAR_5 < VAR_11 * VAR_15; VAR_5 += VAR_15) encode_buf[VAR_5] = in_buf[VAR_13 * VAR_5]; VAR_8 = sgi_rle_encode(&pbc, encode_buf, VAR_11,
VAR_15); if (VAR_8 < 1) { av_free(encode_buf); return AVERROR_INVALIDDATA; } bytestream2_put_be32(&tablen_pcb, VAR_8); in_buf -= VAR_4->linesize[0]; } } av_free(encode_buf); } else { for (VAR_7 = 0; VAR_7 < VAR_13; VAR_7++) { in_buf = VAR_4->data[0] + VAR_4->linesize[0] * (VAR_12 - 1) + VAR_7 * VAR_15; for (VAR_6 = 0; VAR_6 < VAR_12; VAR_6++) { for (VAR_5 = 0; VAR_5 < VAR_11 * VAR_13; VAR_5 += VAR_13) if (VAR_15 == 1)
bytestream2_put_byte(&pbc, in_buf[VAR_5]); else
if (VAR_17)
bytestream2_put_be16(&pbc, ((uint16_t *)in_buf)[VAR_5]); else
bytestream2_put_le16(&pbc, ((uint16_t *)in_buf)[VAR_5]); in_buf -= VAR_4->linesize[0]; } } } VAR_1->size   = bytestream2_tell_p(&pbc); VAR_1->flags |= AV_PKT_FLAG_KEY; *VAR_3 = 1; return 0; }