/* ANM file replacement with VP8 video */

#define __STDC_FORMAT_MACROS
#define __STDC_LIMIT_MACROS


#include <stdint.h>

#include "compat.h"
#include "baselayer.h"
#include "build.h"
#include "glbuild.h"

#define VPX_CODEC_DISABLE_COMPAT 1
#include <vpx/vpx_decoder.h>
#include <vpx/vp8dx.h>

#include "duke3d.h"
#include "game.h"  // kopen4loadfrommod
#include "animvpx.h"

const char *animvpx_read_ivf_header_errmsg[] = {
    "All OK",
    "couldn't read 32-byte IVF header",
    "magic mismatch, not an IVF file",
    "unrecognized IVF version, expected 0",
    "only VP8 video stream supported",
    "invalid framerate numerator or denominator after correction, must not be 0",
};

int32_t animvpx_read_ivf_header(int32_t inhandle, animvpx_ivf_header_t *hdr)
{
    int32_t err;

    Bassert(sizeof(animvpx_ivf_header_t) == 32);

    if (kread(inhandle, hdr, sizeof(animvpx_ivf_header_t)) != sizeof(animvpx_ivf_header_t))
        return 1;  // "couldn't read header"

    err = animvpx_check_header(hdr);
    if (err)
        return err;

    hdr->hdrlen = B_LITTLE16(hdr->hdrlen);

    hdr->width = B_LITTLE16(hdr->width);
    hdr->height = B_LITTLE16(hdr->height);
    hdr->fpsnumer = B_LITTLE16(hdr->fpsnumer);
    hdr->fpsdenom = B_LITTLE16(hdr->fpsdenom);

    hdr->numframes = B_LITTLE32(hdr->numframes);

    // the rest is based on vpxdec.c --> file_is_ivf()

    if (hdr->fpsnumer < 1000)
    {
        // NOTE: We got rid of the 1/(2*fps) correction from libvpx's vpxdec.c,
        // users are encouraged to use the "ivfrate" utility from the source/
        // directory instead.

        if (hdr->fpsdenom==0 || hdr->fpsnumer==0)
            return 5;  // "invalid framerate numerator or denominator"

        initprintf("animvpx: rate is %d frames / %d seconds (%.03f fps).\n",
                   hdr->fpsnumer, hdr->fpsdenom, (double)hdr->fpsnumer/hdr->fpsdenom);
    }
    else
    {
        double fps = (hdr->fpsdenom==0) ? 0.0 : (double)hdr->fpsnumer/hdr->fpsdenom;

        initprintf("animvpx: set rate to 30 fps (header says %d frames / %d seconds = %.03f fps).\n",
                   hdr->fpsnumer, hdr->fpsdenom, fps);

        /* Don't know FPS for sure, and don't have readahead code
         * (yet?), so just default to 30fps.
         */
        hdr->fpsnumer = 30;
        hdr->fpsdenom = 1;
    }

    return 0;
}

////////// CODEC STUFF //////////
static void get_codec_error(animvpx_codec_ctx *codec)
{
    codec->errmsg_detail = vpx_codec_error_detail(&codec->codec);
    codec->errmsg = vpx_codec_error(&codec->codec);
}

// no checks for double-init!
int32_t animvpx_init_codec(const animvpx_ivf_header_t *info, int32_t inhandle, animvpx_codec_ctx *codec)
{
    vpx_codec_dec_cfg_t cfg;

    cfg.threads = 1;
    cfg.w = info->width;
    cfg.h = info->height;

    codec->width = info->width;
    codec->height = info->height;

    //
    codec->inhandle = inhandle;
    codec->pic = Bcalloc(info->width*info->height,4);

    codec->compbuflen = codec->compbufallocsiz = 0;
    codec->compbuf = NULL;

    codec->iter = NULL;

    if (codec->pic == NULL)
    {
        codec->initstate = -1;
        return 1;
    }

    if (vpx_codec_dec_init(&codec->codec, &vpx_codec_vp8_dx_algo, &cfg, 0))
    {
        get_codec_error(codec);
        codec->initstate = -1;
        return 1;
    }

    codec->initstate = 1;
    codec->decstate = 0;

    codec->errmsg_detail = codec->errmsg = NULL;

    codec->numframes = 0;
    Bmemset(codec->sumtimes, 0, sizeof(codec->sumtimes));
    Bmemset(codec->maxtimes, 0, sizeof(codec->maxtimes));

    return 0;
}

