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

                            AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    TXDContext * const s = avctx->priv_data;

    AVFrame *picture = data;

    AVFrame * const p = &s->picture;

    unsigned int version, w, h, d3d_format, depth, stride, mipmap_count, flags;

    unsigned int y, v;

    uint8_t *ptr;

    const uint8_t *cur = buf;

    const uint32_t *palette = (const uint32_t *)(cur + 88);

    uint32_t *pal;



    version         = AV_RL32(cur);

    d3d_format      = AV_RL32(cur+76);

    w               = AV_RL16(cur+80);

    h               = AV_RL16(cur+82);

    depth           = AV_RL8 (cur+84);

    mipmap_count    = AV_RL8 (cur+85);

    flags           = AV_RL8 (cur+87);

    cur            += 92;



    if (version < 8 || version > 9) {

        av_log(avctx, AV_LOG_ERROR, "texture data version %i is unsupported\n",

                                                                    version);

        return -1;

    }



    if (depth == 8) {

        avctx->pix_fmt = PIX_FMT_PAL8;

        cur += 1024;

    } else if (depth == 16 || depth == 32)

        avctx->pix_fmt = PIX_FMT_RGB32;

    else {

        av_log(avctx, AV_LOG_ERROR, "depth of %i is unsupported\n", depth);

        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;



    ptr    = p->data[0];

    stride = p->linesize[0];



    if (depth == 8) {

        pal = (uint32_t *) p->data[1];

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

            v = AV_RB32(palette+y);

            pal[y] = (v>>8) + (v<<24);

        }

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

            memcpy(ptr, cur, w);

            ptr += stride;

            cur += w;

        }

    } else if (depth == 16) {

        switch (d3d_format) {

        case 0:

            if (!(flags & 1))

                goto unsupported;

        case FF_S3TC_DXT1:

            ff_decode_dxt1(cur, ptr, w, h, stride);

            break;

        case FF_S3TC_DXT3:

            ff_decode_dxt3(cur, ptr, w, h, stride);

            break;

        default:

            goto unsupported;

        }

    } else if (depth == 32) {

        switch (d3d_format) {

        case 0x15:

        case 0x16:

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

                memcpy(ptr, cur, w*4);

                ptr += stride;

                cur += w*4;

            }

            break;

        default:

            goto unsupported;

        }

    }



    for (; mipmap_count > 1; mipmap_count--)

        cur += AV_RL32(cur) + 4;



    *picture   = s->picture;

    *data_size = sizeof(AVPicture);



    return cur - buf;



unsupported:

    av_log(avctx, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", d3d_format);

    return -1;

}

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

                            AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    TXDContext * const s = avctx->priv_data;

    AVFrame *picture = data;

    AVFrame * const p = &s->picture;

    unsigned int version, w, h, d3d_format, depth, stride, mipmap_count, flags;

    unsigned int y, v;

    uint8_t *ptr;

    const uint8_t *cur = buf;

    const uint32_t *palette = (const uint32_t *)(cur + 88);

    uint32_t *pal;



    version         = AV_RL32(cur);

    d3d_format      = AV_RL32(cur+76);

    w               = AV_RL16(cur+80);

    h               = AV_RL16(cur+82);

    depth           = AV_RL8 (cur+84);

    mipmap_count    = AV_RL8 (cur+85);

    flags           = AV_RL8 (cur+87);

    cur            += 92;



    if (version < 8 || version > 9) {

        av_log(avctx, AV_LOG_ERROR, "texture data version %i is unsupported\n",

                                                                    version);

        return -1;

    }



    if (depth == 8) {

        avctx->pix_fmt = PIX_FMT_PAL8;

        cur += 1024;

    } else if (depth == 16 || depth == 32)

        avctx->pix_fmt = PIX_FMT_RGB32;

    else {

        av_log(avctx, AV_LOG_ERROR, "depth of %i is unsupported\n", depth);

        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;



    ptr    = p->data[0];

    stride = p->linesize[0];



    if (depth == 8) {

        pal = (uint32_t *) p->data[1];

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

            v = AV_RB32(palette+y);

            pal[y] = (v>>8) + (v<<24);

        }

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

            memcpy(ptr, cur, w);

            ptr += stride;

            cur += w;

        }

    } else if (depth == 16) {

        switch (d3d_format) {

        case 0:

            if (!(flags & 1))

                goto unsupported;

        case FF_S3TC_DXT1:

            ff_decode_dxt1(cur, ptr, w, h, stride);

            break;

        case FF_S3TC_DXT3:

            ff_decode_dxt3(cur, ptr, w, h, stride);

            break;

        default:

            goto unsupported;

        }

    } else if (depth == 32) {

        switch (d3d_format) {

        case 0x15:

        case 0x16:

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

                memcpy(ptr, cur, w*4);

                ptr += stride;

                cur += w*4;

            }

            break;

        default:

            goto unsupported;

        }

    }



    for (; mipmap_count > 1; mipmap_count--)

        cur += AV_RL32(cur) + 4;



    *picture   = s->picture;

    *data_size = sizeof(AVPicture);



    return cur - buf;



