// shader
#define SHADER_LENGTH 10000

#ifdef CUVID
const char *gl_version = "#version 330";
#else
#ifdef RASPI
const char *gl_version = "#version 300 es";
#else
const char *gl_version = "#version 300 es ";
#endif
#endif


/* Color conversion matrix: RGB = m * YUV + c
 * m is in row-major matrix, with m[row][col], e.g.:
 *     [ a11 a12 a13 ]     float m[3][3] = { { a11, a12, a13 },
 *     [ a21 a22 a23 ]                       { a21, a22, a23 },
 *     [ a31 a32 a33 ]                       { a31, a32, a33 } };
 * This is accessed as e.g.: m[2-1][1-1] = a21
 * In particular, each row contains all the coefficients for one of R, G, B,
 * while each column contains all the coefficients for one of Y, U, V:
 *     m[r,g,b][y,u,v] = ...
 * The matrix could also be viewed as group of 3 vectors, e.g. the 1st column
 * is the Y vector (1, 1, 1), the 2nd is the U vector, the 3rd the V vector.
 * The matrix might also be used for other conversions and colorspaces.
 */
struct mp_cmat
{
    GLfloat m[3][3];                    // colormatrix
    GLfloat c[3];                       //colormatrix_c
};

struct mp_mat
{
    GLfloat m[3][3];
};

// YUV input limited range (16-235 for luma, 16-240 for chroma)
// ITU-R BT.601 (SD)
struct mp_cmat yuv_bt601 = { {{1.164384, 1.164384, 1.164384},
    {0.00000, -0.391762, 2.017232},
    {1.596027, -0.812968, 0.000000}},
{-0.874202, 0.531668, -1.085631}
};

// ITU-R BT.709 (HD)
struct mp_cmat yuv_bt709 = { {{1.164384, 1.164384, 1.164384},
    {0.00000, -0.213249, 2.112402},
    {1.792741, -0.532909, 0.000000}},
{-0.972945, 0.301483, -1.133402}
};

// ITU-R BT.2020 non-constant luminance system
struct mp_cmat yuv_bt2020ncl = { {{1.164384, 1.164384, 1.164384},
    {0.00000, -0.187326, 2.141772},
    {1.678674, -0.650424, 0.000000}},
{-0.915688, 0.347459, -1.148145}
};

// ITU-R BT.2020 constant luminance system
struct mp_cmat yuv_bt2020cl = { {{0.0000, 1.164384, 0.000000},
    {0.00000, 0.000000, 1.138393},
    {1.138393, 0.000000, 0.000000}},
{-0.571429, -0.073059, -0.571429}
};

float cms_matrix[3][3] = { {1.660497, -0.124547, -0.018154},
{-0.587657, 1.132895, -0.100597},
{-0.072840, -0.008348, 1.118751}
};

// Common constants for SMPTE ST.2084 (PQ)
static const float PQ_M1 = 2610./4096 * 1./4,
                   PQ_M2 = 2523./4096 * 128,
                   PQ_C1 = 3424./4096,
                   PQ_C2 = 2413./4096 * 32,
                   PQ_C3 = 2392./4096 * 32;

// Common constants for ARIB STD-B67 (HLG)
static const float HLG_A = 0.17883277,
                   HLG_B = 0.28466892,
                   HLG_C = 0.55991073;

struct gl_vao_entry
{
    // used for shader / glBindAttribLocation
    const char *name;
    // glVertexAttribPointer() arguments
    int num_elems;                      // size (number of elements)
    GLenum type;
    bool normalized;
    int offset;
};

struct vertex_pt
{
    float x, y;
};

struct vertex_pi
{
    GLint x, y;
};

#define TEXUNIT_VIDEO_NUM 6

struct vertex
{
    struct vertex_pt position;
    struct vertex_pt texcoord[TEXUNIT_VIDEO_NUM];
};