int32_t animvpx_uninit_codec(animvpx_codec_ctx *codec)
{
    if (codec->initstate <= 0)
        return 2;

    Bfree(codec->pic);
    codec->pic = NULL;

    if (vpx_codec_destroy(&codec->codec))
    {
        get_codec_error(codec);
        codec->initstate = -2;
        return 1;
    }

    codec->initstate = 0;

    return 0;
}

////////// FRAME RETRIEVAL //////////

// read one IVF/VP8 frame, which may code multiple "picture-frames"
static int32_t animvpx_read_frame(int32_t inhandle, uint8_t **bufptr, uint32_t *bufsizptr, uint32_t *bufallocsizptr)
{
#pragma pack(push,1)
    struct { uint32_t framesiz; uint64_t timestamp; } hdr;
#pragma pack(pop)

    if (kread(inhandle, &hdr, sizeof(hdr)) != sizeof(hdr))
        return 1;

    if (hdr.framesiz == 0)
        return 6;  // must be 6, see animvpx_nextpic_errmsg[]

//    OSD_Printf("frame size: %u\n", hdr.framesiz);

    if (!*bufptr)
    {
        *bufptr = Bmalloc(hdr.framesiz);
        if (!*bufptr)
            return 2;
        *bufallocsizptr = hdr.framesiz;
    }
    else if (*bufallocsizptr < hdr.framesiz)
    {
        *bufptr = Brealloc(*bufptr, hdr.framesiz);
        if (!*bufptr)
            return 2;
        *bufallocsizptr = hdr.framesiz;
    }

    *bufsizptr = hdr.framesiz;

    if (kread(inhandle, *bufptr, hdr.framesiz) != (signed)hdr.framesiz)
        return 3;

    return 0;
}

const char *animvpx_nextpic_errmsg[] = {
    "All OK",
    "INTERNAL ERROR, animvpx_codec_ctx not initalized!",
    "OUT OF MEMORY",
    "couldn't read whole frame",
    "decoder error, couldn't decode frame",
    "picture dimension mismatch",
    "INTERNAL ERROR: read 0 frame length",
    "Failed getting corruption status (VP8D_GET_FRAME_CORRUPTED)"
};

// retrieves one picture-frame from the stream
//  pic format:  lines of [Y U V 0] pixels
//  *picptr==NULL means EOF has been reached
#if !defined __clang__ && !defined USING_LTO
# ifdef DEBUGGINGAIDS
ATTRIBUTE((optimize("O1")))
# else
ATTRIBUTE((optimize("O3")))
# endif
#endif
int32_t animvpx_nextpic(animvpx_codec_ctx *codec, uint8_t **picptr)
{
    int32_t ret, corrupted;
    vpx_image_t *img;

    int32_t t[3];

    if (codec->initstate <= 0)  // not inited or error
        return 1;

    t[0] = getticks();

    if (codec->decstate == 0)  // first time / begin
    {
read_ivf_frame:
        corrupted = 0;

        ret = animvpx_read_frame(codec->inhandle, &codec->compbuf, &codec->compbuflen,
                                 &codec->compbufallocsiz);
        if (ret == 1)
        {
            // reached EOF
            *picptr = NULL;
            codec->decstate = 2;
            return 0;
        }
        else if (ret == 2 || ret == 3 || ret == 6)
        {
            *picptr = NULL;
            codec->decstate = -1;
            return ret;
        }
        // ^^^ keep in sync with all animvpx_read_frame() errors!

        // codec->compbuf now contains one IVF/VP8 frame
        codec->decstate = 1;

        // decode it!
        if (vpx_codec_decode(&codec->codec, codec->compbuf, codec->compbuflen, NULL, 0))
        {
            get_codec_error(codec);
            codec->decstate = -2;
            return 4;
        }

// Compilation fix for Debian 6.0 (squeeze), which doesn't have
// VP8D_GET_FRAME_CORRUPTED.
// LibVPX doesn't seem to have a version #define, so we use the
// following one to determine conditional compilation.
#ifdef VPX_CODEC_CAP_ERROR_CONCEALMENT
        if (vpx_codec_control(&codec->codec, VP8D_GET_FRAME_CORRUPTED, &corrupted))
        {
            get_codec_error(codec);
            codec->decstate = -2;
            return 7;
        }
#endif
        if (corrupted)
            OSD_Printf("warning: corrupted frame!\n");
    }

    img = vpx_codec_get_frame(&codec->codec, &codec->iter);
    if (img == NULL)
    {
        codec->iter = NULL;  // !
        goto read_ivf_frame;
    }

    if (img->d_w != codec->width || img->d_h != codec->height)
    {
        codec->decstate = -1;
        return 5;
    }

    t[1] = getticks();

    /*** 3 planes --> packed conversion ***/
    {
        uint8_t *const dstpic = codec->pic;

        const uint8_t *const yplane = img->planes[VPX_PLANE_Y];
        const uint8_t *const uplane = img->planes[VPX_PLANE_U];
        const uint8_t *const vplane = img->planes[VPX_PLANE_V];

        int32_t ystride = img->stride[VPX_PLANE_Y];
        int32_t ustride = img->stride[VPX_PLANE_U];
        int32_t vstride = img->stride[VPX_PLANE_V];

        int32_t x, y;
        const int32_t width=img->d_w, height = img->d_h;

        for (y=0; y<height; y+=2)
        {
            for (x=0; x<width; x+=2)
            {
                uint8_t u = uplane[ustride*(y>>1) + (x>>1)];
                uint8_t v = vplane[vstride*(y>>1) + (x>>1)];

                dstpic[(width*y + x)<<2] = yplane[ystride*y + x];
                dstpic[(width*y + x+1)<<2] = yplane[ystride*y + x+1];
                dstpic[(width*(y+1) + x)<<2] = yplane[ystride*(y+1) + x];
                dstpic[(width*(y+1) + x+1)<<2] = yplane[ystride*(y+1) + x+1];

                dstpic[((width*y + x)<<2) + 1] = u;
                dstpic[((width*y + x+1)<<2) + 1] = u;
                dstpic[((width*(y+1) + x)<<2) + 1] = u;
                dstpic[((width*(y+1) + x+1)<<2) + 1] = u;

                dstpic[((width*y + x)<<2) + 2] = v;
                dstpic[((width*y + x+1)<<2) + 2] = v;
                dstpic[((width*(y+1) + x)<<2) + 2] = v;
                dstpic[((width*(y+1) + x+1)<<2) + 2] = v;
            }
        }
    }

    t[2] = getticks();

    codec->sumtimes[0] += t[1]-t[0];
    codec->sumtimes[1] += t[2]-t[1];

    codec->maxtimes[0] = max(codec->maxtimes[0], t[1]-t[0]);
    codec->maxtimes[1] = max(codec->maxtimes[0], t[2]-t[1]);

    *picptr = codec->pic;
    return 0;
}