unsupported:

    av_log(avctx, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", d3d_format);

    return -1;

}

    const uint8_t *buf = avpkt->data;     const uint8_t *cur = buf;     const uint32_t *palette = (const uint32_t *)(cur + 88);     version         = AV_RL32(cur);     d3d_format      = AV_RL32(cur+76);     w               = AV_RL16(cur+80);     h               = AV_RL16(cur+82);     depth           = AV_RL8 (cur+84);     mipmap_count    = AV_RL8 (cur+85);     flags           = AV_RL8 (cur+87);     cur            += 92;         cur += 1024;     } else if (depth == 16 || depth == 32)     else {         for (y=0; y<256; y++) {             v = AV_RB32(palette+y);             pal[y] = (v>>8) + (v<<24);             memcpy(ptr, cur, w);             cur += w;             ff_decode_dxt1(cur, ptr, w, h, stride);             ff_decode_dxt3(cur, ptr, w, h, stride);                 memcpy(ptr, cur, w*4);                 cur += w*4;     for (; mipmap_count > 1; mipmap_count--)         cur += AV_RL32(cur) + 4;     return cur - buf;
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;

    TXDContext * 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;

    unsigned int VAR_13, VAR_14;

    uint8_t *ptr;

    const uint8_t *VAR_15 = VAR_4;

    const uint32_t *VAR_16 = (const uint32_t *)(VAR_15 + 88);

    uint32_t *pal;



    VAR_5         = AV_RL32(VAR_15);

    VAR_8      = AV_RL32(VAR_15+76);

    VAR_6               = AV_RL16(VAR_15+80);

    VAR_7               = AV_RL16(VAR_15+82);

    VAR_9           = AV_RL8 (VAR_15+84);

    VAR_11    = AV_RL8 (VAR_15+85);

    VAR_12           = AV_RL8 (VAR_15+87);

    VAR_15            += 92;



    if (VAR_5 < 8 || VAR_5 > 9) {

        av_log(VAR_0, AV_LOG_ERROR, "texture VAR_1 VAR_5 %i is unsupported\n",

                                                                    VAR_5);

        return -1;

    }



    if (VAR_9 == 8) {

        VAR_0->pix_fmt = PIX_FMT_PAL8;

        VAR_15 += 1024;

    } else if (VAR_9 == 16 || VAR_9 == 32)

        VAR_0->pix_fmt = PIX_FMT_RGB32;

    else {

        av_log(VAR_0, AV_LOG_ERROR, "VAR_9 of %i is unsupported\n", VAR_9);

        return -1;

    }



    if (p->VAR_1[0])

        VAR_0->release_buffer(VAR_0, p);



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

        return -1;

    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;



    ptr    = p->VAR_1[0];

    VAR_10 = p->linesize[0];



    if (VAR_9 == 8) {

        pal = (uint32_t *) p->VAR_1[1];

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

            VAR_14 = AV_RB32(VAR_16+VAR_13);

            pal[VAR_13] = (VAR_14>>8) + (VAR_14<<24);

        }

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

            memcpy(ptr, VAR_15, VAR_6);

            ptr += VAR_10;

            VAR_15 += VAR_6;

        }

    } else if (VAR_9 == 16) {

        switch (VAR_8) {

        case 0:

            if (!(VAR_12 & 1))

                goto unsupported;

        case FF_S3TC_DXT1:

            ff_decode_dxt1(VAR_15, ptr, VAR_6, VAR_7, VAR_10);

            break;

        case FF_S3TC_DXT3:

            ff_decode_dxt3(VAR_15, ptr, VAR_6, VAR_7, VAR_10);

            break;

        default:

            goto unsupported;

        }

    } else if (VAR_9 == 32) {

        switch (VAR_8) {

        case 0x15:

        case 0x16:

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

                memcpy(ptr, VAR_15, VAR_6*4);

                ptr += VAR_10;

                VAR_15 += VAR_6*4;

            }

            break;

        default:

            goto unsupported;

        }

    }



    for (; VAR_11 > 1; VAR_11--)

        VAR_15 += AV_RL32(VAR_15) + 4;



    *picture   = s->picture;

    *VAR_2 = sizeof(AVPicture);



    return VAR_15 - VAR_4;