static const struct gl_vao_entry vertex_vao[] = {
    {"position", 2, GL_FLOAT, false, offsetof(struct vertex, position)},
    {"texcoord0", 2, GL_FLOAT, false, offsetof(struct vertex, texcoord[0])},
    {"texcoord1", 2, GL_FLOAT, false, offsetof(struct vertex, texcoord[1])},
    {0}
};

#define GLSL(...)  pl_shader_append(__VA_ARGS__)
#define GLSLV(...)  pl_shader_append_v(__VA_ARGS__)

char sh[SHADER_LENGTH];
char shv[SHADER_LENGTH];

GL_init() {
	sh[0] = 0;
}
GLV_init() {
	shv[0] = 0;
}
pl_shader_append(const char *fmt, ...) {
	char temp[1000];
	va_list ap;
	
    va_start(ap, fmt);
	vsprintf(temp,fmt,ap);
	va_end(ap);
	
	if (strlen(sh) + strlen(temp) > SHADER_LENGTH)
		Fatal(_("Shaderlenght fault\n"));
	strcat(sh,temp);

}

pl_shader_append_v(const char *fmt, ...) {
	char temp[1000];
	va_list ap;
	
    va_start(ap, fmt);
	vsprintf(temp,fmt,ap);
	va_end(ap);
	
	if (strlen(shv) + strlen(temp) > SHADER_LENGTH)
		Fatal(_("Shaderlenght fault\n"));
	strcat(shv,temp);

}
static void compile_attach_shader(GLuint program, GLenum type, const char *source)
{
    GLuint shader;
    GLint status=1234, log_length;
    char log[4000];
    GLsizei len;

    shader = glCreateShader(type);
    glShaderSource(shader, 1, (const GLchar **)&source, NULL); // &buffer, NULL);
    glCompileShader(shader);
    status = 0;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    log_length = 0;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
    glGetShaderInfoLog(shader, 4000, &len, log);
    GlxCheck();
    Debug(3, "compile Status %d loglen %d >%s<\n", status, log_length, log);

    glAttachShader(program, shader);
    glDeleteShader(shader);

}

static void link_shader(GLuint program)
{
    GLint status, log_length;

    glLinkProgram(program);
    status = 0;
    glGetProgramiv(program, GL_LINK_STATUS, &status);
    log_length = 0;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
    Debug(3, "Link Status %d loglen %d\n", status, log_length);
}

static GLuint sc_generate_osd(GLuint gl_prog)
{

    Debug(3, "vor create osd\n");
    gl_prog = glCreateProgram();

	GL_init();
	GLSL("%s\n",gl_version);
	GLSL("in vec2 vertex_position;\n");
	GLSL("in vec2 vertex_texcoord0;\n");
	GLSL("out vec2 texcoord0;\n");
	GLSL("void main() {\n");
	GLSL("gl_Position = vec4(vertex_position, 1.0, 1.0);\n");
	GLSL("texcoord0 = vertex_texcoord0;\n");
	GLSL("}\n");
		
    Debug(3, "vor compile vertex osd\n");
    compile_attach_shader(gl_prog, GL_VERTEX_SHADER, sh); // vertex_osd);
	GL_init();	
	GLSL("%s\n",gl_version);
	GLSL("#define texture1D texture\n");
	GLSL("precision mediump float; \n");
	GLSL("layout(location = 0) out vec4 out_color;\n");
	GLSL("in vec2 texcoord0;\n");
	GLSL("uniform sampler2D texture0;\n");
	GLSL("void main() {\n");
	GLSL("vec4 color; \n");
	GLSL("color = vec4(texture(texture0, texcoord0));\n");
#ifdef GAMMA
		GLSL("// delinearize gamma                     \n");
		GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);  \n");    // delinearize gamma
		GLSL("color.rgb = pow(color.rgb, vec3(2.4));   \n");