/////////////// DRAWING! ///////////////
static GLuint texname = 0;
static int32_t texuploaded;

// YUV->RGB conversion fragment shader adapted from
// http://www.fourcc.org/fccyvrgb.php: "Want some sample code?"
// direct link: http://www.fourcc.org/source/YUV420P-OpenGL-GLSLang.c
static char *fragprog_src =
    "#version 120\n"

    "uniform sampler2D tex;\n"

    "void main(void) {\n"

    "  float r,g,b,y,u,v;\n"
    "  vec3 yuv;\n"

    "  yuv = texture2D(tex, gl_TexCoord[0].st).rgb;\n"
    "  y = yuv.r;\n"
    "  u = yuv.g;\n"
    "  v = yuv.b;\n"

    "  y = 1.1643*(y-0.0625);\n"
    "  u = u-0.5;\n"
    "  v = v-0.5;\n"

    "  r = y + 1.5958*v;\n"
    "  g = y - 0.39173*u - 0.81290*v;\n"
    "  b = y + 2.017*u;\n"

    "  gl_FragColor = vec4(r,g,b,1.0);\n"
    "}\n";

void animvpx_setup_glstate(void)
{
    GLint gli;
    GLhandleARB FSHandle, PHandle;
    static char logbuf[512];

    // first, compile the fragment shader
    /* Set up program objects. */
    PHandle = bglCreateProgramObjectARB();
    FSHandle = bglCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

    /* Compile the shader. */
    bglShaderSourceARB(FSHandle, 1, (const GLcharARB **)&fragprog_src, NULL);
    bglCompileShaderARB(FSHandle);

    /* Print the compilation log. */
    bglGetObjectParameterivARB(FSHandle, GL_OBJECT_COMPILE_STATUS_ARB, &gli);
    bglGetInfoLogARB(FSHandle, sizeof(logbuf), NULL, logbuf);
    if (logbuf[0])
        OSD_Printf("animvpx compile log: %s\n", logbuf);

    /* Create a complete program object. */
    bglAttachObjectARB(PHandle, FSHandle);
    bglLinkProgramARB(PHandle);

    /* And print the link log. */
    bglGetInfoLogARB(PHandle, sizeof(logbuf), NULL, logbuf);
    if (logbuf[0])
        OSD_Printf("animvpx link log: %s\n", logbuf);

    /* Finally, use the program. */
    bglUseProgramObjectARB(PHandle);

    ////////// GL STATE //////////

    //Force fullscreen (glox1=-1 forces it to restore afterwards)
    bglViewport(0,0,xdim,ydim); glox1 = -1;

    bglMatrixMode(GL_MODELVIEW);
    bglLoadIdentity();

    bglMatrixMode(GL_PROJECTION);
    bglLoadIdentity();

    bglMatrixMode(GL_COLOR);
    bglLoadIdentity();

    bglMatrixMode(GL_TEXTURE);
    bglLoadIdentity();

    bglPushAttrib(GL_ENABLE_BIT);
    bglDisable(GL_ALPHA_TEST);
//    bglDisable(GL_LIGHTING);
    bglDisable(GL_DEPTH_TEST);
    bglDisable(GL_BLEND);
    bglDisable(GL_CULL_FACE);
//    bglDisable(GL_SCISSOR_TEST);
    bglEnable(GL_TEXTURE_2D);


    bglActiveTextureARB(GL_TEXTURE0_ARB);
    bglGenTextures(1, &texname);
//    gli = bglGetUniformLocationARB(PHandle,"tex");
//    bglUniform1iARB(gli,0);  // 0: texture unit
    bglBindTexture(GL_TEXTURE_2D, texname);

    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, glinfo.clamptoedge?GL_CLAMP_TO_EDGE:GL_CLAMP);
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, glinfo.clamptoedge?GL_CLAMP_TO_EDGE:GL_CLAMP);
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    bglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    texuploaded = 0;
    ////////////////////

    bglClearColor(0.0,0.0,0.0,1.0);
    bglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}

