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

                              const AVFrame *p, int *got_packet)

{

    TargaContext *s = avctx->priv_data;

    int bpp, picsize, datasize = -1, ret;

    uint8_t *out;



    if(avctx->width > 0xffff || avctx->height > 0xffff) {

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

        return AVERROR(EINVAL);

    }

    picsize = av_image_get_buffer_size(avctx->pix_fmt,

                                       avctx->width, avctx->height, 1);

    if ((ret = ff_alloc_packet(pkt, picsize + 45)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n");

        return ret;

    }



    /* zero out the header and only set applicable fields */

    memset(pkt->data, 0, 12);

    AV_WL16(pkt->data+12, avctx->width);

    AV_WL16(pkt->data+14, avctx->height);

    /* image descriptor byte: origin is always top-left, bits 0-3 specify alpha */

    pkt->data[17] = 0x20 | (avctx->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0);



    switch(avctx->pix_fmt) {

    case AV_PIX_FMT_GRAY8:

        pkt->data[2]  = TGA_BW;     /* uncompressed grayscale image */

        pkt->data[16] = 8;          /* bpp */

        break;

    case AV_PIX_FMT_RGB555LE:

        pkt->data[2]  = TGA_RGB;    /* uncompresses true-color image */

        pkt->data[16] = 16;         /* bpp */

        break;

    case AV_PIX_FMT_BGR24:

        pkt->data[2]  = TGA_RGB;    /* uncompressed true-color image */

        pkt->data[16] = 24;         /* bpp */

        break;

    case AV_PIX_FMT_BGRA:

        pkt->data[2]  = TGA_RGB;    /* uncompressed true-color image */

        pkt->data[16] = 32;         /* bpp */

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",

               av_get_pix_fmt_name(avctx->pix_fmt));

        return AVERROR(EINVAL);

    }

    bpp = pkt->data[16] >> 3;



    out = pkt->data + 18;  /* skip past the header we just output */



#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



    /* try RLE compression */

    if (s->rle)

        datasize = targa_encode_rle(out, picsize, p, bpp, avctx->width, avctx->height);



    /* if that worked well, mark the picture as RLE compressed */

    if(datasize >= 0)

        pkt->data[2] |= 8;



    /* if RLE didn't make it smaller, go back to no compression */

    else datasize = targa_encode_normal(out, p, bpp, avctx->width, avctx->height);



    out += datasize;



    /* The standard recommends including this section, even if we don't use

     * any of the features it affords. TODO: take advantage of the pixel

     * aspect ratio and encoder ID fields available? */

    memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);



    pkt->size   = out + 26 - pkt->data;

    pkt->flags |= AV_PKT_FLAG_KEY;

    *got_packet = 1;



    return 0;

}

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

                              const AVFrame *p, int *got_packet)

{

    TargaContext *s = avctx->priv_data;

    int bpp, picsize, datasize = -1, ret;

    uint8_t *out;



    if(avctx->width > 0xffff || avctx->height > 0xffff) {

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

        return AVERROR(EINVAL);

    }

    picsize = av_image_get_buffer_size(avctx->pix_fmt,

                                       avctx->width, avctx->height, 1);

    if ((ret = ff_alloc_packet(pkt, picsize + 45)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n");

        return ret;

    }



    

    memset(pkt->data, 0, 12);

    AV_WL16(pkt->data+12, avctx->width);

    AV_WL16(pkt->data+14, avctx->height);

    

    pkt->data[17] = 0x20 | (avctx->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0);



    switch(avctx->pix_fmt) {

    case AV_PIX_FMT_GRAY8:

        pkt->data[2]  = TGA_BW;     

        pkt->data[16] = 8;          

        break;

    case AV_PIX_FMT_RGB555LE:

        pkt->data[2]  = TGA_RGB;    

        pkt->data[16] = 16;         

        break;

    case AV_PIX_FMT_BGR24:

        pkt->data[2]  = TGA_RGB;    

        pkt->data[16] = 24;         

        break;

    case AV_PIX_FMT_BGRA:

        pkt->data[2]  = TGA_RGB;    

        pkt->data[16] = 32;         

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",

               av_get_pix_fmt_name(avctx->pix_fmt));

        return AVERROR(EINVAL);

    }

    bpp = pkt->data[16] >> 3;



    out = pkt->data + 18;  



#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



    

    if (s->rle)

        datasize = targa_encode_rle(out, picsize, p, bpp, avctx->width, avctx->height);



    

    if(datasize >= 0)

        pkt->data[2] |= 8;



    

    else datasize = targa_encode_normal(out, p, bpp, avctx->width, avctx->height);



    out += datasize;



    





    memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);



    pkt->size   = out + 26 - pkt->data;

    pkt->flags |= AV_PKT_FLAG_KEY;

    *got_packet = 1;



    return 0;

}

    if(avctx->width > 0xffff || avctx->height > 0xffff) {         av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n");         return AVERROR(EINVAL);
static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,

                              const AVFrame *VAR_2, int *VAR_3)