#endif
	GLSL("out_color = color;\n");
	GLSL("}\n");
    Debug(3, "vor compile fragment osd \n");
    compile_attach_shader(gl_prog, GL_FRAGMENT_SHADER, sh); //fragment_osd);
    glBindAttribLocation(gl_prog, 0, "vertex_position");
    glBindAttribLocation(gl_prog, 1, "vertex_texcoord0");

    link_shader(gl_prog);
	
    return gl_prog;
}

static GLuint sc_generate(GLuint gl_prog, enum AVColorSpace colorspace)
{

    char vname[80];
    int n;
    GLint cmsLoc;
    float *m, *c, *cms;
    char *frag;
	
	GL_init();
	GLSL("%s\n",gl_version);
	GLSL("in vec2 vertex_position;      \n");
	GLSL("in vec2 vertex_texcoord0;     \n");
	GLSL("out vec2 texcoord0;           \n");
	GLSL("in vec2 vertex_texcoord1;     \n");
	GLSL("out vec2 texcoord1;           \n");
	if (Planes == 3) {
		GLSL("in vec2 vertex_texcoord2; \n");
		GLSL("out vec2 texcoord2;       \n");	
	}
	GLSL("void main() {                 \n");
	GLSL("gl_Position = vec4(vertex_position, 1.0, 1.0);\n");
	GLSL("texcoord0 = vertex_texcoord0; \n");
	GLSL("texcoord1 = vertex_texcoord1; \n");
	if (Planes == 3) {
		GLSL("texcoord2 = vertex_texcoord1; \n");  // texcoord1 ist hier richtig
	}
	GLSL("}                             \n");
	
    Debug(3, "vor create\n");
    gl_prog = glCreateProgram();
    Debug(3, "vor compile vertex\n");
//	printf("%s",sh);
    compile_attach_shader(gl_prog, GL_VERTEX_SHADER, sh ); 
	
	
    switch (colorspace) {
        case AVCOL_SPC_RGB:
            m = &yuv_bt601.m[0][0];
            c = &yuv_bt601.c[0];
            Debug(3, "BT601 Colorspace used\n");
            break;
        case AVCOL_SPC_BT709:
        case AVCOL_SPC_UNSPECIFIED:    //  comes with UHD
            m = &yuv_bt709.m[0][0];
            c = &yuv_bt709.c[0];
            Debug(3, "BT709 Colorspace used\n");
            break;
        case AVCOL_SPC_BT2020_NCL:
            m = &yuv_bt2020ncl.m[0][0];
            c = &yuv_bt2020ncl.c[0];
            cms = &cms_matrix[0][0];
            Debug(3, "BT2020NCL Colorspace used\n");
            break;
        default:                       // fallback
            m = &yuv_bt709.m[0][0];
            c = &yuv_bt709.c[0];
            Debug(3, "default BT709 Colorspace used  %d\n", colorspace);
            break;
    }
	
	GL_init();
	
	GLSL("%s\n",gl_version);
	GLSL("precision mediump float;    \n");
	GLSL("layout(location = 0) out vec4 out_color;\n");
	GLSL("in vec2 texcoord0;          \n");
	GLSL("in vec2 texcoord1;          \n");
	if (Planes == 3)
		GLSL("in vec2 texcoord2;      \n");
	GLSL("uniform mat3 colormatrix;   \n");
	GLSL("uniform vec3 colormatrix_c; \n");
	if (colorspace == AVCOL_SPC_BT2020_NCL)
		GLSL("uniform mat3 cms_matrix;\n");
	GLSL("uniform sampler2D texture0; \n");
	GLSL("uniform sampler2D texture1; \n");
	if (Planes == 3)
		GLSL("uniform sampler2D texture2; \n");
	GLSL("void main() {               \n");
	GLSL("vec4 color;                 \n");
	
	if (colorspace == AVCOL_SPC_BT2020_NCL) {
		GLSL("color.r = 1.003906 * vec4(texture(texture0, texcoord0)).r;     \n");
		if (Planes == 3) {
			GLSL("color.g = 1.003906 * vec4(texture(texture1, texcoord1)).r;  \n");
			GLSL("color.b = 1.003906 * vec4(texture(texture2, texcoord2)).r;  \n");
		} else {
			GLSL("color.gb = 1.003906 * vec4(texture(texture1, texcoord1)).rg;\n");
		}
		GLSL("// color conversion\n");
		GLSL("color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;     \n");
		GLSL("color.a = 1.0;                             \n");

		GLSL("// pl_shader_linearize                     \n");
        GLSL("color.rgb = max(color.rgb, 0.0);           \n");
//		GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);    \n");
//		GLSL("color.rgb = pow(color.rgb, vec3(2.4));     \n");
//		GLSL("color.rgb = mix(vec3(4.0) * color.rgb * color.rgb,exp((color.rgb - vec3(%f)) * vec3(1.0/%f)) + vec3(%f),bvec3(lessThan(vec3(0.5), color.rgb)));\n",HLG_C, HLG_A, HLG_B);
		GLSL("color.rgb = mix(vec3(4.0) * color.rgb * color.rgb,exp((color.rgb - vec3(0.55991073)) * vec3(1.0/0.17883277)) + vec3(0.28466892), bvec3(lessThan(vec3(0.5), color.rgb)));\n");
		GLSL("// color mapping                           \n");
		GLSL("color.rgb = cms_matrix * color.rgb;        \n");
#ifndef GAMMA	
		GLSL("// pl_shader_delinearize                   \n");
		GLSL("color.rgb = max(color.rgb, 0.0);           \n");
//		GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);    \n");
//		GLSL("color.rgb = pow(color.rgb, vec3(1.0/2.4)); \n");
		GLSL("color.rgb = mix(vec3(0.5) * sqrt(color.rgb), vec3(0.17883277) * log(color.rgb - vec3(0.28466892)) + vec3(0.55991073), bvec3(lessThan(vec3(1.0), color.rgb))); \n");

#endif
		GLSL("out_color = color;                         \n");
		GLSL("} \n");		
	}
	else {		

		GLSL("color.r =  1.000000 * vec4(texture(texture0, texcoord0)).r;  \n");
		if (Planes == 3) {
			GLSL("color.g = 1.000000 * vec4(texture(texture1, texcoord1)).r;\n");
			GLSL("color.b = 1.000000 * vec4(texture(texture2, texcoord2)).r;\n");
		} else {
			GLSL("color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg; \n");
		}
		GLSL("// color conversion         \n");
		GLSL("color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;  \n");
		GLSL("color.a = 1.0;              \n");		

		GLSL("// linearize gamma                     \n");
		GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);  \n");    // linearize gamma
		GLSL("color.rgb = pow(color.rgb, vec3(2.4));   \n");
#ifndef GAMMA	
		GLSL("// delinearize gamma to sRGB               \n");
		GLSL("color.rgb = max(color.rgb, 0.0);         \n");
		GLSL("color.rgb = mix(color.rgb * vec3(12.92), vec3(1.055) * pow(color.rgb, vec3(1.0/2.4)) - vec3(0.055), bvec3(lessThanEqual(vec3(0.0031308), color.rgb))); \n");
#endif
		GLSL("// color mapping            \n");
		GLSL("out_color = color;          \n");
		GLSL("} \n");
	}