void animvpx_restore_glstate(void)
{
    bglUseProgramObjectARB(0);

    bglPopAttrib();

    bglDeleteTextures(1, &texname);
    texname = 0;
    texuploaded = 0;
}

int32_t animvpx_render_frame(animvpx_codec_ctx *codec)
{
    int32_t t = getticks();

    if (codec->initstate <= 0)  // not inited or error
        return 1;

    if (codec->pic == NULL)
        return 2;  // shouldn't happen

    if (!texuploaded)
    {
        bglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, codec->width,codec->height,
                     0, GL_RGBA, GL_UNSIGNED_BYTE, codec->pic);
        texuploaded = 1;
    }
    else
    {
        bglTexSubImage2D(GL_TEXTURE_2D, 0, 0,0, codec->width,codec->height,
                        GL_RGBA, GL_UNSIGNED_BYTE, codec->pic);
    }

    {
        float vid_wbyh = ((float)codec->width)/codec->height;
        float scr_wbyh = ((float)xdim)/ydim;

        float x=1.0, y=1.0;
#if 1
        // aspect correction by pillarboxing/letterboxing
        // TODO: fullscreen? can't assume square pixels there
        if (vid_wbyh != scr_wbyh)
        {
            if (vid_wbyh < scr_wbyh)
                x = vid_wbyh/scr_wbyh;
            else
                y = scr_wbyh/vid_wbyh;
        }
#endif
        bglBegin(GL_QUADS);

        bglTexCoord2f(0.0,1.0);
        bglVertex3f(-x, -y, 0.0);

        bglTexCoord2f(0.0,0.0);
        bglVertex3f(-x, y, 0.0);

        bglTexCoord2f(1.0,0.0);
        bglVertex3f(x, y, 0.0);

        bglTexCoord2f(1.0,1.0);
        bglVertex3f(x, -y, 0.0);

        bglEnd();
    }

    t = getticks()-t;
    codec->sumtimes[2] += t;
    codec->maxtimes[2] = max(codec->maxtimes[2], t);
    codec->numframes++;

    return 0;
}

void animvpx_print_stats(const animvpx_codec_ctx *codec)
{
    if (codec->numframes != 0)
    {
        const int32_t *s = codec->sumtimes;
        const int32_t *m = codec->maxtimes;
        int32_t n = codec->numframes;

        initprintf("VP8 timing stats (mean, max) [ms] for %d frames:\n"
                   " read and decode frame: %.02f, %d\n"
                   " 3 planes -> packed conversion: %.02f, %d\n"
                   " upload and display: %.02f, %d\n",
                   n, (double)s[0]/n, m[0], (double)s[1]/n, m[1], (double)s[2]/n, m[2]);
    }
}