unsupported:

    av_log(VAR_0, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", VAR_8);

    return -1;

}

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; TXDContext * 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; unsigned int VAR_13, VAR_14; uint8_t *ptr; const uint8_t *VAR_15 = VAR_4; const uint32_t *VAR_16 = (const uint32_t *)(VAR_15 + 88); uint32_t *pal; VAR_5         = AV_RL32(VAR_15); VAR_8      = AV_RL32(VAR_15+76); VAR_6               = AV_RL16(VAR_15+80); VAR_7               = AV_RL16(VAR_15+82); VAR_9           = AV_RL8 (VAR_15+84); VAR_11    = AV_RL8 (VAR_15+85); VAR_12           = AV_RL8 (VAR_15+87); VAR_15            += 92; if (VAR_5 < 8 || VAR_5 > 9) { av_log(VAR_0, AV_LOG_ERROR, "texture VAR_1 VAR_5 %i is unsupported\n",
VAR_5); return -1; } if (VAR_9 == 8) { VAR_0->pix_fmt = PIX_FMT_PAL8; VAR_15 += 1024; } else if (VAR_9 == 16 || VAR_9 == 32) VAR_0->pix_fmt = PIX_FMT_RGB32; else { av_log(VAR_0, AV_LOG_ERROR, "VAR_9 of %i is unsupported\n", VAR_9); return -1; } if (p->VAR_1[0])
VAR_0->release_buffer(VAR_0, p); if (av_image_check_size(VAR_6, VAR_7, 0, VAR_0))
return -1; 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; ptr    = p->VAR_1[0]; VAR_10 = p->linesize[0]; if (VAR_9 == 8) { pal = (uint32_t *) p->VAR_1[1]; for (VAR_13=0; VAR_13<256; VAR_13++) { VAR_14 = AV_RB32(VAR_16+VAR_13); pal[VAR_13] = (VAR_14>>8) + (VAR_14<<24); } for (VAR_13=0; VAR_13<VAR_7; VAR_13++) { memcpy(ptr, VAR_15, VAR_6); ptr += VAR_10; VAR_15 += VAR_6; } } else if (VAR_9 == 16) { switch (VAR_8) { case 0:
if (!(VAR_12 & 1))
goto unsupported; case FF_S3TC_DXT1:
ff_decode_dxt1(VAR_15, ptr, VAR_6, VAR_7, VAR_10); break; case FF_S3TC_DXT3:
ff_decode_dxt3(VAR_15, ptr, VAR_6, VAR_7, VAR_10); break; default:
goto unsupported; } } else if (VAR_9 == 32) { switch (VAR_8) { case 0x15:
case 0x16:
for (VAR_13=0; VAR_13<VAR_7; VAR_13++) { memcpy(ptr, VAR_15, VAR_6*4); ptr += VAR_10; VAR_15 += VAR_6*4; } break; default:
goto unsupported; } } for (; VAR_11 > 1; VAR_11--) VAR_15 += AV_RL32(VAR_15) + 4; *picture   = s->picture; *VAR_2 = sizeof(AVPicture); return VAR_15 - VAR_4; unsupported:
av_log(VAR_0, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", VAR_8); return -1; }