//printf(">%s<",sh);
    Debug(3, "vor compile fragment\n");
    compile_attach_shader(gl_prog, GL_FRAGMENT_SHADER, sh); 
    glBindAttribLocation(gl_prog, 0, "vertex_position");

    for (n = 0; n < 6; n++) {
        sprintf(vname, "vertex_texcoord%1d", n);
        glBindAttribLocation(gl_prog, n + 1, vname);
    }

    link_shader(gl_prog);

    gl_colormatrix = glGetUniformLocation(gl_prog, "colormatrix");
    Debug(3, "get uniform colormatrix %d \n", gl_colormatrix);
    if (gl_colormatrix != -1)
        glProgramUniformMatrix3fv(gl_prog, gl_colormatrix, 1, 0, m);
    GlxCheck();
    Debug(3, "nach set colormatrix\n");

    gl_colormatrix_c = glGetUniformLocation(gl_prog, "colormatrix_c");
    Debug(3, "get uniform colormatrix_c %d %f\n", gl_colormatrix_c, *c);
    if (gl_colormatrix_c != -1)
        glProgramUniform3fv(gl_prog, gl_colormatrix_c, 1, c);
    GlxCheck();

    if (colorspace == AVCOL_SPC_BT2020_NCL) {
        cmsLoc = glGetUniformLocation(gl_prog, "cms_matrix");
        if (cmsLoc != -1)
            glProgramUniformMatrix3fv(gl_prog, cmsLoc, 1, 0, cms);
        GlxCheck();
    }

    return gl_prog;
}