{

    TargaContext *s = VAR_0->priv_data;

    int VAR_4, VAR_5, VAR_6 = -1, VAR_7;

    uint8_t *out;



    if(VAR_0->width > 0xffff || VAR_0->height > 0xffff) {

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

        return AVERROR(EINVAL);

    }

    VAR_5 = av_image_get_buffer_size(VAR_0->pix_fmt,

                                       VAR_0->width, VAR_0->height, 1);

    if ((VAR_7 = ff_alloc_packet(VAR_1, VAR_5 + 45)) < 0) {

        av_log(VAR_0, AV_LOG_ERROR, "encoded frame too large\n");

        return VAR_7;

    }



    

    memset(VAR_1->data, 0, 12);

    AV_WL16(VAR_1->data+12, VAR_0->width);

    AV_WL16(VAR_1->data+14, VAR_0->height);

    

    VAR_1->data[17] = 0x20 | (VAR_0->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0);



    switch(VAR_0->pix_fmt) {

    case AV_PIX_FMT_GRAY8:

        VAR_1->data[2]  = TGA_BW;     

        VAR_1->data[16] = 8;          

        break;

    case AV_PIX_FMT_RGB555LE:

        VAR_1->data[2]  = TGA_RGB;    

        VAR_1->data[16] = 16;         

        break;

    case AV_PIX_FMT_BGR24:

        VAR_1->data[2]  = TGA_RGB;    

        VAR_1->data[16] = 24;         

        break;

    case AV_PIX_FMT_BGRA:

        VAR_1->data[2]  = TGA_RGB;    

        VAR_1->data[16] = 32;         

        break;

    default:

        av_log(VAR_0, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",

               av_get_pix_fmt_name(VAR_0->pix_fmt));

        return AVERROR(EINVAL);

    }

    VAR_4 = VAR_1->data[16] >> 3;



    out = VAR_1->data + 18;  



#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



    

    if (s->rle)

        VAR_6 = targa_encode_rle(out, VAR_5, VAR_2, VAR_4, VAR_0->width, VAR_0->height);



    

    if(VAR_6 >= 0)

        VAR_1->data[2] |= 8;



    

    else VAR_6 = targa_encode_normal(out, VAR_2, VAR_4, VAR_0->width, VAR_0->height);



    out += VAR_6;



    





    memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);



    VAR_1->size   = out + 26 - VAR_1->data;

    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)
{ TargaContext *s = VAR_0->priv_data; int VAR_4, VAR_5, VAR_6 = -1, VAR_7; uint8_t *out; if(VAR_0->width > 0xffff || VAR_0->height > 0xffff) { av_log(VAR_0, AV_LOG_ERROR, "image dimensions too large\n"); return AVERROR(EINVAL); } VAR_5 = av_image_get_buffer_size(VAR_0->pix_fmt,
VAR_0->width, VAR_0->height, 1); if ((VAR_7 = ff_alloc_packet(VAR_1, VAR_5 + 45)) < 0) { av_log(VAR_0, AV_LOG_ERROR, "encoded frame too large\n"); return VAR_7; } memset(VAR_1->data, 0, 12); AV_WL16(VAR_1->data+12, VAR_0->width); AV_WL16(VAR_1->data+14, VAR_0->height); VAR_1->data[17] = 0x20 | (VAR_0->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0); switch(VAR_0->pix_fmt) { case AV_PIX_FMT_GRAY8:
VAR_1->data[2]  = TGA_BW; VAR_1->data[16] = 8; break; case AV_PIX_FMT_RGB555LE:
VAR_1->data[2]  = TGA_RGB; VAR_1->data[16] = 16; break; case AV_PIX_FMT_BGR24:
VAR_1->data[2]  = TGA_RGB; VAR_1->data[16] = 24; break; case AV_PIX_FMT_BGRA:
VAR_1->data[2]  = TGA_RGB; VAR_1->data[16] = 32; break; default:
av_log(VAR_0, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",
av_get_pix_fmt_name(VAR_0->pix_fmt)); return AVERROR(EINVAL); } VAR_4 = VAR_1->data[16] >> 3; out = VAR_1->data + 18; #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
if (s->rle)
VAR_6 = targa_encode_rle(out, VAR_5, VAR_2, VAR_4, VAR_0->width, VAR_0->height); if(VAR_6 >= 0)
VAR_1->data[2] |= 8; else VAR_6 = targa_encode_normal(out, VAR_2, VAR_4, VAR_0->width, VAR_0->height); out += VAR_6; memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26); VAR_1->size   = out + 26 - VAR_1->data; VAR_1->flags |= AV_PKT_FLAG_KEY; *VAR_3 = 1; return 0; }