opengl colorspace + BT2020

[goodguy/history.git] / cinelerra-5.1 / plugins / gamma / gamma.C

diff --git a/cinelerra-5.1/plugins/gamma/gamma.C b/cinelerra-5.1/plugins/gamma/gamma.C
index 28d04fc5b71a8365ca368e4611861d21ec1a1fdc..a462b0624930e3854bf5be71055b357bc1fee149 100644 (file)
--- a/cinelerra-5.1/plugins/gamma/gamma.C
+++ b/cinelerra-5.1/plugins/gamma/gamma.C
@@ -177,7 +177,7 @@ void GammaUnit::process_package(LoadPackage *package)
                                y /= 0xff;
                                u = (float)((u - 0x80) / 0xff);
                                v = (float)((v - 0x80) / 0xff);
-                               YUV::yuv_to_rgb_f(r, g, b, y, u, v);
+                               YUV::yuv.yuv_to_rgb_f(r, g, b, y, u, v);
                                HISTOGRAM_TAIL(3)
                                break;
                        case BC_YUVA8888:
@@ -188,7 +188,7 @@ void GammaUnit::process_package(LoadPackage *package)
                                y /= 0xff;
                                u = (float)((u - 0x80) / 0xff);
                                v = (float)((v - 0x80) / 0xff);
-                               YUV::yuv_to_rgb_f(r, g, b, y, u, v);
+                               YUV::yuv.yuv_to_rgb_f(r, g, b, y, u, v);
                                HISTOGRAM_TAIL(4)
                                break;
                }
@@ -275,9 +275,9 @@ void GammaUnit::process_package(LoadPackage *package)
                                y /= 0xff;
                                u = (float)((u - 0x80) / 0xff);
                                v = (float)((v - 0x80) / 0xff);
-                               YUV::yuv_to_rgb_f(r, g, b, y, u, v);
+                               YUV::yuv.yuv_to_rgb_f(r, g, b, y, u, v);
                                GAMMA_MID
-                               YUV::rgb_to_yuv_f(r, g, b, y, u, v);
+                               YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
                                y *= 0xff;
                                u = u * 0xff + 0x80;
                                v = v * 0xff + 0x80;
@@ -294,9 +294,9 @@ void GammaUnit::process_package(LoadPackage *package)
                                y /= 0xff;
                                u = (float)((u - 0x80) / 0xff);
                                v = (float)((v - 0x80) / 0xff);
-                               YUV::yuv_to_rgb_f(r, g, b, y, u, v);
+                               YUV::yuv.yuv_to_rgb_f(r, g, b, y, u, v);
                                GAMMA_MID
-                               YUV::rgb_to_yuv_f(r, g, b, y, u, v);
+                               YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
                                y *= 0xff;
                                u = u * 0xff + 0x80;
                                v = v * 0xff + 0x80;
@@ -573,43 +573,30 @@ int GammaMain::handle_opengl()
        get_output()->to_texture();
        get_output()->enable_opengl();
 
+        const char *shader_stack[16];
+        memset(shader_stack,0, sizeof(shader_stack));
+        int current_shader = 0;
 
-       const char *shader_stack[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-       int current_shader = 0;
-
+       int need_color_matrix = BC_CModels::is_yuv(get_output()->get_color_model()) ? 1 : 0;
+       if( need_color_matrix )
+               shader_stack[current_shader++] = bc_gl_colors;
 
 // Aggregate with interpolate
-       int aggregate = 0;
-       if(prev_effect_is(_("Interpolate Pixels")))
-       {
-               aggregate = 1;
-               INTERPOLATE_COMPILE(shader_stack, current_shader)
-       }
+       int aggregate = prev_effect_is(_("Interpolate Pixels")) ? 1 : 0;
+       if( aggregate )
+               INTERPOLATE_COMPILE(shader_stack, current_shader);
 
        GAMMA_COMPILE(shader_stack, current_shader, aggregate);
 
-       unsigned int shader = VFrame::make_shader(0,
-                               shader_stack[0],
-                               shader_stack[1],
-                               shader_stack[2],
-                               shader_stack[3],
-                               shader_stack[4],
-                               shader_stack[5],
-                               shader_stack[6],
-                               shader_stack[7],
-                               0);
-
-
-       if(shader > 0)
-       {
+       shader_stack[current_shader] = 0;
+       unsigned int shader = VFrame::make_shader(shader_stack);
+       if( shader > 0 ) {
                glUseProgram(shader);
                glUniform1i(glGetUniformLocation(shader, "tex"), 0);
-
                if(aggregate)
-               {
-                       INTERPOLATE_UNIFORMS(shader)
-               }
-               GAMMA_UNIFORMS(shader)
+                       INTERPOLATE_UNIFORMS(shader);
+               GAMMA_UNIFORMS(shader);
+               if( need_color_matrix ) BC_GL_COLORS(shader);
        }
 
        get_output()->init_screen();