static void render_pass_quad(int flip, float xcrop, float ycrop)
{
    struct vertex va[4];
    int n;
    const struct gl_vao_entry *e;

    // uhhhh what a hack
    if (!flip) {
        va[0].position.x = (float)-1.0;
        va[0].position.y = (float)1.0;
        va[1].position.x = (float)-1.0;
        va[1].position.y = (float)-1.0;
        va[2].position.x = (float)1.0;
        va[2].position.y = (float)1.0;
        va[3].position.x = (float)1.0;
        va[3].position.y = (float)-1.0;
    } else {
        va[0].position.x = (float)-1.0;
        va[0].position.y = (float)-1.0;
        va[1].position.x = (float)-1.0;
        va[1].position.y = (float)1.0;
        va[2].position.x = (float)1.0;
        va[2].position.y = (float)-1.0;
        va[3].position.x = (float)1.0;
        va[3].position.y = (float)1.0;
    }

    va[0].texcoord[0].x = (float)0.0 + xcrop;
    va[0].texcoord[0].y = (float)0.0 + ycrop;   // abgeschnitten von links oben
    va[0].texcoord[1].x = (float)0.0 + xcrop;
    va[0].texcoord[1].y = (float)0.0 + ycrop;   // abgeschnitten von links oben
    va[1].texcoord[0].x = (float)0.0 + xcrop;
    va[1].texcoord[0].y = (float)1.0 - ycrop;   // abgeschnitten links unten 1.0 - Wert
    va[1].texcoord[1].x = (float)0.0 + xcrop;
    va[1].texcoord[1].y = (float)1.0 - ycrop;   // abgeschnitten links unten 1.0 - Wert
    va[2].texcoord[0].x = (float)1.0 - xcrop;
    va[2].texcoord[0].y = (float)0.0 + ycrop;   // abgeschnitten von rechts oben
    va[2].texcoord[1].x = (float)1.0 - xcrop;
    va[2].texcoord[1].y = (float)0.0 + ycrop;   // abgeschnitten von rechts oben
    va[3].texcoord[0].x = (float)1.0 - xcrop;
    va[3].texcoord[0].y = (float)1.0 - ycrop;   // abgeschnitten von rechts unten 1.0 - wert
    va[3].texcoord[1].x = (float)1.0 - xcrop;
    va[3].texcoord[1].y = (float)1.0 - ycrop;   // abgeschnitten von rechts unten 1.0 - wert

    glBindBuffer(GL_ARRAY_BUFFER, vao_buffer);
    glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(struct vertex), va, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // enable attribs
    glBindBuffer(GL_ARRAY_BUFFER, vao_buffer);
    for (n = 0; vertex_vao[n].name; n++) {
        e = &vertex_vao[n];
        glEnableVertexAttribArray(n);
        glVertexAttribPointer(n, e->num_elems, e->type, e->normalized, sizeof(struct vertex),
            (void *)(intptr_t) e->offset);
    }
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    // draw quad
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    for (n = 0; vertex_vao[n].name; n++)
        glDisableVertexAttribArray(n);
}