server->output->to_texture();
server->output->enable_opengl();
- unsigned int frag_shader = VFrame::make_shader(0,
- affine_frag,
- 0);
+ unsigned int frag_shader = VFrame::make_shader(0, affine_frag, 0);
if( frag_shader > 0 ) {
glUseProgram(frag_shader);
glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
const char *YuvColorSpace::color_space[] = {
N_("BT601"),
N_("BT709"),
+ N_("BT2020"),
};
YuvColorSpace::YuvColorSpace(int x, int y, PreferencesWindow *pwindow)
class YuvColorSpace : public BC_PopupMenu
{
- static const char *color_space[2];
+ static const char *color_space[3];
public:
YuvColorSpace(int x, int y, PreferencesWindow *pwindow);
~YuvColorSpace();
int is_mpeg = !ff ? 0 : ff->ff_video_mpeg_color_range(vstream);
switch(driver) {
- case PLAYBACK_X11: return is_mpeg ? BC_YUV888 : BC_RGB888;
+ case PLAYBACK_X11:
+ case PLAYBACK_X11_GL: return is_mpeg ? BC_YUV888 : BC_RGB888;
case PLAYBACK_X11_XV: return BC_YUV420P;
- case PLAYBACK_X11_GL: return BC_RGB_FLOAT;
}
return BC_RGB888;
{
switch(driver) {
// the direct X11 color model requires scaling in the codec
- case PLAYBACK_X11: return BC_RGB888;
+ case PLAYBACK_X11:
+ case PLAYBACK_X11_GL: return BC_RGB888;
case PLAYBACK_X11_XV: return BC_YUV420P;
- case PLAYBACK_X11_GL: return BC_RGB_FLOAT;
}
return BC_YUV420P;
// result->data->get_w(),
// frame->get_w());
-
+// no context data since keyframe updates may vary input
frame->copy_from(result->data);
-
-
-// This would have copied the color matrix for interpolate, but
-// required the same plugin stack as the reader.
-// frame->copy_stacks(result->data);
- frame->copy_params(result->data);
}
result->age = get_age();
}
#define GL_GLEXT_PROTOTYPES
+#include "bccolors.h"
#include "bcsignals.h"
#include "bcwindowbase.h"
#include "canvas.h"
#ifdef HAVE_GL
static const char *yuv_to_rgb_frag =
"uniform sampler2D tex;\n"
+ "uniform mat3 yuv_to_rgb_matrix;\n"
+ "uniform float yminf;\n"
"void main()\n"
"{\n"
" vec4 yuva = texture2D(tex, gl_TexCoord[0].st);\n"
- " yuva.rgb -= vec3(0, 0.5, 0.5);\n"
- " const mat3 yuv_to_rgb_matrix = mat3(\n"
- " 1, 1, 1, \n"
- " 0, -0.34414, 1.77200, \n"
- " 1.40200, -0.71414, 0);\n"
+ " yuva.rgb -= vec3(yminf, 0.5, 0.5);\n"
" gl_FragColor = vec4(yuv_to_rgb_matrix * yuva.rgb, yuva.a);\n"
"}\n";
static const char *yuva_to_rgb_frag =
"uniform sampler2D tex;\n"
+ "uniform mat3 yuv_to_rgb_matrix;\n"
+ "uniform float yminf;\n"
"void main()\n"
"{\n"
" vec4 yuva = texture2D(tex, gl_TexCoord[0].st);\n"
- " yuva.rgb -= vec3(0, 0.5, 0.5);\n"
- " const mat3 yuv_to_rgb_matrix = mat3(\n"
- " 1, 1, 1, \n"
- " 0, -0.34414, 1.77200, \n"
- " 1.40200, -0.71414, 0);\n"
+ " yuva.rgb -= vec3(yminf, 0.5, 0.5);\n"
" yuva.rgb = yuv_to_rgb_matrix * yuva.rgb;\n"
" yuva.rgb *= yuva.a;\n"
" yuva.a = 1.0;\n"
static const char *rgb_to_yuv_frag =
"uniform sampler2D tex;\n"
+ "uniform mat3 rgb_to_yuv_matrix;\n"
+ "uniform float yminf;\n"
"void main()\n"
"{\n"
" vec4 rgba = texture2D(tex, gl_TexCoord[0].st);\n"
- " const mat3 rgb_to_yuv_matrix = mat3(\n"
- " 0.29900, -0.16874, 0.50000, \n"
- " 0.58700, -0.33126, -0.41869, \n"
- " 0.11400, 0.50000, -0.08131);\n"
" rgba.rgb = rgb_to_yuv_matrix * rgba.rgb;\n"
- " rgba.rgb += vec3(0, 0.5, 0.5);\n"
+ " rgba.rgb += vec3(yminf, 0.5, 0.5);\n"
" gl_FragColor = rgba;\n"
"}\n";
static const char *rgba_to_yuv_frag =
"uniform sampler2D tex;\n"
+ "uniform mat3 rgb_to_yuv_matrix;\n"
+ "uniform float yminf;\n"
"void main()\n"
"{\n"
" vec4 rgba = texture2D(tex, gl_TexCoord[0].st);\n"
- " const mat3 rgb_to_yuv_matrix = mat3(\n"
- " 0.29900, -0.16874, 0.50000, \n"
- " 0.58700, -0.33126, -0.41869, \n"
- " 0.11400, 0.50000, -0.08131);\n"
" rgba.rgb *= rgba.a;\n"
" rgba.a = 1.0;\n"
" rgba.rgb = rgb_to_yuv_matrix * rgba.rgb;\n"
- " rgba.rgb += vec3(0, 0.5, 0.5);\n"
+ " rgba.rgb += vec3(yminf, 0.5, 0.5);\n"
" gl_FragColor = rgba;\n"
"}\n";
// Undo any previous shader settings
command->frame->bind_texture(0);
-
-
-
// Convert colormodel
- unsigned int frag_shader = 0;
- switch(command->frame->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- frag_shader = VFrame::make_shader(0,
- yuv_to_rgb_frag,
- 0);
- break;
- }
-
-
- if(frag_shader > 0)
- {
- glUseProgram(frag_shader);
- int variable = glGetUniformLocation(frag_shader, "tex");
+ unsigned int shader = !BC_CModels::is_yuv(command->frame->get_color_model()) ? 0 :
+ VFrame::make_shader(0, yuv_to_rgb_frag, 0);
+ if( shader > 0 ) {
+ glUseProgram(shader);
// Set texture unit of the texture
+ int variable = glGetUniformLocation(shader, "tex");
glUniform1i(variable, 0);
+ BC_GL_YUV_TO_RGB(shader);
}
if(BC_CModels::components(command->frame->get_color_model()) == 4)
}
- const char *shader_stack[4] = { 0, 0, 0, 0, };
- int total_shaders = 0;
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int total_shaders = 0, need_matrix = 0;
VFrame::init_screen(canvas_w, canvas_h);
// Convert colormodel to RGB if not nested.
// The color model setting in the output frame is ignored.
- if( command->is_nested <= 0 ) { // not nested
- switch(command->input->get_color_model()) {
- case BC_YUV888:
- case BC_YUVA8888:
- shader_stack[total_shaders++] = yuv_to_rgb_frag;
- break;
- }
+ if( command->is_nested <= 0 && // not nested
+ BC_CModels::is_yuv(command->input->get_color_model()) ) {
+ need_matrix = 1;
+ shader_stack[total_shaders++] = yuv_to_rgb_frag;
}
// get the shaders
}
// run the shaders
- unsigned int frag_shader = 0;
- if(shader_stack[0]) {
- frag_shader = VFrame::make_shader(0,
- shader_stack[0], shader_stack[1],
- shader_stack[2], shader_stack[3], 0);
-
- glUseProgram(frag_shader);
-
+ add_shader(0);
+ unsigned int shader = !shader_stack[0] ? 0 :
+ VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ if( need_matrix ) BC_GL_YUV_TO_RGB(shader);
// Set texture unit of the texture
- glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
// Set texture unit of the temp texture
- glUniform1i(glGetUniformLocation(frag_shader, "tex2"), 1);
+ glUniform1i(glGetUniformLocation(shader, "tex2"), 1);
// Set alpha
- int variable = glGetUniformLocation(frag_shader, "alpha");
+ int variable = glGetUniformLocation(shader, "alpha");
glUniform1f(variable, command->alpha);
// Set dimensions of the temp texture
if(temp_texture)
- glUniform2f(glGetUniformLocation(frag_shader, "tex2_dimensions"),
+ glUniform2f(glGetUniformLocation(shader, "tex2_dimensions"),
(float)temp_texture->get_texture_w(),
(float)temp_texture->get_texture_h());
}
// For unfeathered masks, we could use a stencil buffer
// for further optimization but we also need a YUV algorithm.
unsigned int frag_shader = 0;
- switch(temp_texture->get_texture_components())
- {
- case 3:
- if(command->frame->get_color_model() == BC_YUV888)
- frag_shader = VFrame::make_shader(0,
- multiply_yuvmask3_frag,
- 0);
- else
- frag_shader = VFrame::make_shader(0,
- multiply_mask3_frag,
- 0);
- break;
- case 4:
- frag_shader = VFrame::make_shader(0,
- multiply_mask4_frag,
- 0);
- break;
+ switch(temp_texture->get_texture_components()) {
+ case 3:
+ frag_shader = VFrame::make_shader(0,
+ command->frame->get_color_model() == BC_YUV888 ?
+ multiply_yuvmask3_frag : multiply_mask3_frag,
+ 0);
+ break;
+ case 4:
+ frag_shader = VFrame::make_shader(0, multiply_mask4_frag, 0);
+ break;
}
- if(frag_shader)
- {
+ if( frag_shader ) {
int variable;
glUseProgram(frag_shader);
if((variable = glGetUniformLocation(frag_shader, "tex")) >= 0)
#ifdef HAVE_GL
command->canvas->lock_canvas("Playback3D::convert_cmodel_sync");
- if(command->canvas->get_canvas())
- {
+ if( command->canvas->get_canvas() ) {
BC_WindowBase *window = command->canvas->get_canvas();
window->lock_window("Playback3D::convert_cmodel_sync");
window->enable_opengl();
command->frame->to_texture();
// Colormodel permutation
- const char *shader = 0;
int src_cmodel = command->frame->get_color_model();
int dst_cmodel = command->dst_cmodel;
- typedef struct
- {
- int src;
- int dst;
+ typedef struct {
+ int src, dst, typ;
const char *shader;
} cmodel_shader_table_t;
- static cmodel_shader_table_t cmodel_shader_table[] =
- {
- { BC_RGB888, BC_YUV888, rgb_to_yuv_frag },
- { BC_RGB888, BC_YUVA8888, rgb_to_yuv_frag },
- { BC_RGBA8888, BC_RGB888, rgba_to_rgb_frag },
- { BC_RGBA8888, BC_RGB_FLOAT, rgba_to_rgb_frag },
- { BC_RGBA8888, BC_YUV888, rgba_to_yuv_frag },
- { BC_RGBA8888, BC_YUVA8888, rgb_to_yuv_frag },
- { BC_RGB_FLOAT, BC_YUV888, rgb_to_yuv_frag },
- { BC_RGB_FLOAT, BC_YUVA8888, rgb_to_yuv_frag },
- { BC_RGBA_FLOAT, BC_RGB888, rgba_to_rgb_frag },
- { BC_RGBA_FLOAT, BC_RGB_FLOAT, rgba_to_rgb_frag },
- { BC_RGBA_FLOAT, BC_YUV888, rgba_to_yuv_frag },
- { BC_RGBA_FLOAT, BC_YUVA8888, rgb_to_yuv_frag },
- { BC_YUV888, BC_RGB888, yuv_to_rgb_frag },
- { BC_YUV888, BC_RGBA8888, yuv_to_rgb_frag },
- { BC_YUV888, BC_RGB_FLOAT, yuv_to_rgb_frag },
- { BC_YUV888, BC_RGBA_FLOAT, yuv_to_rgb_frag },
- { BC_YUVA8888, BC_RGB888, yuva_to_rgb_frag },
- { BC_YUVA8888, BC_RGBA8888, yuv_to_rgb_frag },
- { BC_YUVA8888, BC_RGB_FLOAT, yuva_to_rgb_frag },
- { BC_YUVA8888, BC_RGBA_FLOAT, yuv_to_rgb_frag },
- { BC_YUVA8888, BC_YUV888, yuva_to_yuv_frag },
+ enum { rgb_to_rgb, rgb_to_yuv, yuv_to_rgb, yuv_to_yuv, };
+ int type = -1;
+ static cmodel_shader_table_t cmodel_shader_table[] = {
+ { BC_RGB888, BC_YUV888, rgb_to_yuv, rgb_to_yuv_frag },
+ { BC_RGB888, BC_YUVA8888, rgb_to_yuv, rgb_to_yuv_frag },
+ { BC_RGBA8888, BC_RGB888, rgb_to_rgb, rgba_to_rgb_frag },
+ { BC_RGBA8888, BC_RGB_FLOAT, rgb_to_rgb, rgba_to_rgb_frag },
+ { BC_RGBA8888, BC_YUV888, rgb_to_yuv, rgba_to_yuv_frag },
+ { BC_RGBA8888, BC_YUVA8888, rgb_to_yuv, rgb_to_yuv_frag },
+ { BC_RGB_FLOAT, BC_YUV888, rgb_to_yuv, rgb_to_yuv_frag },
+ { BC_RGB_FLOAT, BC_YUVA8888, rgb_to_yuv, rgb_to_yuv_frag },
+ { BC_RGBA_FLOAT,BC_RGB888, rgb_to_rgb, rgba_to_rgb_frag },
+ { BC_RGBA_FLOAT,BC_RGB_FLOAT, rgb_to_rgb, rgba_to_rgb_frag },
+ { BC_RGBA_FLOAT,BC_YUV888, rgb_to_yuv, rgba_to_yuv_frag },
+ { BC_RGBA_FLOAT,BC_YUVA8888, rgb_to_yuv, rgb_to_yuv_frag },
+ { BC_YUV888, BC_RGB888, yuv_to_rgb, yuv_to_rgb_frag },
+ { BC_YUV888, BC_RGBA8888, yuv_to_rgb, yuv_to_rgb_frag },
+ { BC_YUV888, BC_RGB_FLOAT, yuv_to_rgb, yuv_to_rgb_frag },
+ { BC_YUV888, BC_RGBA_FLOAT, yuv_to_rgb, yuv_to_rgb_frag },
+ { BC_YUVA8888, BC_RGB888, yuv_to_rgb, yuva_to_rgb_frag },
+ { BC_YUVA8888, BC_RGBA8888, yuv_to_rgb, yuv_to_rgb_frag },
+ { BC_YUVA8888, BC_RGB_FLOAT, yuv_to_rgb, yuva_to_rgb_frag },
+ { BC_YUVA8888, BC_RGBA_FLOAT, yuv_to_rgb, yuv_to_rgb_frag },
+ { BC_YUVA8888, BC_YUV888, yuv_to_yuv, yuva_to_yuv_frag },
};
+ const char *shader = 0;
int table_size = sizeof(cmodel_shader_table) / sizeof(cmodel_shader_table_t);
- for(int i = 0; i < table_size; i++)
- {
- if(cmodel_shader_table[i].src == src_cmodel &&
- cmodel_shader_table[i].dst == dst_cmodel)
- {
+ for( int i=0; i<table_size; ++i ) {
+ if( cmodel_shader_table[i].src == src_cmodel &&
+ cmodel_shader_table[i].dst == dst_cmodel ) {
shader = cmodel_shader_table[i].shader;
+ type = cmodel_shader_table[i].typ;
break;
}
}
// command->dst_cmodel,
// shader);
- if(shader)
- {
+ const char *shader_stack[9];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
+
+ if( shader ) {
//printf("Playback3D::convert_cmodel_sync %d\n", __LINE__);
+ shader_stack[current_shader++] = shader;
+ shader_stack[current_shader] = 0;
+ unsigned int shader_id = VFrame::make_shader(shader_stack);
+
command->frame->bind_texture(0);
- unsigned int shader_id = -1;
- if(shader)
- {
- shader_id = VFrame::make_shader(0,
- shader,
- 0);
- glUseProgram(shader_id);
- glUniform1i(glGetUniformLocation(shader_id, "tex"), 0);
+ glUseProgram(shader_id);
+
+ glUniform1i(glGetUniformLocation(shader_id, "tex"), 0);
+ switch( type ) {
+ case rgb_to_yuv:
+ BC_GL_RGB_TO_YUV(shader_id);
+ break;
+ case yuv_to_rgb:
+ BC_GL_YUV_TO_RGB(shader_id);
+ break;
}
command->frame->draw_texture();
-
if(shader) glUseProgram(0);
-
command->frame->set_opengl_state(VFrame::SCREEN);
}
}
- if(frag_shader)
- {
+ if( frag_shader ) {
glUseProgram(frag_shader);
int variable;
if((variable = glGetUniformLocation(frag_shader, "tex")) >= 0)
#define PLAYBACK3D_H
#include "arraylist.h"
+#include "bccolors.h"
#include "bcpixmap.inc"
#include "bcsynchronous.h"
#include "bcwindowbase.inc"
+// use static presets YUV in bccolors.h
+#define BC_GL_MATRIX(shader, mat) \
+ glUniformMatrix3fv(glGetUniformLocation(shader, #mat), 1, 0, YUV::mat)
+
+#define BC_GL_YMINF(shader,mat) \
+ glUniform1f(glGetUniformLocation(shader, "yminf"), YUV::mat[9])
+
+#define BC_GL_RGB_TO_YUV(shader) do { \
+ BC_GL_MATRIX(shader, rgb_to_yuv_matrix); \
+ BC_GL_YMINF(shader, rgb_to_yuv_matrix); \
+} while(0)
+
+#define BC_GL_YUV_TO_RGB(shader) do { \
+ BC_GL_MATRIX(shader, yuv_to_rgb_matrix); \
+ BC_GL_YMINF(shader, yuv_to_rgb_matrix); \
+} while(0)
+
+#define BC_GL_COLORS(shader) do { \
+ BC_GL_MATRIX(shader, yuv_to_rgb_matrix); \
+ BC_GL_MATRIX(shader, rgb_to_yuv_matrix); \
+ BC_GL_YMINF(shader, rgb_to_yuv_matrix); \
+} while(0)
+
+
+#define bc_gl_yuv_to_rgb "uniform mat3 yuv_to_rgb_matrix;\n"
+#define bc_gl_rgb_to_yuv "uniform mat3 rgb_to_yuv_matrix;\n"
+#define bc_gl_yminf "uniform float yminf;\n"
+#define bc_gl_colors bc_gl_yuv_to_rgb bc_gl_rgb_to_yuv bc_gl_yminf
// Macros for useful fragment shaders
#define YUV_TO_RGB_FRAG(PIXEL) \
- PIXEL ".gb -= vec2(0.5, 0.5);\n" \
- PIXEL ".rgb = mat3(\n" \
- " 1, 1, 1, \n" \
- " 0, -0.34414, 1.77200, \n" \
- " 1.40200, -0.71414, 0) * " PIXEL ".rgb;\n"
+ PIXEL ".rgb -= vec3(yminf, 0.5, 0.5);\n" \
+ PIXEL ".rgb = yuv_to_rgb_matrix * " PIXEL ".rgb;\n"
#define RGB_TO_YUV_FRAG(PIXEL) \
- PIXEL ".rgb = mat3(\n" \
- " 0.29900, -0.16874, 0.50000, \n" \
- " 0.58700, -0.33126, -0.41869, \n" \
- " 0.11400, 0.50000, -0.08131) * " PIXEL ".rgb;\n" \
- PIXEL ".gb += vec2(0.5, 0.5);\n"
+ PIXEL ".rgb = rgb_to_yuv_matrix * " PIXEL ".rgb;\n" \
+ PIXEL ".rgb += vec3(yminf, 0.5, 0.5);\n"
#define RGB_TO_HSV_FRAG(PIXEL) \
"{\n" \
"" PIXEL ".b = b;\n" \
"}\n"
-
-
class Playback3DCommand : public BC_SynchronousCommand
{
public:
void Mixer::set_title(const char *tp)
{
if( tp == title ) return;
- strncpy(title, tp, sizeof(title));
+ strncpy(title, !tp ? "" : tp, sizeof(title));
title[sizeof(title)-1] = 0;
}
YUV YUV::yuv;
+float YUV::rgb_to_yuv_matrix[10];
+float YUV::yuv_to_rgb_matrix[10];
YUV::YUV()
{
int mpeg;
switch( color_space ) {
default:
- case 0: kr = BT601_Kr; kb = BT601_Kb; break;
- case 1: kr = BT709_Kr; kb = BT709_Kb; break;
+ case BC_COLORS_BT601: kr = BT601_Kr; kb = BT601_Kb; break;
+ case BC_COLORS_BT709: kr = BT709_Kr; kb = BT709_Kb; break;
+ case BC_COLORS_BT2020: kr = BT2020_Kr; kb = BT2020_Kb; break;
}
switch( color_range ) {
default:
- case 0: mpeg = 0; break;
- case 1: mpeg = 1; break;
+ case BC_COLORS_JPEG: mpeg = 0; break;
+ case BC_COLORS_MPEG: mpeg = 1; break;
}
init(kr, kb, mpeg);
}
vtor8f, vtog8f, utog8f, utob8f);
init_tables(0x10000,
vtor16f, vtog16f, utog16f, utob16f);
+
+ rgb_to_yuv_matrix[0] = r_to_y;
+ rgb_to_yuv_matrix[1] = r_to_u;
+ rgb_to_yuv_matrix[2] = r_to_v;
+ rgb_to_yuv_matrix[3] = g_to_y;
+ rgb_to_yuv_matrix[4] = g_to_u;
+ rgb_to_yuv_matrix[5] = g_to_v;
+ rgb_to_yuv_matrix[6] = b_to_y;
+ rgb_to_yuv_matrix[7] = b_to_u;
+ rgb_to_yuv_matrix[8] = b_to_v;
+ rgb_to_yuv_matrix[9] = yminf;
+
+ float yscale = 1.f / yrangef;
+ yuv_to_rgb_matrix[0] = yscale;
+ yuv_to_rgb_matrix[1] = yscale;
+ yuv_to_rgb_matrix[2] = yscale;
+ yuv_to_rgb_matrix[3] = 0;
+ yuv_to_rgb_matrix[4] = u_to_g;
+ yuv_to_rgb_matrix[5] = u_to_b;
+ yuv_to_rgb_matrix[6] = v_to_r;
+ yuv_to_rgb_matrix[7] = v_to_g;
+ yuv_to_rgb_matrix[8] = 0;
+ yuv_to_rgb_matrix[9] = yminf;
}
void YUV::init_tables(int len,
// Duplicate filename in guicast
+#include "bccolors.inc"
#include "clip.h"
#include "vframe.inc"
#include <stdint.h>
-// bt601 coefs originaly used
-// Compression coefficients straight out of jpeglib
-#define R_TO_Y 0.29900
-#define G_TO_Y 0.58700
-#define B_TO_Y 0.11400
-
-#define R_TO_U -0.16874
-#define G_TO_U -0.33126
-#define B_TO_U 0.50000
-
-#define R_TO_V 0.50000
-#define G_TO_V -0.41869
-#define B_TO_V -0.08131
-
-// Decompression coefficients straight out of jpeglib
-#define V_TO_R 1.40200
-#define V_TO_G -0.71414
-
-#define U_TO_G -0.34414
-#define U_TO_B 1.77200
/*
Digital YCbCr is derived from analog RGB as follows:
#define utog8f (tabf+0x40200)
#define utob8f (tabf+0x40300)
-#define bc_always_inline __attribute__ ((__always_inline__)) inline
-
public:
YUV();
~YUV();
inline int is_mpeg() { return mpeg; }
static YUV yuv;
+ static float rgb_to_yuv_matrix[10];
+ static float yuv_to_rgb_matrix[10];
#define YUV_rgb_to_yuv_8(r,g,b, y,u,v) \
- y = (rtoy8[r] + gtoy8[g] + btoy8[b] + yzero) >> 16; \
- u = (rtou8[r] + gtou8[g] + btou8[b] + uvzero) >> 16; \
- v = (rtov8[r] + gtov8[g] + btov8[b] + uvzero) >> 16
+ y = iclip((rtoy8[r] + gtoy8[g] + btoy8[b] + yzero) >> 16, ymin8, ymax8); \
+ u = iclip((rtou8[r] + gtou8[g] + btou8[b] + uvzero) >> 16, uvmin8, uvmax8); \
+ v = iclip((rtov8[r] + gtov8[g] + btov8[b] + uvzero) >> 16, uvmin8, uvmax8)
bc_always_inline void rgb_to_yuv_8(int r, int g, int b, int &y, int &u, int &v) {
YUV_rgb_to_yuv_8(r,g,b, y,u,v);
}
#define YUV_rgb_to_yuv_16(r,g,b, y,u,v) \
- y = (rtoy16[r] + gtoy16[g] + btoy16[b] + yzero) >> 8; \
- u = (rtou16[r] + gtou16[g] + btou16[b] + uvzero) >> 8; \
- v = (rtov16[r] + gtov16[g] + btov16[b] + uvzero) >> 8
+ y = iclip((rtoy16[r] + gtoy16[g] + btoy16[b] + yzero) >> 8, ymin16, ymax16); \
+ u = iclip((rtou16[r] + gtou16[g] + btou16[b] + uvzero) >> 8, uvmin16, uvmax16); \
+ v = iclip((rtov16[r] + gtov16[g] + btov16[b] + uvzero) >> 8, uvmin16, uvmax16)
bc_always_inline void rgb_to_yuv_16(int r, int g, int b, int &y, int &u, int &v) {
YUV_rgb_to_yuv_16(r,g,b, y,u,v);
u = r * r_to_u + g * g_to_u + b * b_to_u;
v = r * r_to_v + g * g_to_v + b * b_to_v;
}
- bc_always_inline void rgb_to_yuv_8(float r, float g, float b, int &y, int &u, int &v) {
- float fy, fu, fv; rgb_to_yuv_f(r, g, b, fy, fu, fv);
- int iy = fy * 0x100, iu = fu * 0x100, iv = fv * 0x100;
- CLAMP(iy, ymin8, ymax8);
- CLAMP(iu, uvmin8, uvmax8); CLAMP(iv, uvmin8, uvmax8);
- y = iy; u = iu; v = iv;
+ bc_always_inline void rgb_to_yuv_f(float r, float g, float b, uint8_t &y, uint8_t &u, uint8_t &v) {
+ int ir = iclip(r*0x100, 0, 0xff);
+ int ig = iclip(g*0x100, 0, 0xff);
+ int ib = iclip(b*0x100, 0, 0xff);
+ rgb_to_yuv_8(ir,ig,ib, y,u,v);
}
- bc_always_inline void rgb_to_yuv_16(float r, float g, float b,
- int &y, int &u, int &v) {
- float fy, fu, fv; rgb_to_yuv_f(r, g, b, fy, fu, fv);
- int iy = fy * 0x10000, iu = fu * 0x10000, iv = fv * 0x10000;
- CLAMP(iy, ymin16, ymax16);
- CLAMP(iu, uvmin16, uvmax16); CLAMP(iv, uvmin16, uvmax16);
- y = iy; u = iu; v = iv;
+ bc_always_inline void rgb_to_yuv_f(float r, float g, float b, uint16_t &y, uint16_t &u, uint16_t &v) {
+ int ir = iclip(r*0x10000, 0, 0xffff);
+ int ig = iclip(g*0x10000, 0, 0xffff);
+ int ib = iclip(b*0x10000, 0, 0xffff);
+ rgb_to_yuv_16(ir,ig,ib, y,u,v);
}
#define YUV_yuv_to_rgb_8(r,g,b, y,u,v) \
- r = (ytab8[y] + vtor8[v]) >> 16; \
- g = (ytab8[y] + utog8[u] + vtog8[v]) >> 16; \
- b = (ytab8[y] + utob8[u]) >> 16
+ r = iclip((ytab8[y] + vtor8[v]) >> 16, 0, 0xff); \
+ g = iclip((ytab8[y] + utog8[u] + vtog8[v]) >> 16, 0, 0xff); \
+ b = iclip((ytab8[y] + utob8[u]) >> 16, 0, 0xff)
bc_always_inline void yuv_to_rgb_8(int &r, int &g, int &b, int y, int u, int v) {
YUV_yuv_to_rgb_8(r,g,b, y,u,v);
- CLAMP(r, 0, 0xff); CLAMP(g, 0, 0xff); CLAMP(b, 0, 0xff);
}
bc_always_inline void yuv_to_rgb_8(uint8_t &r, uint8_t &g, uint8_t &b, int y, int u, int v) {
YUV_yuv_to_rgb_8(r,g,b, y,u,v);
}
bc_always_inline void yuv_to_rgb_8(int &r, int &g, int &b) {
int y = r, u = g, v = b; YUV_yuv_to_rgb_8(r,g,b, y,u,v);
- CLAMP(r, 0, 0xff); CLAMP(g, 0, 0xff); CLAMP(b, 0, 0xff);
}
bc_always_inline void yuv_to_rgb_8(float &r, float &g, float &b, int y, int u, int v) {
- int ir, ig, ib; YUV_yuv_to_rgb_8(ir,ig,ib, y,u,v);
+ int ir, ig, ib; yuv_to_rgb_8(ir,ig,ib, y,u,v);
float s = 1/255.f; r = s*ir; g = s*ig; b = s*ib;
}
#define YUV_yuv_to_rgb_16(r,g,b, y,u,v) \
- r = (ytab16[y] + vtor16[v]) >> 8; \
- g = (ytab16[y] + utog16[u] + vtog16[v]) >> 8; \
- b = (ytab16[y] + utob16[u]) >> 8
+ r = iclip((ytab16[y] + vtor16[v]) >> 8, 0, 0xffff); \
+ g = iclip((ytab16[y] + utog16[u] + vtog16[v]) >> 8, 0, 0xffff); \
+ b = iclip((ytab16[y] + utob16[u]) >> 8, 0, 0xffff)
bc_always_inline void yuv_to_rgb_16(int &r, int &g, int &b, int y, int u, int v) {
YUV_yuv_to_rgb_16(r,g,b, y,u,v);
- CLAMP(r, 0, 0xffff); CLAMP(g, 0, 0xffff); CLAMP(b, 0, 0xffff);
}
bc_always_inline void yuv_to_rgb_16(uint16_t &r, uint16_t &g, uint16_t &b, int y, int u, int v) {
YUV_yuv_to_rgb_16(r,g,b, y,u,v);
}
bc_always_inline void yuv_to_rgb_16(int &r, int &g, int &b) {
int y = r, u = g, v = b; YUV_yuv_to_rgb_16(r,g,b, y,u,v);
- CLAMP(r, 0, 0xffff); CLAMP(g, 0, 0xffff); CLAMP(b, 0, 0xffff);
}
bc_always_inline void yuv_to_rgb_16(float &r, float &g, float &b, int y, int u, int v) {
int ir, ig, ib; YUV_yuv_to_rgb_16(ir,ig,ib, y,u,v);
g = y + u_to_g * u + v_to_g * v;
b = y + u_to_b * u;
}
+ bc_always_inline void yuv_to_rgb_f(float &r, float &g, float &b, uint8_t &y, uint8_t &u, uint8_t &v) {
+ yuv_to_rgb_8(r,g,b, y,u,v);
+ }
+ bc_always_inline void yuv_to_rgb_f(float &r, float &g, float &b, uint16_t &y, uint16_t &u, uint16_t &v) {
+ yuv_to_rgb_16(r,g,b, y,u,v);
+ }
+
+ bc_always_inline int rgb_to_y_8(int r, int g, int b) {
+ return (rtoy8[r] + gtoy8[g] + btoy8[b] + yzero) >> 16;
+ }
+ bc_always_inline int rgb_to_y_16(int r, int g, int b) {
+ return (rtoy16[r] + gtoy16[g] + btoy16[b] + yzero) >> 8;
+ }
+ bc_always_inline float rgb_to_y_f(float r, float g, float b) {
+ return r * r_to_y + g * g_to_y + b * b_to_y + yminf;
+ }
// For easier programming. Doesn't do anything.
// unused cases in macro expansions, mismatched argument types
inline void yuv_to_rgb_8(float &r, float &g, float &b, float y, float u, float v) {}
inline void yuv_to_rgb_16(float &r, float &g, float &b, float y, float u, float v) {}
inline void yuv_to_rgb_f(int &r, int &g, int &b, int y, int u, int v) {}
- inline void yuv_to_rgb_f(uint8_t &r, uint8_t &g, uint8_t &b, int y, int u, int v) {}
+ inline void yuv_to_rgb_f(uint8_t &r, uint8_t &g, uint8_t &b, int&y, int u, int v) {}
inline void yuv_to_rgb_f(uint16_t &r, uint16_t &g, uint16_t &b, int y, int u, int v) {}
+
inline void rgb_to_yuv_8(float r, float g, float b, float &y, float &u, float &v) {}
inline void rgb_to_yuv_16(float r, float g, float b, float &y, float &u, float &v) {}
- inline void rgb_to_yuv_f(int &r, int &g, int &b, int y, int u, int v) {}
- inline void rgb_to_yuv_f(uint8_t &r, uint8_t &g, uint8_t &b, int y, int u, int v) {}
- inline void rgb_to_yuv_f(uint16_t &r, uint16_t &g, uint16_t &b, int y, int u, int v) {}
+ inline void rgb_to_yuv_f(int r, int g, int b, int &y, int &u, int &v) {}
+ inline void rgb_to_yuv_f(uint8_t r, uint8_t g, uint8_t b, int &y, int &u, int &v) {}
+ inline void rgb_to_yuv_f(uint16_t r, uint16_t g, uint16_t b, int &y, int &u, int &v) {}
};
class YUV;
+#define BC_COLORS_BT601 0
+#define BC_COLORS_BT709 1
+#define BC_COLORS_BT2020 2
+
+#define BC_COLORS_JPEG 0
+#define BC_COLORS_MPEG 1
#endif
fclose(ifp);
}
+static void bc_list_openfiles(int lines, FILE *ofp, const char *fmt,...)
+{
+ va_list ap; va_start(ap, fmt);
+ char bfr[BCTEXTLEN]; vsnprintf(bfr, sizeof(bfr), fmt, ap);
+ va_end(ap);
+ DIR *dir = opendir(bfr);
+ if( !dir ) return;
+ struct dirent64 *dent;
+ while( --lines >= 0 && (dent = readdir64(dir)) ) {
+ const char *fn = dent->d_name;
+ fprintf(ofp, "%s", fn);
+ char path[BCTEXTLEN], link[BCTEXTLEN];
+ struct stat st;
+ snprintf(path, sizeof(path), "%s/%s", bfr, fn);
+ if( !stat(path,&st) ) {
+ int typ = 0;
+ if( S_ISREG(st.st_mode) ) typ = ' ';
+ else if( S_ISDIR(st.st_mode) ) typ = 'd';
+ else if( S_ISBLK(st.st_mode) ) typ = 'b';
+ else if( S_ISCHR(st.st_mode) ) typ = 'c';
+ else if( S_ISFIFO(st.st_mode) ) typ = 'f';
+ else if( S_ISLNK(st.st_mode) ) typ = 'l';
+ else if( S_ISSOCK(st.st_mode) ) typ = 's';
+ if( typ ) fprintf(ofp, "\t%c", typ);
+ fprintf(ofp, "\tsize %jd", st.st_size);
+ int len = readlink(path, link, sizeof(link)-1);
+ if( len > 0 ) {
+ link[len] = 0;
+ fprintf(ofp, "\t-> %s", link);
+ }
+ }
+ snprintf(path, sizeof(path), "%sinfo/%s", bfr, fn);
+ FILE *fp = fopen(path,"r"); int64_t pos;
+ if( fp ) {
+ while( fgets(link, sizeof(link), fp) ) {
+ if( sscanf(link, "pos:%jd", &pos) == 1 ) {
+ fprintf(ofp, "\tpos: %jd", pos);
+ break;
+ }
+ }
+ fclose(fp);
+ }
+ fprintf(ofp, "\n");
+ }
+ closedir(dir);
+}
+
// Can't use Mutex because it would be recursive
static pthread_mutex_t *handler_lock = 0;
}
fprintf(fp,"\nVERSION:\n"); bc_copy_textfile(INT_MAX, fp,"/proc/version");
fprintf(fp,"\nMEMINFO:\n"); bc_copy_textfile(INT_MAX, fp,"/proc/meminfo");
+ fprintf(fp,"\nSTATUS:\n"); bc_copy_textfile(INT_MAX, fp,"/proc/%d/status",pid);
+ fprintf(fp,"\nFD:\n"); bc_list_openfiles(INT_MAX, fp,"/proc/%d/fd", pid);
fprintf(fp,"\nMAPS:\n"); bc_copy_textfile(INT_MAX, fp,"/proc/%d/maps",pid);
char proc_mem[64];
if( tid > 0 && tid != pid )
#define TO_RAD(x) ((x) * 2 * M_PI / 360)
#define TO_DEG(x) ((x) * 360 / 2 / M_PI)
-static inline int bmin(int a, int b) { return a < b ? a : b; }
-static inline float bmin(float a, float b) { return a < b ? a : b; }
-static inline double bmin(double a, double b) { return a < b ? a : b; }
-static inline int bmax(int a, int b) { return a > b ? a : b; }
-static inline float bmax(float a, float b) { return a > b ? a : b; }
-static inline double bmax(double a, double b) { return a > b ? a : b; }
+#define bc_always_inline __attribute__ ((__always_inline__)) inline
-static inline int bclip(int &iv, int imn, int imx) {
+static bc_always_inline int bmin(int a, int b) { return a < b ? a : b; }
+static bc_always_inline float bmin(float a, float b) { return a < b ? a : b; }
+static bc_always_inline double bmin(double a, double b) { return a < b ? a : b; }
+static bc_always_inline int bmax(int a, int b) { return a > b ? a : b; }
+static bc_always_inline float bmax(float a, float b) { return a > b ? a : b; }
+static bc_always_inline double bmax(double a, double b) { return a > b ? a : b; }
+
+static bc_always_inline int iclip(int iv, int imn, int imx) {
+ return iv < imn ? imn : iv > imx ? imx : iv;
+}
+static bc_always_inline int bclip(int &iv, int imn, int imx) {
return iv < imn ? imn : iv > imx ? imx : iv;
}
-static inline float bclip(float &fv, float fmn, float fmx) {
+static bc_always_inline float bclip(float &fv, float fmn, float fmx) {
return fv < fmn ? fmn : fv > fmx ? fmx : fv;
}
-static inline double bclip(double &dv, double dmn, double dmx) {
+static bc_always_inline double bclip(double &dv, double dmn, double dmx) {
return dv < dmn ? dmn : dv > dmx ? dmx : dv;
}
-static inline void bclamp(int &iv, int imn, int imx) {
+
+static bc_always_inline void bclamp(int &iv, int imn, int imx) {
if( iv < imn ) iv = imn; else if( iv > imx ) iv = imx;
}
-static inline void bclamp(float &fv, float fmn, float fmx) {
+static bc_always_inline void bclamp(float &fv, float fmn, float fmx) {
if( fv < fmn ) fv = fmn; else if( fv > fmx ) fv = fmx;
}
-static inline void bclamp(double &dv, double dmn, double dmx) {
+static bc_always_inline void bclamp(double &dv, double dmn, double dmx) {
if( dv < dmn ) dv = dmn; else if( dv > dmx ) dv = dmx;
}
-static inline void bc_rgb2yuv(float r, float g, float b, float &y, float &u, float &v)
-{ //bt601, jpeg, unclipped
- y = 0.29900*r + 0.58700*g + 0.11400*b;
- u = -0.16874*r - 0.33126*g + 0.50000*b + 0.5;
- v = 0.50000*r - 0.41869*g - 0.08131*b + 0.5;
-}
-static inline void bc_rgb2yuv(int r, int g, int b, int &y, int &u, int &v, int max=255)
-{ // clipped
- float mx = max, fr = r/mx, fg = g/mx, fb = b/mx, fy, fu, fv;
- bc_rgb2yuv(fr,fg,fb, fy,fu,fv);
- y = (int)(fy * mx + 0.5); bclamp(y,0,max);
- u = (int)(fu * mx + 0.5); bclamp(u,0,max);
- v = (int)(fv * mx + 0.5); bclamp(v,0,max);
-}
-static inline void bc_yuv2rgb(float y, float u, float v, float &r, float &g, float &b)
-{ //bt601, jpeg, unclipped
- r = y + 1.40200*v;
- g = y - 0.34414*u - 0.71414*v;
- b = y + 1.77200*u;
-}
-static inline void bc_yuv2rgb(int y, int u, int v, int &r, int &g, int &b, int max=255)
-{ // clipped
- int ofs = (max + 1) / 2;
- float mx = max, fy = y/mx, fu = (u-ofs)/mx, fv = (v-ofs)/mx, fr, fg, fb;
- bc_yuv2rgb(fy,fu,fv, fr,fg,fb);
- r = (int)(fr * mx + 0.5); bclamp(r,0,max);
- g = (int)(fg * mx + 0.5); bclamp(g,0,max);
- b = (int)(fb * mx + 0.5); bclamp(b,0,max);
-}
#endif
--- /dev/null
+#include <stdio.h>
+#include <math.h>
+#include "bccolors.C"
+
+//c++ -g -I../guicast test5.C ../guicast/x86_64/libguicast.a \
+// -DHAVE_GL -DHAVE_XFT -I/usr/include/freetype2 -lGL -lX11 -lXext \
+// -lXinerama -lXv -lpng -lfontconfig -lfreetype -lXft -pthread
+
+int main(int ac, char **av)
+{
+ int rgb2yuv = atoi(av[1]);
+ int color = atoi(av[2]);
+ int range = atoi(av[3]);
+
+ YUV::yuv.yuv_set_colors(color, range);
+ if( !rgb2yuv ) {
+ for( int y=0; y<0x100; ++y ) {
+ for( int u=0; u<0x100; ++u ) {
+ for( int v=0; v<0x100; ++v ) {
+ float fy = y/255.f, fu = u/255.f - 0.5f, fv = v/255.f - 0.5f;
+ float fr, fg, fb; YUV::yuv.yuv_to_rgb_f(fr,fg,fb, fy,fu,fv);
+ if( fr<0 || fr>1 || fg<0 || fg>1 || fb<0 || fb>1 )
+ continue;
+ float yy, uu, vv; YUV::yuv.rgb_to_yuv_f(fr,fg,fb, yy,uu,vv);
+ float d = fabsf(fy-yy) + fabsf(fu-uu) + fabsf(fv-vv);
+ int rr = fr*256, gg = fg*256, bb = fb*256;
+ CLAMP(rr,0,255); CLAMP(gg,0,255); CLAMP(bb,0,255);
+ printf("yuv 0x%02x 0x%02x 0x%02x =%f,%f,%f, "
+ "rgb 0x%02x 0x%02x 0x%02x =%f,%f,%f, "
+ " %f,%f,%f, %f\n",
+ y,u,v, fy,fu,fv, rr,gg,bb, fr,fg,fb, yy,uu,vv, d);
+ }
+ }
+ }
+ }
+ else {
+ for( int r=0; r<0x100; ++r ) {
+ for( int g=0; g<0x100; ++g ) {
+ for( int b=0; b<0x100; ++b ) {
+ float fr = r/255.f, fg = g/255.f, fb = b/255.f;
+ float fy, fu, fv; YUV::yuv.rgb_to_yuv_f(fr,fg,fb, fy,fu,fv);
+ if( fy<0 || fy>1 || fu<0 || fu>1 || fv<0 || fv>1 )
+ continue;
+ float rr, gg, bb; YUV::yuv.yuv_to_rgb_f(rr,gg,bb, fy,fu,fv);
+ float d = fabsf(fr-rr) + fabsf(fg-gg) + fabsf(fb-bb);
+ int yy = fy*256, uu = fu*256, vv = fv*256;
+ CLAMP(yy,0,255); CLAMP(uu,0,255); CLAMP(vv,0,255);
+ printf("rgb 0x%02x 0x%02x 0x%02x =%f,%f,%f, "
+ "yuv 0x%02x 0x%02x 0x%02x =%f,%f,%f, "
+ " %f,%f,%f, %f\n",
+ r,g,b, fr,fg,fb, yy,uu,vv, fy,fu,fv, rr,gg,bb, d);
+ }
+ }
+ }
+ }
+ return 0;
+}
+
use_shm = frame.use_shm;
allocate_data(0, -1, 0, 0, 0, frame.w, frame.h,
frame.color_model, frame.bytes_per_line);
- copy_from(&frame);
+ copy_vframe(&frame);
}
+
VFrame::VFrame(int w, int h, int color_model, long bytes_per_line)
{
reset_parameters(1);
void VFrame::flip_vert()
{
- unsigned char *temp = new unsigned char[bytes_per_line];
- for(int i = 0, j = h - 1; i < j; i++, j--)
- {
+ unsigned char temp[bytes_per_line];
+ for( int i=0, j=h; --j>i; ++i ) {
memcpy(temp, rows[j], bytes_per_line);
memcpy(rows[j], rows[i], bytes_per_line);
memcpy(rows[i], temp, bytes_per_line);
}
- delete [] temp;
}
void VFrame::flip_horiz()
break;
}
- params->copy_from(frame->params);
return 0;
}
int VFrame::transfer_from(VFrame *that, int bg_color, int in_x, int in_y, int in_w, int in_h)
{
+ timestamp = that->timestamp;
+ copy_params(that);
+
if( this->get_color_model() == that->get_color_model() &&
this->get_w() == that->get_w() && this->get_h() == that->get_h() &&
this->get_bytes_per_line() == that->get_bytes_per_line() )
return this->copy_from(that);
- timestamp = that->timestamp;
#if 0
BC_CModels::transfer(
this->get_rows(), that->get_rows(), // Packed data out/in
that->get_bytes_per_line(),
bg_color);
#endif
- params->copy_from(that->params);
return 0;
}
{
clear_stacks();
- for(int i = 0; i < src->next_effects.total; i++)
- {
- char *ptr;
- next_effects.append(ptr = new char[strlen(src->next_effects.values[i]) + 1]);
- strcpy(ptr, src->next_effects.values[i]);
- }
- for(int i = 0; i < src->prev_effects.total; i++)
- {
- char *ptr;
- prev_effects.append(ptr = new char[strlen(src->prev_effects.values[i]) + 1]);
- strcpy(ptr, src->prev_effects.values[i]);
- }
+ for( int i=0; i < src->next_effects.total; ++i )
+ next_effects.append(cstrdup(src->next_effects[i]));
+ for( int i=0; i < src->prev_effects.total; ++i )
+ prev_effects.append(cstrdup(src->prev_effects[i]));
copy_params(src);
}
+int VFrame::copy_vframe(VFrame *frame)
+{
+ copy_stacks(frame);
+ return copy_from(frame);
+}
+
int VFrame::equal_stacks(VFrame *src)
{
for(int i = 0; i < src->next_effects.total && i < next_effects.total; i++)
int ir = 0xff & (pixel_rgb >> 16);
int ig = 0xff & (pixel_rgb >> 8);
int ib = 0xff & (pixel_rgb >> 0);
- bc_rgb2yuv(ir,ig,ib, ir,ig,ib);
+ YUV::yuv.rgb_to_yuv_8(ir, ig, ib);
pixel_yuv = (ir<<16) | (ig<<8) | (ib<<0);
}
// direct copy with no alpha
int copy_from(VFrame *frame);
+ int copy_vframe(VFrame *src);
// BC_CModels::transfer
int transfer_from(VFrame *frame, int bg_color, int in_x, int in_y, int in_w, int in_h);
int transfer_from(VFrame *frame, int bg_color=0) {
// Adds the program with put_shader.
// Returns the program handle.
// Requires a null terminated argument list of shaders to link together.
+// if fragments is not NULL, it is a a zero terminated list of frags
+// if fragments is NULL, then a zero terminated list of va_args frags
// At least one shader argument must have a main() function. make_shader
// replaces all the main() functions with unique functions and calls them in
// sequence, so multiple independant shaders can be linked.
-// x is a placeholder for va_arg and should be 0.
- static unsigned int make_shader(int x, ...);
+ static unsigned int make_shader(const char **fragments, ...);
static void dump_shader(int shader_id);
// Because OpenGL is faster if multiple effects are combined, we need
+// call as:
+// make_shader(0, frag1, .., fragn, 0);
+// or make_shader(fragments);
-
-unsigned int VFrame::make_shader(int x, ...)
+unsigned int VFrame::make_shader(const char **fragments, ...)
{
unsigned int result = 0;
#ifdef HAVE_GL
// Construct single source file out of arguments
- char *complete_program = 0;
- int complete_size = 0;
- int current_shader = 0;
-
- va_list list;
- va_start(list, x);
-
- while(1)
- {
- char *text = va_arg(list, char*);
- if(!text) break;
-
-// Replace one occurrance in each source of main() with a unique id.
- char main_replacement[BCTEXTLEN];
- sprintf(main_replacement, "main%03d()", current_shader);
-//printf("VFrame::make_shader %s %s\n", text, main_replacement);
- char *source_replacement = new char[strlen(text) + strlen(main_replacement) + 1];
- char *ptr = strstr(text, "main()");
-
- if(ptr)
- {
- memcpy(source_replacement, text, ptr - text);
- source_replacement[ptr - text] = 0;
- strcat(source_replacement, main_replacement);
- ptr += strlen("main()");
- strcat(source_replacement, ptr);
- current_shader++;
- }
- else
- {
- memcpy(source_replacement, text, strlen(text));
- source_replacement[strlen(text)] = 0;
- }
-
- if(!complete_program)
- {
- complete_size = strlen(source_replacement) + 1;
- complete_program = (char*)malloc(complete_size);
- strcpy(complete_program, source_replacement);
- }
- else
- {
- complete_size += strlen(source_replacement);
- complete_program = (char*)realloc(complete_program, complete_size);
- strcat(complete_program, source_replacement);
- }
-
- delete [] source_replacement;
+ char *program = 0;
+ int nb_mains = 0;
+
+ int nb_frags = 1;
+ if( !fragments ) {
+ va_list list; va_start(list, fragments);
+ while( va_arg(list, char*) != 0 ) ++nb_frags;
+ va_end(list);
}
- va_end(list);
-
-// Add main() function which calls all the unique main replacements in order
- char main_function[BCTEXTLEN];
- sprintf(main_function,
- "\n"
- "void main()\n"
- "{\n");
-
- for(int i = 0; i < current_shader; i++)
- {
- char main_replacement[BCTEXTLEN];
- sprintf(main_replacement, "\tmain%03d();\n", i);
- strcat(main_function, main_replacement);
+ const char *frags[nb_frags], *text = 0;
+ if( !fragments ) {
+ va_list list; va_start(list, fragments);
+ for( int i=0; i<nb_frags; ++i ) frags[i] = va_arg(list, char*);
+ va_end(list);
+ fragments = frags;
}
- strcat(main_function, "}\n");
- if(!complete_program)
- {
- complete_size = strlen(main_function) + 1;
- complete_program = (char*)malloc(complete_size);
- strcpy(complete_program, main_function);
- }
- else
- {
- complete_size += strlen(main_function);
- complete_program = (char*)realloc(complete_program, complete_size);
- strcat(complete_program, main_function);
- }
-
-
+ while( (text = *fragments++) ) {
+ char src[strlen(text) + BCSTRLEN + 1];
+ const char *tp = strstr(text, "main()");
+ if( tp ) {
+// Replace main() with a mainxxx()
+ char mainxxx[BCSTRLEN], *sp = src;
+ sprintf(mainxxx, "main%03d()", nb_mains++);
+ int n = tp - text;
+ memcpy(sp, text, n); sp += n;
+ n = strlen(mainxxx);
+ memcpy(sp, mainxxx, n); sp += n;
+ tp += strlen("main()");
+ strcpy(sp, tp);
+ text = src;
+ }
+ char *new_program = !program ? cstrdup(text) :
+ cstrcat(2, program, text);
+ delete [] program; program = new_program;
+ }
+// Add main() which calls mainxxx() in order
+ char main_program[BCTEXTLEN], *cp = main_program;
+ cp += sprintf(cp, "\nvoid main() {\n");
+ for( int i=0; i < nb_mains; ++i )
+ cp += sprintf(cp, "\tmain%03d();\n", i);
+ cp += sprintf(cp, "}\n");
+ cp = !program ? cstrdup(main_program) :
+ cstrcat(2, program, main_program);
+ delete [] program; program = cp;
int got_it = 0;
- result = BC_WindowBase::get_synchronous()->get_shader(complete_program,
- &got_it);
-
- if(!got_it)
- {
+ result = BC_WindowBase::get_synchronous()->get_shader(program, &got_it);
+ if( !got_it ) {
result = glCreateProgram();
-
- unsigned int shader;
- shader = glCreateShader(GL_FRAGMENT_SHADER);
- const GLchar *text_ptr = complete_program;
+ unsigned int shader = glCreateShader(GL_FRAGMENT_SHADER);
+ const GLchar *text_ptr = program;
glShaderSource(shader, 1, &text_ptr, NULL);
glCompileShader(shader);
- int error = print_error(complete_program, shader, 0);
+ int error = print_error(program, shader, 0);
glAttachShader(result, shader);
glDeleteShader(shader);
-
glLinkProgram(result);
- if(!error) error = print_error(complete_program, result, 1);
-
-
-// printf("BC_WindowBase::make_shader: shader=%d window_id=%d\n",
-// result,
+ if( !error )
+ error = print_error(program, result, 1);
+//printf("BC_WindowBase::make_shader: shader=%d window_id=%d\n", result,
// BC_WindowBase::get_synchronous()->current_window->get_id());
- BC_WindowBase::get_synchronous()->put_shader(result, complete_program);
+ BC_WindowBase::get_synchronous()->put_shader(result, program);
}
-//printf("VFrame::make_shader\n%s\n", complete_program);
- free(complete_program);
- complete_program = NULL;
-
+//printf("VFrame::make_shader\n%s\n", program);
#endif
return result;
}
static inline void HSpV_correct_RGB(float H, float Sp, float &V, float &R, float &G, float &B){
float vp = Sp<0.f?0.f:(fabs(V)+HSpV_SATURATION_BIAS)*Sp*HSpV_SATURATION_ISCALE;
+#define R_TO_Y (Kr)
+#define G_TO_Y (Kg)
+#define B_TO_Y (Kb)
+
int i = (int)H;
switch(i){
default:
*
*/
-#include "clip.h"
-#include "filexml.h"
#include "brightness.h"
+#include "bccolors.h"
#include "bchash.h"
+#include "clip.h"
+#include "filexml.h"
#include "language.h"
+#include "playback3d.h"
#include <stdio.h>
#include <stdint.h>
"uniform float brightness;\n"
"uniform float contrast;\n"
"uniform float offset;\n"
+ "uniform mat3 yuv_to_rgb_matrix;\n"
+ "uniform mat3 rgb_to_yuv_matrix;\n"
+
"void main()\n"
"{\n"
- " const mat3 yuv_to_rgb_matrix = mat3(\n"
- " 1, 1, 1, \n"
- " 0, -0.34414, 1.77200, \n"
- " 1.40200, -0.71414, 0);\n"
- " const mat3 rgb_to_yuv_matrix = mat3(\n"
- " 0.29900, -0.16874, 0.50000, \n"
- " 0.58700, -0.33126, -0.41869, \n"
- " 0.11400, 0.50000, -0.08131);\n"
" vec4 rgba = texture2D(tex, gl_TexCoord[0].st);\n"
" rgba.rgb = rgb_to_yuv_matrix * rgba.rgb;\n"
" rgba.r += brightness;\n"
get_output()->to_texture();
get_output()->enable_opengl();
+ int need_matrix = 0;
+ const char *brightness_frag = BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ (config.luma ? (need_matrix = 0, brightness_yuvluma_frag) : brightness_yuv_frag) :
+ (config.luma ? (need_matrix = 1, brightness_rgbluma_frag) : brightness_rgb_frag) ;
- unsigned int shader_id = 0;
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- if(config.luma)
- shader_id = VFrame::make_shader(0,
- brightness_yuvluma_frag,
- 0);
- else
- shader_id = VFrame::make_shader(0,
- brightness_yuv_frag,
- 0);
- break;
- default:
- if(config.luma)
- shader_id = VFrame::make_shader(0,
- brightness_rgbluma_frag,
- 0);
- else
- shader_id = VFrame::make_shader(0,
- brightness_rgb_frag,
- 0);
- break;
- }
-
-
- if(shader_id > 0)
- {
+ unsigned int shader_id = VFrame::make_shader(0, brightness_frag, 0);
+ if( shader_id > 0 ) {
glUseProgram(shader_id);
glUniform1i(glGetUniformLocation(shader_id, "tex"), 0);
glUniform1f(glGetUniformLocation(shader_id, "brightness"), config.brightness / 100);
glUniform1f(glGetUniformLocation(shader_id, "contrast"), contrast);
float offset = 0.5 - contrast / 2;
glUniform1f(glGetUniformLocation(shader_id, "offset"), offset);
+ if( need_matrix ) {
+ BC_GL_MATRIX(shader_id, yuv_to_rgb_matrix);
+ BC_GL_MATRIX(shader_id, rgb_to_yuv_matrix);
+ }
}
get_output()->init_screen();
*
*/
+#include "bccolors.h"
#include "bcdisplayinfo.h"
#include "bcsignals.h"
#include "chromakey.h"
//float max_hue = h + plugin->config.threshold * 360 / 100;
-#define RGB_TO_VALUE(r, g, b) \
-((r) * R_TO_Y + (g) * G_TO_Y + (b) * B_TO_Y)
-
+#define RGB_TO_VALUE(r, g, b) YUV::yuv.rgb_to_y_f((r),(g),(b))
#define OUTER_VARIABLES(plugin) \
float value = RGB_TO_VALUE(plugin->config.red, \
"}\n";
static const char *get_rgbvalue_frag =
+ "uniform mat3 rgb_to_yuv_matrix;\n"
+ "uniform float yminf;\n"
"float get_value(vec4 color)\n"
"{\n"
- " return dot(color.rgb, vec3(0.29900, 0.58700, 0.11400));\n"
+ " return dot(color.rgb, rgb_to_yuv_matrix[0]) + yminf;\n"
"}\n";
static const char *value_frag =
get_output()->to_texture();
get_output()->enable_opengl();
get_output()->init_screen();
- const char *shader_stack[] = { 0, 0, 0, 0, 0 };
- int current_shader = 0;
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
shader_stack[current_shader++] = uniform_frag;
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- if(config.use_value)
- {
- shader_stack[current_shader++] = get_yuvvalue_frag;
- shader_stack[current_shader++] = value_frag;
- }
- else
- {
- shader_stack[current_shader++] = cube_frag;
- }
- break;
- default:
- if(config.use_value)
- {
- shader_stack[current_shader++] = get_rgbvalue_frag;
- shader_stack[current_shader++] = value_frag;
- }
- else
- {
- shader_stack[current_shader++] = cube_frag;
- }
- break;
+ switch(get_output()->get_color_model()) {
+ case BC_YUV888:
+ case BC_YUVA8888:
+ if( config.use_value ) {
+ shader_stack[current_shader++] = get_yuvvalue_frag;
+ shader_stack[current_shader++] = value_frag;
+ }
+ else {
+ shader_stack[current_shader++] = cube_frag;
+ }
+ break;
+
+ default:
+ if(config.use_value) {
+ shader_stack[current_shader++] = get_rgbvalue_frag;
+ shader_stack[current_shader++] = value_frag;
+ }
+ else {
+ shader_stack[current_shader++] = cube_frag;
+ }
+ break;
}
SET_TRACE
- unsigned int frag = VFrame::make_shader(0,
- shader_stack[0],
- shader_stack[1],
- shader_stack[2],
- shader_stack[3],
- 0);
- get_output()->bind_texture(0);
-
- if(frag)
- {
- glUseProgram(frag);
- glUniform1i(glGetUniformLocation(frag, "tex"), 0);
- glUniform1f(glGetUniformLocation(frag, "min_v"), min_v);
- glUniform1f(glGetUniformLocation(frag, "max_v"), max_v);
- glUniform1f(glGetUniformLocation(frag, "run"), run);
- glUniform1f(glGetUniformLocation(frag, "threshold"), threshold);
- glUniform1f(glGetUniformLocation(frag, "threshold_run"), threshold_run);
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ get_output()->bind_texture(0);
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "min_v"), min_v);
+ glUniform1f(glGetUniformLocation(shader, "max_v"), max_v);
+ glUniform1f(glGetUniformLocation(shader, "run"), run);
+ glUniform1f(glGetUniformLocation(shader, "threshold"), threshold);
+ glUniform1f(glGetUniformLocation(shader, "threshold_run"), threshold_run);
if(get_output()->get_color_model() != BC_YUV888 &&
get_output()->get_color_model() != BC_YUVA8888)
- glUniform3f(glGetUniformLocation(frag, "key"),
+ glUniform3f(glGetUniformLocation(shader, "key"),
r_key, g_key, b_key);
else
- glUniform3f(glGetUniformLocation(frag, "key"),
+ glUniform3f(glGetUniformLocation(shader, "key"),
(float)y_key / 0xff, (float)u_key / 0xff, (float)v_key / 0xff);
-
+ if(config.use_value)
+ BC_GL_RGB_TO_YUV(shader);
}
SET_TRACE
for (int j = 0; j < w; j++)
{
- float a = 1;
-
- float r = (float) row[0] / max;
- float g = (float) row[1] / max;
- float b = (float) row[2] / max;
+ float r, g, b, a = 1;
+ if (!use_yuv) {
+ r = (float) row[0] / max;
+ g = (float) row[1] / max;
+ b = (float) row[2] / max;
+ }
+ else
+ YUV::yuv.yuv_to_rgb_f (r, g, b, row[0], row[1], row[2]);
float h, s, v;
float av = 1, ah = 1, as = 1, avm = 1;
bool has_match = true;
- if (use_yuv)
- {
-/* Convert pixel to RGB float */
- float y = r;
- float u = g;
- float v = b;
- YUV::yuv.yuv_to_rgb_f (r, g, b, y, u - 0.5, v - 0.5);
- }
-
HSV::rgb_to_hsv (r, g, b, h, s, v);
// First, test if the hue is in range
/* Hue wrap */
if(h <= hue_key - tolerance_in * 180.0)
- h += 360;
+ h += 360.0;
else
if(h >= hue_key + tolerance_in * 180.0)
- h -= 360;
+ h -= 360.0;
if (tolerance == 0)
HSV::hsv_to_rgb (r, g, b, h, s, v);
- if (use_yuv)
- {
- float y;
- float u;
- float v;
- YUV::yuv.rgb_to_yuv_f (r, g, b, y, u, v);
- CLAMP (y, 0, 1.0);
- CLAMP (u, 0, 1.0);
- CLAMP (v, 0, 1.0);
- row[0] = (component_type) ((float) y * max);
- row[1] = (component_type) ((float) (u + 0.5) * max);
- row[2] = (component_type) ((float) (v + 0.5) * max);
+ if (!use_yuv) {
+ row[0] = (component_type) ((float) r * max);
+ row[1] = (component_type) ((float) g * max);
+ row[2] = (component_type) ((float) b * max);
}
- else
- {
- CLAMP (r, 0, 1.0);
- CLAMP (g, 0, 1.0);
- CLAMP (b, 0, 1.0);
- row[0] = (component_type) ((float) r * max);
- row[1] = (component_type) ((float) g * max);
- row[2] = (component_type) ((float) b * max);
- }
- }
+ else
+ YUV::yuv.rgb_to_yuv_f(r, g, b, row[0], row[1], row[2]);
+ }
a += alpha_offset;
CLAMP (a, 0.0, 1.0);
static const char *yuv_shader =
"const vec3 black = vec3(0.0, 0.5, 0.5);\n"
+ "uniform mat3 yuv_to_rgb_matrix;\n"
+ "uniform mat3 rgb_to_yuv_matrix;\n"
+ "uniform float yminf;\n"
"\n"
"vec4 yuv_to_rgb(vec4 color)\n"
"{\n"
- YUV_TO_RGB_FRAG("color")
+ " color.rgb -= vec3(yminf, 0.5, 0.5);\n"
+ " color.rgb = yuv_to_rgb_matrix * color.rgb;\n"
" return color;\n"
"}\n"
"\n"
"vec4 rgb_to_yuv(vec4 color)\n"
"{\n"
- RGB_TO_YUV_FRAG("color")
+ " color.rgb = rgb_to_yuv_matrix * color.rgb;\n"
+ " color.rgb += vec3(yminf, 0.5, 0.5);\n"
" return color;\n"
"}\n";
" return vec4(color.rgb, min(color.a, color2.a));"
"}\n";
- extern unsigned char _binary_chromakey_sl_start[];
- static const char *shader = (char*)_binary_chromakey_sl_start;
-
get_output()->to_texture();
get_output()->enable_opengl();
get_output()->init_screen();
- const char* shader_stack[] = { 0, 0, 0, 0, 0 };
-
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- shader_stack[0] = yuv_shader;
- shader_stack[1] = hsv_shader;
- if(config.show_mask)
- shader_stack[2] = show_yuvmask_shader;
- else
- shader_stack[2] = nomask_shader;
- shader_stack[3] = shader;
- break;
-
- default:
- shader_stack[0] = rgb_shader;
- shader_stack[1] = hsv_shader;
- if(config.show_mask)
- shader_stack[2] = show_rgbmask_shader;
- else
- shader_stack[2] = nomask_shader;
- shader_stack[3] = shader;
- break;
- }
-
-
- unsigned int frag = VFrame::make_shader(0,
- shader_stack[0],
- shader_stack[1],
- shader_stack[2],
- shader_stack[3],
- 0);
-
- if(frag)
- {
- glUseProgram(frag);
- glUniform1i(glGetUniformLocation(frag, "tex"), 0);
- glUniform1f(glGetUniformLocation(frag, "red"), red);
- glUniform1f(glGetUniformLocation(frag, "green"), green);
- glUniform1f(glGetUniformLocation(frag, "blue"), blue);
- glUniform1f(glGetUniformLocation(frag, "in_slope"), in_slope);
- glUniform1f(glGetUniformLocation(frag, "out_slope"), out_slope);
- glUniform1f(glGetUniformLocation(frag, "tolerance"), tolerance);
- glUniform1f(glGetUniformLocation(frag, "tolerance_in"), tolerance_in);
- glUniform1f(glGetUniformLocation(frag, "tolerance_out"), tolerance_out);
- glUniform1f(glGetUniformLocation(frag, "sat"), sat);
- glUniform1f(glGetUniformLocation(frag, "min_s"), min_s);
- glUniform1f(glGetUniformLocation(frag, "min_s_in"), min_s_in);
- glUniform1f(glGetUniformLocation(frag, "min_s_out"), min_s_out);
- glUniform1f(glGetUniformLocation(frag, "min_v"), min_v);
- glUniform1f(glGetUniformLocation(frag, "min_v_in"), min_v_in);
- glUniform1f(glGetUniformLocation(frag, "min_v_out"), min_v_out);
- glUniform1f(glGetUniformLocation(frag, "max_v"), max_v);
- glUniform1f(glGetUniformLocation(frag, "max_v_in"), max_v_in);
- glUniform1f(glGetUniformLocation(frag, "max_v_out"), max_v_out);
- glUniform1f(glGetUniformLocation(frag, "spill_threshold"), spill_threshold);
- glUniform1f(glGetUniformLocation(frag, "spill_amount"), spill_amount);
- glUniform1f(glGetUniformLocation(frag, "alpha_offset"), alpha_offset);
- glUniform1f(glGetUniformLocation(frag, "hue_key"), hue_key);
- glUniform1f(glGetUniformLocation(frag, "saturation_key"), saturation_key);
- glUniform1f(glGetUniformLocation(frag, "value_key"), value_key);
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
+
+ shader_stack[current_shader++] = \
+ !BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ rgb_shader : yuv_shader;
+ shader_stack[current_shader++] = hsv_shader;
+ shader_stack[current_shader++] = !config.show_mask ? nomask_shader :
+ !BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ show_rgbmask_shader : show_yuvmask_shader ;
+ extern unsigned char _binary_chromakey_sl_start[];
+ static const char *shader_frag = (char*)_binary_chromakey_sl_start;
+ shader_stack[current_shader++] = shader_frag;
+
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "red"), red);
+ glUniform1f(glGetUniformLocation(shader, "green"), green);
+ glUniform1f(glGetUniformLocation(shader, "blue"), blue);
+ glUniform1f(glGetUniformLocation(shader, "in_slope"), in_slope);
+ glUniform1f(glGetUniformLocation(shader, "out_slope"), out_slope);
+ glUniform1f(glGetUniformLocation(shader, "tolerance"), tolerance);
+ glUniform1f(glGetUniformLocation(shader, "tolerance_in"), tolerance_in);
+ glUniform1f(glGetUniformLocation(shader, "tolerance_out"), tolerance_out);
+ glUniform1f(glGetUniformLocation(shader, "sat"), sat);
+ glUniform1f(glGetUniformLocation(shader, "min_s"), min_s);
+ glUniform1f(glGetUniformLocation(shader, "min_s_in"), min_s_in);
+ glUniform1f(glGetUniformLocation(shader, "min_s_out"), min_s_out);
+ glUniform1f(glGetUniformLocation(shader, "min_v"), min_v);
+ glUniform1f(glGetUniformLocation(shader, "min_v_in"), min_v_in);
+ glUniform1f(glGetUniformLocation(shader, "min_v_out"), min_v_out);
+ glUniform1f(glGetUniformLocation(shader, "max_v"), max_v);
+ glUniform1f(glGetUniformLocation(shader, "max_v_in"), max_v_in);
+ glUniform1f(glGetUniformLocation(shader, "max_v_out"), max_v_out);
+ glUniform1f(glGetUniformLocation(shader, "spill_threshold"), spill_threshold);
+ glUniform1f(glGetUniformLocation(shader, "spill_amount"), spill_amount);
+ glUniform1f(glGetUniformLocation(shader, "alpha_offset"), alpha_offset);
+ glUniform1f(glGetUniformLocation(shader, "hue_key"), hue_key);
+ glUniform1f(glGetUniformLocation(shader, "saturation_key"), saturation_key);
+ glUniform1f(glGetUniformLocation(shader, "value_key"), value_key);
+ if( BC_CModels::is_yuv(get_output()->get_color_model()) )
+ BC_GL_COLORS(shader);
}
-
get_output()->bind_texture(0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
/* Hue wrap */
if(color2.r <= hue_key - tolerance_in * 180.0)
- color2.r += 360;
+ color2.r += 360.0;
else
if(color2.r >= hue_key + tolerance_in * 180.0)
- color2.r -= 360;
+ color2.r -= 360.0;
/* Hue is completely out of range */
if (tolerance == 0.0)
+++ /dev/null
-
-/*
- * CINELERRA
- * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#ifndef COLORBALANCE_AGGREGATED
-#define COLORBALANCE_AGGREGATED
-
-static const char *colorbalance_get_pixel1 =
- "vec4 colorbalance_get_pixel()\n"
- "{\n"
- " return gl_FragColor;\n"
- "}\n";
-
-static const char *colorbalance_get_pixel2 =
- "uniform sampler2D tex;\n"
- "vec4 colorbalance_get_pixel()\n"
- "{\n"
- " return texture2D(tex, gl_TexCoord[0].st);\n"
- "}\n";
-
-
-static const char *colorbalance_rgb_shader =
- "uniform vec3 colorbalance_scale;\n"
- "void main()\n"
- "{\n"
- " gl_FragColor = colorbalance_get_pixel();\n"
- " gl_FragColor.rgb *= colorbalance_scale;\n"
- "}\n";
-
-static const char *colorbalance_yuv_shader =
- "uniform vec3 colorbalance_scale;\n"
- "void main()\n"
- "{\n"
- " gl_FragColor = colorbalance_get_pixel();\n"
- YUV_TO_RGB_FRAG("gl_FragColor")
- " gl_FragColor.rgb *= colorbalance_scale;\n"
- RGB_TO_YUV_FRAG("gl_FragColor")
- "}\n";
-
-static const char *colorbalance_yuv_preserve_shader =
- "uniform vec3 colorbalance_scale;\n"
- "void main()\n"
- "{\n"
- " gl_FragColor = colorbalance_get_pixel();\n"
- " float y = gl_FragColor.r;\n"
- YUV_TO_RGB_FRAG("gl_FragColor")
- " gl_FragColor.rgb *= colorbalance_scale.rgb;\n"
- RGB_TO_YUV_FRAG("gl_FragColor")
- " gl_FragColor.r = y;\n"
- "}\n";
-
-#define COLORBALANCE_COMPILE(shader_stack, current_shader, aggregate_prev) \
-{ \
- if(aggregate_prev) \
- shader_stack[current_shader++] = colorbalance_get_pixel1; \
- else \
- shader_stack[current_shader++] = colorbalance_get_pixel2; \
- if(BC_CModels::is_yuv(get_output()->get_color_model())) \
- {\
- if(get_output()->get_params()->get("COLORBALANCE_PRESERVE", (int)0)) \
- shader_stack[current_shader++] = colorbalance_yuv_preserve_shader; \
- else \
- shader_stack[current_shader++] = colorbalance_yuv_shader; \
- } \
- else \
- shader_stack[current_shader++] = colorbalance_rgb_shader; \
-}
-
-#define COLORBALANCE_UNIFORMS(shader) \
- glUniform3f(glGetUniformLocation(shader, "colorbalance_scale"), \
- get_output()->get_params()->get("COLORBALANCE_CYAN", (float)1), \
- get_output()->get_params()->get("COLORBALANCE_MAGENTA", (float)1), \
- get_output()->get_params()->get("COLORBALANCE_YELLOW", (float)1));
-
-#endif
-
#include "language.h"
#include "playback3d.h"
-#include "aggregated.h"
-#include "../interpolate/aggregated.h"
-#include "../gamma/aggregated.h"
-
#include <stdio.h>
#include <string.h>
r = r + TOTAL_TRANSFER(r, r_factor); \
g = g + TOTAL_TRANSFER(g, g_factor); \
b = b + TOTAL_TRANSFER(b, b_factor); \
+ r = CLAMP(r,0,1); g = CLAMP(g,0,1); b = CLAMP(b,0,1); \
/* Apply saturation/value */ \
float h, s, v; \
HSV::rgb_to_hsv(r, g, b, h, s, v); \
v += TOTAL_TRANSFER(v, v_factor); \
s += TOTAL_TRANSFER(s, s_factor); \
- s = MAX(s, 0); \
+ s = CLAMP(s,0,1); v = CLAMP(v,0,1); \
HSV::hsv_to_rgb(r, g, b, h, s, v);
{ \
type *in = (type*)plugin->get_input()->get_rows()[i]; \
type *out = (type*)plugin->get_input()->get_rows()[i]; \
- for(int j = 0; j < w; j++) \
- { \
+ for(int j = 0; j < w; j++) { \
/* Convert to RGB float */ \
- float r; \
- float g; \
- float b; \
- if(is_yuv) \
- { \
- YUV::yuv.yuv_to_rgb_f(r, g, b, \
- (float)in[0] / max, \
- (float)in[1] / max - 0.5, \
- (float)in[2] / max - 0.5); \
- in += 3; \
+ float r, g, b; \
+ if( !is_yuv ) { \
+ r = (float)in[0] / max; \
+ g = (float)in[1] / max; \
+ b = (float)in[2] / max; \
} \
else \
- { \
- r = (float)*in++ / max; \
- g = (float)*in++ / max; \
- b = (float)*in++ / max; \
- } \
+ YUV::yuv.yuv_to_rgb_f(r, g, b, in[0], in[1], in[2]); \
\
PROCESS_PIXEL(r, g, b) \
\
+ if( !is_yuv ) { \
/* Convert to project colormodel */ \
- if(is_yuv) \
- { \
- float y, u, v; \
- YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v); \
- r = y; \
- g = u + 0.5; \
- b = v + 0.5; \
- } \
- if(max == 0xff) \
- { \
- CLAMP(r, 0, 1); \
- CLAMP(g, 0, 1); \
- CLAMP(b, 0, 1); \
- } \
- *out++ = (type)(r * max); \
- *out++ = (type)(g * max); \
- *out++ = (type)(b * max); \
- if(components == 4) \
- { \
- in++; \
- out++; \
+ if(max == 0xff) { \
+ CLAMP(r, 0, 1); \
+ CLAMP(g, 0, 1); \
+ CLAMP(b, 0, 1); \
+ } \
+ out[0] = (type)(r * max); \
+ out[1] = (type)(g * max); \
+ out[2] = (type)(b * max); \
} \
+ else \
+ YUV::yuv.rgb_to_yuv_f(r, g, b, out[0], out[1], out[2]); \
+ \
+ in += components; \
+ out += components; \
} \
}
get_aggregation(&aggregate_interpolate,
&aggregate_gamma);
-
-
engine->process_packages();
-
return 0;
}
}
}
-int Color3WayMain::handle_opengl()
-{
-#ifdef HAVE_GL
-
- get_output()->to_texture();
- get_output()->enable_opengl();
-
- unsigned int shader = 0;
- const char *shader_stack[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
- int current_shader = 0;
- int aggregate_interpolate = 0;
- int aggregate_gamma = 0;
-
- get_aggregation(&aggregate_interpolate,
- &aggregate_gamma);
-
-printf("Color3WayMain::handle_opengl %d %d\n", aggregate_interpolate, aggregate_gamma);
- if(aggregate_interpolate)
- INTERPOLATE_COMPILE(shader_stack, current_shader)
-
- if(aggregate_gamma)
- GAMMA_COMPILE(shader_stack, current_shader, aggregate_interpolate)
-
- COLORBALANCE_COMPILE(shader_stack,
- current_shader,
- aggregate_gamma || aggregate_interpolate)
-
- 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)
- {
- glUseProgram(shader);
- glUniform1i(glGetUniformLocation(shader, "tex"), 0);
-
- if(aggregate_interpolate) INTERPOLATE_UNIFORMS(shader);
- if(aggregate_gamma) GAMMA_UNIFORMS(shader);
-
- COLORBALANCE_UNIFORMS(shader);
-
- }
-
- get_output()->init_screen();
- get_output()->bind_texture(0);
- get_output()->draw_texture();
- glUseProgram(0);
- get_output()->set_opengl_state(VFrame::SCREEN);
-#endif
- return 0;
-}
-
-
-
-
-
-
void update_gui();
void save_data(KeyFrame *keyframe);
void read_data(KeyFrame *keyframe);
- int handle_opengl();
void get_aggregation(int *aggregate_interpolate,
int *aggregate_gamma);
"void main()\n"
"{\n"
" gl_FragColor = colorbalance_get_pixel();\n"
- YUV_TO_RGB_FRAG("gl_FragColor")
+ YUV_TO_RGB_FRAG("gl_FragColor")
" gl_FragColor.rgb *= colorbalance_scale;\n"
- RGB_TO_YUV_FRAG("gl_FragColor")
+ RGB_TO_YUV_FRAG("gl_FragColor")
"}\n";
static const char *colorbalance_yuv_preserve_shader =
"{\n"
" gl_FragColor = colorbalance_get_pixel();\n"
" float y = gl_FragColor.r;\n"
- YUV_TO_RGB_FRAG("gl_FragColor")
+ YUV_TO_RGB_FRAG("gl_FragColor")
" gl_FragColor.rgb *= colorbalance_scale.rgb;\n"
- RGB_TO_YUV_FRAG("gl_FragColor")
+ RGB_TO_YUV_FRAG("gl_FragColor")
" gl_FragColor.r = y;\n"
"}\n";
-#define COLORBALANCE_COMPILE(shader_stack, current_shader, aggregate_prev) \
-{ \
- if(aggregate_prev) \
- shader_stack[current_shader++] = colorbalance_get_pixel1; \
- else \
- shader_stack[current_shader++] = colorbalance_get_pixel2; \
- if(BC_CModels::is_yuv(get_output()->get_color_model())) \
- {\
- if(get_output()->get_params()->get("COLORBALANCE_PRESERVE", (int)0)) \
- shader_stack[current_shader++] = colorbalance_yuv_preserve_shader; \
- else \
- shader_stack[current_shader++] = colorbalance_yuv_shader; \
- } \
- else \
- shader_stack[current_shader++] = colorbalance_rgb_shader; \
-}
+#define COLORBALANCE_COMPILE(shader_stack, current_shader, aggregate_prev) do { \
+ shader_stack[current_shader++] = \
+ aggregate_prev ? colorbalance_get_pixel1 : colorbalance_get_pixel2; \
+ shader_stack[current_shader++] = \
+ !BC_CModels::is_yuv(get_output()->get_color_model()) ? colorbalance_rgb_shader : \
+ get_output()->get_params()->get("COLORBALANCE_PRESERVE", (int)0) ? \
+ colorbalance_yuv_preserve_shader : colorbalance_yuv_shader ; \
+} while(0)
-#define COLORBALANCE_UNIFORMS(shader) \
+#define COLORBALANCE_UNIFORMS(shader) do { \
glUniform3f(glGetUniformLocation(shader, "colorbalance_scale"), \
get_output()->get_params()->get("COLORBALANCE_CYAN", (float)1), \
get_output()->get_params()->get("COLORBALANCE_MAGENTA", (float)1), \
- get_output()->get_params()->get("COLORBALANCE_YELLOW", (float)1));
+ get_output()->get_params()->get("COLORBALANCE_YELLOW", (float)1)); \
+} while(0)
#endif
int ColorBalanceMain::synchronize_params(ColorBalanceSlider *slider, float difference)
{
- if(thread && config.lock_params)
- {
- if(slider != ((ColorBalanceWindow*)thread->window)->cyan)
- {
- config.cyan += difference;
- test_boundary(config.cyan);
- ((ColorBalanceWindow*)thread->window)->cyan->update((int64_t)config.cyan);
- }
- if(slider != ((ColorBalanceWindow*)thread->window)->magenta)
- {
- config.magenta += difference;
- test_boundary(config.magenta);
- ((ColorBalanceWindow*)thread->window)->magenta->update((int64_t)config.magenta);
- }
- if(slider != ((ColorBalanceWindow*)thread->window)->yellow)
- {
- config.yellow += difference;
- test_boundary(config.yellow);
- ((ColorBalanceWindow*)thread->window)->yellow->update((int64_t)config.yellow);
- }
- }
+ if(thread && config.lock_params) {
+ if(slider != ((ColorBalanceWindow*)thread->window)->cyan) {
+ config.cyan += difference;
+ test_boundary(config.cyan);
+ ((ColorBalanceWindow*)thread->window)->cyan->update((int64_t)config.cyan);
+ }
+ if(slider != ((ColorBalanceWindow*)thread->window)->magenta) {
+ config.magenta += difference;
+ test_boundary(config.magenta);
+ ((ColorBalanceWindow*)thread->window)->magenta->update((int64_t)config.magenta);
+ }
+ if(slider != ((ColorBalanceWindow*)thread->window)->yellow) {
+ config.yellow += difference;
+ test_boundary(config.yellow);
+ ((ColorBalanceWindow*)thread->window)->yellow->update((int64_t)config.yellow);
+ }
+ }
return 0;
}
get_output()->to_texture();
get_output()->enable_opengl();
- unsigned int shader = 0;
- const char *shader_stack[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
- int current_shader = 0;
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ 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;
+
int aggregate_interpolate = 0;
int aggregate_gamma = 0;
//printf("ColorBalanceMain::handle_opengl %d %d\n", aggregate_interpolate, aggregate_gamma);
if(aggregate_interpolate)
- INTERPOLATE_COMPILE(shader_stack, current_shader)
+ INTERPOLATE_COMPILE(shader_stack, current_shader);
if(aggregate_gamma)
- GAMMA_COMPILE(shader_stack, current_shader, aggregate_interpolate)
-
- COLORBALANCE_COMPILE(shader_stack,
- current_shader,
- aggregate_gamma || aggregate_interpolate)
-
- 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)
- {
+ GAMMA_COMPILE(shader_stack, current_shader,
+ aggregate_interpolate);
+
+ COLORBALANCE_COMPILE(shader_stack, current_shader,
+ aggregate_gamma || aggregate_interpolate);
+
+ 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_gamma) GAMMA_UNIFORMS(shader);
COLORBALANCE_UNIFORMS(shader);
-
+ if( need_color_matrix ) BC_GL_COLORS(shader);
}
get_output()->init_screen();
ColorBalanceSlider::ColorBalanceSlider(ColorBalanceMain *client,
float *output, int x, int y)
- : BC_ISlider(x,
- y,
- 0,
- 200,
- 200,
- -1000,
- 1000,
- (int)*output)
+ : BC_ISlider(x, y, 0, 200, 200, -1000, 1000, (int)*output)
{
this->client = client;
this->output = output;
- old_value = *output;
+ old_value = *output;
}
ColorBalanceSlider::~ColorBalanceSlider()
{
float difference = get_value() - *output;
*output = get_value();
- client->synchronize_params(this, difference);
+ client->synchronize_params(this, difference);
client->send_configure_change();
return 1;
}
#include "language.h"
#include "vframe.h"
-
-
-
-
-
-
-
-
#include <stdint.h>
#include <string.h>
REGISTER_PLUGIN(DeInterlaceMain)
-
-
-
DeInterlaceConfig::DeInterlaceConfig()
{
mode = DEINTERLACE_EVEN;
get_output()->enable_opengl();
get_output()->init_screen();
- const char *shader_stack[] = { 0, 0, 0 };
- shader_stack[0] = head_frag;
+ if( config.mode != DEINTERLACE_NONE ) {
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
- float double_line_h = 2.0 / get_output()->get_texture_h();
- float line_h = 1.0 / get_output()->get_texture_h();
- float y_offset = 0.0;
- switch(config.mode)
- {
+ shader_stack[current_shader++] = head_frag;
+
+ float double_line_h = 2.0 / get_output()->get_texture_h();
+ float line_h = 1.0 / get_output()->get_texture_h();
+ float y_offset = 0.0;
+ const char *shader_frag = 0;
+
+ switch(config.mode) {
case DEINTERLACE_EVEN:
- shader_stack[1] = line_double_frag;
+ shader_frag = line_double_frag;
break;
case DEINTERLACE_ODD:
- shader_stack[1] = line_double_frag;
+ shader_frag = line_double_frag;
y_offset += 1.0;
break;
case DEINTERLACE_AVG:
- shader_stack[1] = line_avg_frag;
+ shader_frag = line_avg_frag;
break;
case DEINTERLACE_AVG_EVEN:
- shader_stack[1] = field_avg_frag;
+ shader_frag = field_avg_frag;
break;
case DEINTERLACE_AVG_ODD:
- shader_stack[1] = field_avg_frag;
+ shader_frag = field_avg_frag;
y_offset += 1.0;
break;
case DEINTERLACE_SWAP_EVEN:
- shader_stack[1] = line_swap_frag;
+ shader_frag = line_swap_frag;
break;
case DEINTERLACE_SWAP_ODD:
- shader_stack[1] = line_swap_frag;
+ shader_frag = line_swap_frag;
y_offset += 1.0;
break;
- }
-
- y_offset /= get_output()->get_texture_h();
-
- shader_stack[2] = tail_frag;
-
- if(config.mode != DEINTERLACE_NONE)
- {
- unsigned int frag = VFrame::make_shader(0,
- shader_stack[0],
- shader_stack[1],
- shader_stack[2],
- 0);
- if(frag)
- {
- glUseProgram(frag);
- glUniform1i(glGetUniformLocation(frag, "tex"), 0);
- glUniform1f(glGetUniformLocation(frag, "line_h"), line_h);
- glUniform1f(glGetUniformLocation(frag, "double_line_h"), double_line_h);
- glUniform1f(glGetUniformLocation(frag, "y_offset"), y_offset);
+ }
+ if( shader_frag )
+ shader_stack[current_shader++] = shader_frag;
+
+ shader_stack[current_shader++] = tail_frag;
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ y_offset /= get_output()->get_texture_h();
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "line_h"), line_h);
+ glUniform1f(glGetUniformLocation(shader, "double_line_h"), double_line_h);
+ glUniform1f(glGetUniformLocation(shader, "y_offset"), y_offset);
}
}
#ifndef DIFFKEY_H
#define DIFFKEY_H
+#include "bccolors.h"
#include "bcdisplayinfo.h"
#include "clip.h"
#include "bchash.h"
#include "loadbalance.h"
#include "bccolors.h"
#include "pluginvclient.h"
-
+#include "playback3d.h"
#include <string.h>
" float difference = abs(foreground.r - background.r);\n";
static const char *rgb_value =
- " float difference = abs(dot(foreground.rgb, vec3(0.29900, 0.58700, 0.11400)) - \n"
- " dot(background.rgb, vec3(0.29900, 0.58700, 0.11400)));\n";
+ " float difference = abs("
+ " dot(foreground.rgb, rgb_to_yuv_matrix[0]) - "
+ " dot(background.rgb, rgb_to_yuv_matrix[0]));\n";
static const char *diffkey_tail =
" vec4 result;\n"
" gl_FragColor = result;\n"
"}\n";
-
-
-
-
top_frame->enable_opengl();
top_frame->init_screen();
top_frame->enable_opengl();
top_frame->init_screen();
- unsigned int shader_id = 0;
- if(config.do_value)
- {
- if(BC_CModels::is_yuv(top_frame->get_color_model()))
- shader_id = VFrame::make_shader(0,
- diffkey_head,
- yuv_value,
- diffkey_tail,
- 0);
- else
- shader_id = VFrame::make_shader(0,
- diffkey_head,
- rgb_value,
- diffkey_tail,
- 0);
- }
- else
- {
- shader_id = VFrame::make_shader(0,
- diffkey_head,
- colorcube,
- diffkey_tail,
- 0);
- }
-
-
+ int need_color_matrix = 0;
+ const char *shader_frag = !config.do_value ? colorcube :
+ BC_CModels::is_yuv(top_frame->get_color_model()) ?
+ yuv_value : (need_color_matrix = 1, rgb_value);
+ unsigned int shader = VFrame::make_shader(0,
+ diffkey_head, shader_frag, diffkey_tail, 0);
DIFFKEY_VARS(this)
bottom_frame->bind_texture(1);
top_frame->bind_texture(0);
- if(shader_id > 0)
- {
- glUseProgram(shader_id);
- glUniform1i(glGetUniformLocation(shader_id, "tex_fg"), 0);
- glUniform1i(glGetUniformLocation(shader_id, "tex_bg"), 1);
- glUniform1f(glGetUniformLocation(shader_id, "threshold"), threshold);
- glUniform1f(glGetUniformLocation(shader_id, "pad"), pad);
- glUniform1f(glGetUniformLocation(shader_id, "threshold_pad"), threshold_pad);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex_fg"), 0);
+ glUniform1i(glGetUniformLocation(shader, "tex_bg"), 1);
+ glUniform1f(glGetUniformLocation(shader, "threshold"), threshold);
+ glUniform1f(glGetUniformLocation(shader, "pad"), pad);
+ glUniform1f(glGetUniformLocation(shader, "threshold_pad"), threshold_pad);
+ if( need_color_matrix )
+ BC_GL_MATRIX(shader, rgb_to_yuv_matrix);
}
if(BC_CModels::components(get_output()->get_color_model()) == 3)
top_frame->draw_texture();
glUseProgram(0);
top_frame->set_opengl_state(VFrame::SCREEN);
-// Fastest way to discard output
- bottom_frame->set_opengl_state(VFrame::TEXTURE);
glDisable(GL_BLEND);
+// does not work, fails in playback3d
+// Fastest way to discard output
+// bottom_frame->set_opengl_state(VFrame::TEXTURE);
+// kludge ahead
+ top_frame->screen_to_ram();
#endif
return 0;
}
DiffKey *plugin = engine->plugin;
int w = plugin->top_frame->get_w();
-#define RGB_TO_VALUE(r, g, b) \
-((r) * R_TO_Y + (g) * G_TO_Y + (b) * B_TO_Y)
+#define RGB_TO_VALUE(r, g, b) YUV::yuv.rgb_to_y_f((r),(g),(b))
#define DIFFKEY_MACRO(type, components, max, chroma_offset) \
src->bind_texture(0);
dst->bind_texture(1);
- const char *shader_stack[] = { 0, 0, 0 };
- int current_shader = 0;
- shader_stack[current_shader++] = blend_dissolve;
-
- unsigned int shader_id = VFrame::make_shader(0,
- shader_stack[0], shader_stack[1], shader_stack[2], 0);
-
- glUseProgram(shader_id);
- glUniform1f(glGetUniformLocation(shader_id, "fade"), fade);
- glUniform1i(glGetUniformLocation(shader_id, "src_tex"), 0);
- glUniform1i(glGetUniformLocation(shader_id, "dst_tex"), 1);
- if(BC_CModels::is_yuv(dst->get_color_model()))
- glUniform3f(glGetUniformLocation(shader_id, "chroma_offset"), 0.0, 0.5, 0.5);
- else
- glUniform3f(glGetUniformLocation(shader_id, "chroma_offset"), 0.0, 0.0, 0.0);
- glUniform2f(glGetUniformLocation(shader_id, "dst_tex_dimensions"),
- (float)dst->get_texture_w(),
- (float)dst->get_texture_h());
-
+ unsigned int shader = VFrame::make_shader(0, blend_dissolve, 0);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1f(glGetUniformLocation(shader, "fade"), fade);
+ glUniform1i(glGetUniformLocation(shader, "src_tex"), 0);
+ glUniform1i(glGetUniformLocation(shader, "dst_tex"), 1);
+ if(BC_CModels::is_yuv(dst->get_color_model()))
+ glUniform3f(glGetUniformLocation(shader, "chroma_offset"), 0.0, 0.5, 0.5);
+ else
+ glUniform3f(glGetUniformLocation(shader, "chroma_offset"), 0.0, 0.0, 0.0);
+ glUniform2f(glGetUniformLocation(shader, "dst_tex_dimensions"),
+ (float)dst->get_texture_w(),
+ (float)dst->get_texture_h());
+ }
glDisable(GL_BLEND);
src->draw_texture();
glUseProgram(0);
get_output()->enable_opengl();
}
- unsigned int frag = 0;
float y_offset = 0.0;
if(field_number == 0)
{
get_output()->get_h(),
get_output()->get_color_model());
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
- const char *shaders[3] = { 0, 0, 0 };
- shaders[0] = field_frag;
-
+ shader_stack[current_shader++] = field_frag;
// Aggregate with other effect
//printf("FrameField::handle_opengl %s\n", get_output()->get_next_effect());
- if(aggregate_rgb601)
- {
- if(rgb601_direction == 1)
- {
- if(BC_CModels::is_yuv(get_output()->get_color_model()))
- shaders[1] = yuv_to_601_frag;
- else
- shaders[1] = rgb_to_601_frag;
- }
- else
- if(rgb601_direction == 2)
- {
- if(BC_CModels::is_yuv(get_output()->get_color_model()))
- shaders[1] = _601_to_yuv_frag;
- else
- shaders[1] = _601_to_rgb_frag;
+ if( aggregate_rgb601 ) {
+ switch( rgb601_direction ) {
+ case 1:
+ shader_stack[current_shader++] =
+ BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ yuv_to_601_frag : rgb_to_601_frag;
+ break;
+ case 2:
+ shader_stack[current_shader++] =
+ BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ _601_to_yuv_frag : _601_to_rgb_frag;
+ break;
}
}
-
-
- frag = VFrame::make_shader(0, shaders[0], shaders[1], shaders[2], 0);
-
-
- if(frag)
- {
- glUseProgram(frag);
- glUniform1i(glGetUniformLocation(frag, "tex"), 0);
- glUniform1f(glGetUniformLocation(frag, "double_line_h"),
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "double_line_h"),
2.0 / src_texture->get_texture_h());
- glUniform1f(glGetUniformLocation(frag, "y_offset"),
+ glUniform1f(glGetUniformLocation(shader, "y_offset"),
y_offset / src_texture->get_texture_h());
}
-
-
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
get_output()->draw_texture();
" gl_FragColor = pixel;\n"
"}\n";
-#define GAMMA_COMPILE(shader_stack, current_shader, aggregate_interpolation) \
-{ \
- if(aggregate_interpolation) \
- shader_stack[current_shader++] = gamma_get_pixel1; \
- else \
- shader_stack[current_shader++] = gamma_get_pixel2; \
- \
- switch(get_output()->get_color_model()) \
- { \
- case BC_YUV888: \
- case BC_YUVA8888: \
- shader_stack[current_shader++] = gamma_pow_frag; \
- shader_stack[current_shader++] = gamma_yuv_frag; \
- break; \
- default: \
- shader_stack[current_shader++] = gamma_pow_frag; \
- shader_stack[current_shader++] = gamma_rgb_frag; \
- break; \
- } \
-}
+#define GAMMA_COMPILE(shader_stack, current_shader, aggregate_interpolation) do { \
+ shader_stack[current_shader++] = \
+ (aggregate_interpolation) ? gamma_get_pixel1 : gamma_get_pixel2; \
+ shader_stack[current_shader++] = gamma_pow_frag; \
+ shader_stack[current_shader++] = \
+ !BC_CModels::is_yuv(get_output()->get_color_model()) ? \
+ gamma_rgb_frag : gamma_yuv_frag; \
+} while(0)
-#define GAMMA_UNIFORMS(frag) \
-{ \
+#define GAMMA_UNIFORMS(frag) do { \
float gamma = get_output()->get_params()->get("GAMMA_GAMMA", (float)1); \
float max = get_output()->get_params()->get("GAMMA_MAX", (float)1) * gamma; \
gamma -= 1.0; \
glUniform1f(glGetUniformLocation(frag, "gamma_scale"), scale); \
glUniform1f(glGetUniformLocation(frag, "gamma_gamma"), gamma); \
glUniform1f(glGetUniformLocation(frag, "gamma_max"), max); \
-printf("GAMMA_UNIFORMS %f %f\n", max, gamma); \
-}
-
-
-
-
+} while(0)
#endif
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();
"}\n";
- const char *shader_stack[5] = { 0, 0, 0, 0, 0 };
- shader_stack[0] = head_frag;
-
- switch(config.shape)
- {
- case GradientConfig::LINEAR:
- shader_stack[1] = linear_shape;
- break;
-
- default:
- shader_stack[1] = radial_shape;
- break;
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
+
+ shader_stack[current_shader++] = head_frag;
+
+ const char *shape_frag = 0;
+ switch( config.shape ) {
+ case GradientConfig::LINEAR:
+ shape_frag = linear_shape;
+ break;
+ default:
+ shape_frag = radial_shape;
+ break;
}
-
- switch(config.rate)
- {
- case GradientConfig::LINEAR:
- shader_stack[2] = linear_rate;
- break;
- case GradientConfig::LOG:
- shader_stack[2] = log_rate;
- break;
- case GradientConfig::SQUARE:
- shader_stack[2] = square_rate;
- break;
+ if( shape_frag )
+ shader_stack[current_shader++] = shape_frag;
+
+ const char *rate_frag = 0;
+ switch(config.rate) {
+ case GradientConfig::LINEAR:
+ rate_frag = linear_rate;
+ break;
+ case GradientConfig::LOG:
+ rate_frag = log_rate;
+ break;
+ case GradientConfig::SQUARE:
+ rate_frag = square_rate;
+ break;
}
+ if( rate_frag )
+ shader_stack[current_shader++] = rate_frag;
+
+ shader_stack[current_shader++] = tail_frag;
- shader_stack[3] = tail_frag;
// Force frame to create texture without copying to it if full alpha.
- if(config.in_a >= 0xff &&
- config.out_a >= 0xff)
+ if( config.in_a >= 0xff && config.out_a >= 0xff )
get_output()->set_opengl_state(VFrame::TEXTURE);
get_output()->to_texture();
get_output()->enable_opengl();
get_output()->init_screen();
get_output()->bind_texture(0);
- unsigned int frag = VFrame::make_shader(0,
- shader_stack[0],
- shader_stack[1],
- shader_stack[2],
- shader_stack[3],
- 0);
-
- if(frag)
- {
- glUseProgram(frag);
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ glUseProgram(shader);
float w = get_output()->get_w();
float h = get_output()->get_h();
float texture_w = get_output()->get_texture_w();
float texture_h = get_output()->get_texture_h();
- glUniform1i(glGetUniformLocation(frag, "tex"), 0);
- glUniform1f(glGetUniformLocation(frag, "half_w"), w / 2 / texture_w);
- glUniform1f(glGetUniformLocation(frag, "half_h"), h / 2 / texture_h);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "half_w"), w / 2 / texture_w);
+ glUniform1f(glGetUniformLocation(shader, "half_h"), h / 2 / texture_h);
if(config.shape == GradientConfig::LINEAR)
{
- glUniform1f(glGetUniformLocation(frag, "center_x"),
+ glUniform1f(glGetUniformLocation(shader, "center_x"),
w / 2 / texture_w);
- glUniform1f(glGetUniformLocation(frag, "center_y"),
+ glUniform1f(glGetUniformLocation(shader, "center_y"),
h / 2 / texture_h);
}
else
{
- glUniform1f(glGetUniformLocation(frag, "center_x"),
+ glUniform1f(glGetUniformLocation(shader, "center_x"),
(float)config.center_x * w / 100 / texture_w);
- glUniform1f(glGetUniformLocation(frag, "center_y"),
+ glUniform1f(glGetUniformLocation(shader, "center_y"),
(float)config.center_y * h / 100 / texture_h);
}
float gradient_size = hypotf(w / texture_w, h / texture_h);
- glUniform1f(glGetUniformLocation(frag, "half_gradient_size"),
+ glUniform1f(glGetUniformLocation(shader, "half_gradient_size"),
gradient_size / 2);
- glUniform1f(glGetUniformLocation(frag, "sin_angle"),
+ glUniform1f(glGetUniformLocation(shader, "sin_angle"),
sin(config.angle * (M_PI / 180)));
- glUniform1f(glGetUniformLocation(frag, "cos_angle"),
+ glUniform1f(glGetUniformLocation(shader, "cos_angle"),
cos(config.angle * (M_PI / 180)));
float in_radius = (float)config.in_radius / 100 * gradient_size;
- glUniform1f(glGetUniformLocation(frag, "in_radius"), in_radius);
+ glUniform1f(glGetUniformLocation(shader, "in_radius"), in_radius);
float out_radius = (float)config.out_radius / 100 * gradient_size;
- glUniform1f(glGetUniformLocation(frag, "out_radius"), out_radius);
- glUniform1f(glGetUniformLocation(frag, "radius_diff"),
+ glUniform1f(glGetUniformLocation(shader, "out_radius"), out_radius);
+ glUniform1f(glGetUniformLocation(shader, "radius_diff"),
out_radius - in_radius);
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- {
- float in1, in2, in3, in4;
- float out1, out2, out3, out4;
- YUV::yuv.rgb_to_yuv_f((float)config.in_r / 0xff,
- (float)config.in_g / 0xff,
- (float)config.in_b / 0xff,
- in1,
- in2,
- in3);
+ switch(get_output()->get_color_model()) {
+ case BC_YUV888:
+ case BC_YUVA8888: {
+ float in1, in2, in3, in4;
+ float out1, out2, out3, out4;
+ YUV::yuv.rgb_to_yuv_f(
+ (float)config.in_r / 0xff,
+ (float)config.in_g / 0xff,
+ (float)config.in_b / 0xff,
+ in1, in2, in3);
in4 = (float)config.in_a / 0xff;
- YUV::yuv.rgb_to_yuv_f((float)config.out_r / 0xff,
- (float)config.out_g / 0xff,
- (float)config.out_b / 0xff,
- out1,
- out2,
- out3);
- in2 += 0.5;
- in3 += 0.5;
- out2 += 0.5;
- out3 += 0.5;
- out4 = (float)config.out_a / 0xff;
- glUniform4f(glGetUniformLocation(frag, "out_color"),
- out1, out2, out3, out4);
- glUniform4f(glGetUniformLocation(frag, "in_color"),
- in1, in2, in3, in4);
- break;
- }
+ YUV::yuv.rgb_to_yuv_f(
+ (float)config.out_r / 0xff,
+ (float)config.out_g / 0xff,
+ (float)config.out_b / 0xff,
+ out1, out2, out3);
+ in2 += 0.5; in3 += 0.5;
+ out2 += 0.5; out3 += 0.5;
+ out4 = (float)config.out_a / 0xff;
+ glUniform4f(glGetUniformLocation(shader, "out_color"),
+ out1, out2, out3, out4);
+ glUniform4f(glGetUniformLocation(shader, "in_color"),
+ in1, in2, in3, in4);
+ break; }
- default:
- glUniform4f(glGetUniformLocation(frag, "out_color"),
- (float)config.out_r / 0xff,
- (float)config.out_g / 0xff,
- (float)config.out_b / 0xff,
- (float)config.out_a / 0xff);
- glUniform4f(glGetUniformLocation(frag, "in_color"),
- (float)config.in_r / 0xff,
- (float)config.in_g / 0xff,
- (float)config.in_b / 0xff,
- (float)config.in_a / 0xff);
- break;
+ default:
+ glUniform4f(glGetUniformLocation(shader, "out_color"),
+ (float)config.out_r / 0xff,
+ (float)config.out_g / 0xff,
+ (float)config.out_b / 0xff,
+ (float)config.out_a / 0xff);
+ glUniform4f(glGetUniformLocation(shader, "in_color"),
+ (float)config.in_r / 0xff,
+ (float)config.in_g / 0xff,
+ (float)config.in_b / 0xff,
+ (float)config.in_a / 0xff);
+ break;
}
}
}
-
-
-
-
-
-
-
-
-
GradientPackage::GradientPackage()
: LoadPackage()
{
}
-
-
-
GradientUnit::GradientUnit(GradientServer *server, GradientMain *plugin)
: LoadClient(server)
{
}
-
-
static float calculate_opacity(float mag,
float in_radius, float out_radius, int rate)
{
get_output()->to_texture();
get_output()->enable_opengl();
- const char *shader_stack[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
- int current_shader = 0;
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ 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;
+
int aggregate_interpolation = 0;
int aggregate_gamma = 0;
int aggregate_colorbalance = 0;
if(!strcmp(get_output()->get_prev_effect(0), _("Color Balance")))
aggregate_colorbalance = 1;
+ if( BC_CModels::is_yuv(get_output()->get_color_model()) )
+ shader_stack[current_shader++] = bc_gl_colors;
// The order of processing is fixed by this sequence
if(aggregate_interpolation)
- INTERPOLATE_COMPILE(shader_stack,
- current_shader)
+ INTERPOLATE_COMPILE(shader_stack, current_shader);
if(aggregate_gamma)
- GAMMA_COMPILE(shader_stack,
- current_shader,
- aggregate_interpolation)
+ GAMMA_COMPILE(shader_stack, current_shader,
+ aggregate_interpolation);
if(aggregate_colorbalance)
- COLORBALANCE_COMPILE(shader_stack,
- current_shader,
- aggregate_interpolation || aggregate_gamma)
+ COLORBALANCE_COMPILE(shader_stack, current_shader,
+ aggregate_interpolation || aggregate_gamma);
+ shader_stack[current_shader++] =
+ aggregate_interpolation || aggregate_gamma || aggregate_colorbalance ?
+ histogram_get_pixel1 : histogram_get_pixel2;
- if(aggregate_interpolation || aggregate_gamma || aggregate_colorbalance)
- shader_stack[current_shader++] = histogram_get_pixel1;
- else
- shader_stack[current_shader++] = histogram_get_pixel2;
-
- unsigned int shader = 0;
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- shader_stack[current_shader++] = head_frag;
- shader_stack[current_shader++] = get_yuv_frag;
- shader_stack[current_shader++] = apply_histogram_frag;
- shader_stack[current_shader++] = put_yuv_frag;
- break;
- default:
- shader_stack[current_shader++] = head_frag;
- shader_stack[current_shader++] = get_rgb_frag;
- shader_stack[current_shader++] = apply_histogram_frag;
- shader_stack[current_shader++] = put_rgb_frag;
- break;
- }
+ shader_stack[current_shader++] = head_frag;
+ shader_stack[current_shader++] = BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ get_yuv_frag : get_rgb_frag;
+ shader_stack[current_shader++] = apply_histogram_frag;
+ shader_stack[current_shader++] = BC_CModels::is_yuv(get_output()->get_color_model()) ?
+ put_yuv_frag : put_rgb_frag;
- 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],
- shader_stack[8],
- shader_stack[9],
- shader_stack[10],
- shader_stack[11],
- shader_stack[12],
- shader_stack[13],
- shader_stack[14],
- shader_stack[15],
- 0);
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
// printf("HistogramMain::handle_opengl %d %d %d %d shader=%d\n",
// aggregate_interpolation,
{
glUseProgram(shader);
glUniform1i(glGetUniformLocation(shader, "tex"), 0);
- if(aggregate_gamma) GAMMA_UNIFORMS(shader)
- if(aggregate_interpolation) INTERPOLATE_UNIFORMS(shader)
- if(aggregate_colorbalance) COLORBALANCE_UNIFORMS(shader)
+ if(aggregate_gamma) GAMMA_UNIFORMS(shader);
+ if(aggregate_interpolation) INTERPOLATE_UNIFORMS(shader);
+ if(aggregate_colorbalance) COLORBALANCE_UNIFORMS(shader);
glUniform4fv(glGetUniformLocation(shader, "low_input"), 1, low_input);
glUniform4fv(glGetUniformLocation(shader, "high_input"), 1, high_input);
glUniform4fv(glGetUniformLocation(shader, "gamma"), 1, gamma);
glUniform4fv(glGetUniformLocation(shader, "low_output"), 1, low_output);
glUniform4fv(glGetUniformLocation(shader, "output_scale"), 1, output_scale);
+ if( need_color_matrix ) BC_GL_COLORS(shader);
}
get_output()->init_screen();
get_output()->to_texture();
get_output()->enable_opengl();
- unsigned int frag_shader = 0;
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
-// This is a lousy approximation but good enough for the masker.
- if(EQUIV(config.hue, 0))
- frag_shader = VFrame::make_shader(0,
- yuv_saturation_frag,
- 0);
- else
- frag_shader = VFrame::make_shader(0,
- yuv_frag,
- 0);
- break;
- default:
- frag_shader = VFrame::make_shader(0,
- rgb_frag,
- 0);
- break;
- }
-
-
- if(frag_shader > 0)
- {
- glUseProgram(frag_shader);
- glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
- glUniform1f(glGetUniformLocation(frag_shader, "h_offset"), config.hue);
- glUniform1f(glGetUniformLocation(frag_shader, "s_offset"),
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ 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;
+ shader_stack[current_shader++] = !need_color_matrix ? rgb_frag :
+ EQUIV(config.hue, 0) ? yuv_saturation_frag: yuv_frag ;
+
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if(shader > 0) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "h_offset"), config.hue);
+ glUniform1f(glGetUniformLocation(shader, "s_offset"),
((float)config.saturation - MINSATURATION) / MAXSATURATION);
- glUniform1f(glGetUniformLocation(frag_shader, "v_offset"),
+ glUniform1f(glGetUniformLocation(shader, "v_offset"),
((float)config.value - MINVALUE) / MAXVALUE);
+ if( need_color_matrix ) BC_GL_COLORS(shader);
}
get_output()->init_screen();
" vec3 result;\n"
" pattern_coord -= pattern_offset;\n"
" pattern_coord = fract(pattern_coord / pattern_size);\n"
-" if(pattern_coord.x >= 0.5)\n"
-" {\n"
-" if(pattern_coord.y >= 0.5)\n"
-" {\n"
+" if(pattern_coord.x >= 0.5) {\n"
+" if(pattern_coord.y >= 0.5) {\n"
/* Bottom right of pattern */
/* Bottom right pixels are: */
/* 2 */
" vec2 pixel3 = pixel_coord + vec2(pixel_size.x, 0.0);\n"
" vec2 pixel4 = pixel_coord + vec2(0.0, pixel_size.y);\n"
" result = vec3((texture2D(tex, pixel1).r + \n"
-" texture2D(tex, pixel3).r) / 2.0, \n"
-" texture2D(tex, pixel_coord).g, \n"
-" (texture2D(tex, pixel2).b + \n"
-" texture2D(tex, pixel4).b) / 2.0);\n"
+" texture2D(tex, pixel3).r) / 2.0, \n"
+" texture2D(tex, pixel_coord).g, \n"
+" (texture2D(tex, pixel2).b + \n"
+" texture2D(tex, pixel4).b) / 2.0);\n"
" }\n"
-" else\n"
-" {\n"
+" else {\n"
/* Top right of pattern */
/* Top right pixels are: */
/* 123 */
" vec2 pixel7 = pixel_coord + vec2(0.0, pixel_size.y);\n"
" vec2 pixel8 = pixel_coord + pixel_size;\n"
" result = vec3((texture2D(tex, pixel1).r + \n"
-" texture2D(tex, pixel3).r + \n"
-" texture2D(tex, pixel6).r + \n"
-" texture2D(tex, pixel8).r) / 4.0, \n"
-" (texture2D(tex, pixel4).g + \n"
-" texture2D(tex, pixel2).g + \n"
-" texture2D(tex, pixel5).g + \n"
-" texture2D(tex, pixel7).g) / 4.0, \n"
-" texture2D(tex, pixel_coord).b);\n"
+" texture2D(tex, pixel3).r + \n"
+" texture2D(tex, pixel6).r + \n"
+" texture2D(tex, pixel8).r) / 4.0, \n"
+" (texture2D(tex, pixel4).g + \n"
+" texture2D(tex, pixel2).g + \n"
+" texture2D(tex, pixel5).g + \n"
+" texture2D(tex, pixel7).g) / 4.0, \n"
+" texture2D(tex, pixel_coord).b);\n"
" }\n"
" }\n"
-" else\n"
-" {\n"
-" if(pattern_coord.y >= 0.5)\n"
-" {\n"
+" else {\n"
+" if(pattern_coord.y >= 0.5) {\n"
/* Bottom left of pattern */
/* Bottom left pixels are: */
/* 123 */
" vec2 pixel6 = pixel_coord + vec2(-pixel_size.x, pixel_size.y);\n"
" vec2 pixel7 = pixel_coord + vec2(0.0, pixel_size.y);\n"
" vec2 pixel8 = pixel_coord + pixel_size;\n"
-" result = vec3(\n"
-" texture2D(tex, pixel_coord).r, \n"
-" (texture2D(tex, pixel4).g + \n"
-" texture2D(tex, pixel2).g + \n"
-" texture2D(tex, pixel5).g + \n"
-" texture2D(tex, pixel7).g) / 4.0, \n"
-" (texture2D(tex, pixel1).b + \n"
-" texture2D(tex, pixel3).b + \n"
-" texture2D(tex, pixel6).b + \n"
-" texture2D(tex, pixel8).b) / 4.0);\n"
+" result = vec3(texture2D(tex, pixel_coord).r, \n"
+" (texture2D(tex, pixel4).g + \n"
+" texture2D(tex, pixel2).g + \n"
+" texture2D(tex, pixel5).g + \n"
+" texture2D(tex, pixel7).g) / 4.0, \n"
+" (texture2D(tex, pixel1).b + \n"
+" texture2D(tex, pixel3).b + \n"
+" texture2D(tex, pixel6).b + \n"
+" texture2D(tex, pixel8).b) / 4.0);\n"
" }\n"
-" else\n"
-" {\n"
+" else {\n"
/* Top left of pattern */
/* Top left pixels are: */
/* 2 */
" vec2 pixel2 = pixel_coord - vec2(0.0, pixel_size.y);\n"
" vec2 pixel3 = pixel_coord + vec2(pixel_size.x, 0.0);\n"
" vec2 pixel4 = pixel_coord + vec2(0.0, pixel_size.y);\n"
-" result = vec3(\n"
-" (texture2D(tex, pixel2).r + \n"
-" texture2D(tex, pixel4).r) / 2.0, \n"
-" texture2D(tex, pixel_coord).g, \n"
-" (texture2D(tex, pixel1).b + \n"
-" texture2D(tex, pixel3).b) / 2.0);\n"
+" result = vec3((texture2D(tex, pixel2).r + \n"
+" texture2D(tex, pixel4).r) / 2.0, \n"
+" texture2D(tex, pixel_coord).g, \n"
+" (texture2D(tex, pixel1).b + \n"
+" texture2D(tex, pixel3).b) / 2.0);\n"
" }\n"
" }\n"
"\n"
-"\n"
" gl_FragColor = vec4(result * color_matrix, 1.0);\n"
"}\n";
-#define INTERPOLATE_COMPILE(shader_stack, current_shader) \
-{ \
+#define INTERPOLATE_COMPILE(shader_stack, current_shader) do { \
shader_stack[current_shader++] = interpolate_shader; \
-}
+} while(0)
-#define INTERPOLATE_UNIFORMS(frag) \
-{ \
+#define INTERPOLATE_UNIFORMS(frag) do { \
int x_offset = get_output()->get_params()->get("INTERPOLATEPIXELS_X", (int)0); \
int y_offset = get_output()->get_params()->get("INTERPOLATEPIXELS_Y", (int)0); \
float color_matrix[9]; \
char string[BCTEXTLEN]; \
string[0] = 0; \
get_output()->get_params()->get("DCRAW_MATRIX", string); \
- sscanf(string, \
- "%f %f %f %f %f %f %f %f %f", \
- &color_matrix[0], \
- &color_matrix[1], \
- &color_matrix[2], \
- &color_matrix[3], \
- &color_matrix[4], \
- &color_matrix[5], \
- &color_matrix[6], \
- &color_matrix[7], \
- &color_matrix[8]); \
+ sscanf(string, "%f %f %f %f %f %f %f %f %f", \
+ &color_matrix[0], &color_matrix[1], &color_matrix[2], \
+ &color_matrix[3], &color_matrix[4], &color_matrix[5], \
+ &color_matrix[6], &color_matrix[7], &color_matrix[8]); \
glUniformMatrix3fv(glGetUniformLocation(frag, "color_matrix"), \
- 1, \
- 0, \
- color_matrix); \
+ 1, 0, color_matrix); \
glUniform2f(glGetUniformLocation(frag, "pattern_offset"), \
(float)x_offset / get_output()->get_texture_w(), \
(float)y_offset / get_output()->get_texture_h()); \
glUniform2f(glGetUniformLocation(frag, "pixel_size"), \
1.0 / get_output()->get_texture_w(), \
1.0 / get_output()->get_texture_h()); \
-}
+} while(0)
#endif
get_output()->to_texture();
get_output()->enable_opengl();
- const char *shader_stack[] = { 0, 0, 0 };
- int current_shader = 0;
- INTERPOLATE_COMPILE(shader_stack, current_shader)
- unsigned int frag = VFrame::make_shader(0,
- shader_stack[0],
- 0);
- if(frag > 0)
- {
- glUseProgram(frag);
- glUniform1i(glGetUniformLocation(frag, "tex"), 0);
- INTERPOLATE_UNIFORMS(frag)
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
+ int current_shader = 0;
+
+ INTERPOLATE_COMPILE(shader_stack, current_shader);
+
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ INTERPOLATE_UNIFORMS(shader);
}
-
get_output()->init_screen();
get_output()->bind_texture(0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
get_output()->to_texture();
get_output()->enable_opengl();
- unsigned int frag_shader = 0;
- frag_shader = VFrame::make_shader(0,
- invert_frag,
- 0);
+ unsigned int frag_shader = VFrame::make_shader(0, invert_frag, 0);
glUseProgram(frag_shader);
glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
glUniform1i(glGetUniformLocation(frag_shader, "do_r"), config.r);
"uniform vec2 center_coord;\n"
"uniform vec4 border_color;\n"
"uniform vec4 r;\n"
- "uniform float radius;\n"
"void main()\n"
"{\n"
" vec2 outcoord = gl_TexCoord[0].st * texture_extents;\n"
" vec2 coord_diff = outcoord - center_coord;\n"
" float z = sqrt(coord_diff.x * coord_diff.x +\n"
" coord_diff.y * coord_diff.y);\n"
- " vec4 radius1 = (vec4(z, z, z, z) / r) * 2.0 * radius;\n"
- " vec4 z_in = r * atan(radius1) / (3.14159 / 2.0);\n"
+ " vec4 radius1 = vec4(z, z, z, z) / r;\n"
+ " vec4 z_in = r * tan(radius1) / (3.14159 / 2.0);\n"
"\n"
" float angle;\n"
" if( coord_diff.x == 0.0 )\n"
get_output()->to_texture();
get_output()->enable_opengl();
- unsigned int frag_shader = 0;
- switch( config.mode )
- {
+ unsigned int shader = 0;
+ const char *shader_frag = 0;
+ switch( config.mode ) {
case LensConfig::SPHERICAL_SHRINK:
- frag_shader = VFrame::make_shader(0, shrink_frag, 0);
+ shader_frag = shrink_frag;
break;
case LensConfig::SPHERICAL_STRETCH:
- frag_shader = VFrame::make_shader(0, stretch_frag, 0);
+ shader_frag = stretch_frag;
break;
case LensConfig::RECTILINEAR_STRETCH:
- frag_shader = VFrame::make_shader(0, rectilinear_stretch_frag, 0);
+ shader_frag = rectilinear_stretch_frag;
break;
case LensConfig::RECTILINEAR_SHRINK:
- frag_shader = VFrame::make_shader(0, rectilinear_shrink_frag, 0);
+ shader_frag = rectilinear_shrink_frag;
break;
}
-
- if( frag_shader > 0 ) {
+ if( shader_frag )
+ shader = VFrame::make_shader(0, shader_frag, 0);
+ if( shader > 0 ) {
float border_color[] = { 0, 0, 0, 0 };
if( BC_CModels::is_yuv(get_output()->get_color_model()) ) {
- border_color[1] = 0.5;
- border_color[2] = 0.5;
+ border_color[1] = border_color[2] = 0.5;
}
double x_factor = config.aspect;
if( x_factor < 1 ) x_factor = 1;
if( y_factor < 1 ) y_factor = 1;
- glUseProgram(frag_shader);
- glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
- glUniform2f(glGetUniformLocation(frag_shader, "aspect"),
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform2f(glGetUniformLocation(shader, "aspect"),
x_factor,
y_factor);
- glUniform2f(glGetUniformLocation(frag_shader, "center_coord"),
+ glUniform2f(glGetUniformLocation(shader, "center_coord"),
(GLfloat)get_input()->get_w() * config.center_x / 100.0,
(GLfloat)get_input()->get_h() * config.center_y / 100.0);
- glUniform2f(glGetUniformLocation(frag_shader, "texture_extents"),
+ glUniform2f(glGetUniformLocation(shader, "texture_extents"),
(GLfloat)get_input()->get_texture_w(),
(GLfloat)get_input()->get_texture_h());
- glUniform2f(glGetUniformLocation(frag_shader, "image_extents"),
+ glUniform2f(glGetUniformLocation(shader, "image_extents"),
(GLfloat)get_input()->get_w(),
(GLfloat)get_input()->get_h());
float *fov = config.fov;
float dim;
float max_z;
- switch( config.mode )
- {
- case LensConfig::SPHERICAL_SHRINK:
- dim = MAX(width, height) * config.radius;
- max_z = dim * sqrt(2.0) / 2;
- glUniform4fv(glGetUniformLocation(frag_shader, "border_color"),
- 1,
- (GLfloat*)border_color);
- glUniform4f(glGetUniformLocation(frag_shader, "max_z"),
+ switch( config.mode ) {
+ case LensConfig::SPHERICAL_SHRINK:
+ dim = MAX(width, height) * config.radius;
+ max_z = dim * sqrt(2.0) / 2;
+ glUniform4fv(glGetUniformLocation(shader, "border_color"),
+ 1, (GLfloat*)border_color);
+ glUniform4f(glGetUniformLocation(shader, "max_z"),
max_z / fov[0],
max_z / fov[1],
max_z / fov[2],
max_z / fov[3]);
- glUniform4f(glGetUniformLocation(frag_shader, "r"),
+ glUniform4f(glGetUniformLocation(shader, "r"),
(max_z / fov[0]) * 2 / M_PI,
(max_z / fov[1]) * 2 / M_PI,
(max_z / fov[2]) * 2 / M_PI,
(max_z / fov[3]) * 2 / M_PI);
- break;
+ break;
- case LensConfig::SPHERICAL_STRETCH:
- dim = MAX(width, height) * config.radius;
- max_z = dim * sqrt(2.0) / 2;
- glUniform4f(glGetUniformLocation(frag_shader, "r"),
+ case LensConfig::SPHERICAL_STRETCH:
+ dim = MAX(width, height) * config.radius;
+ max_z = dim * sqrt(2.0) / 2;
+ glUniform4f(glGetUniformLocation(shader, "r"),
max_z / M_PI / (fov[0] / 2.0),
max_z / M_PI / (fov[1] / 2.0),
max_z / M_PI / (fov[2] / 2.0),
max_z / M_PI / (fov[3] / 2.0));
- break;
+ break;
- case LensConfig::RECTILINEAR_STRETCH:
- max_z = sqrt(SQR(width) + SQR(height)) / 2;
- glUniform4f(glGetUniformLocation(frag_shader, "r"),
+ case LensConfig::RECTILINEAR_STRETCH:
+ max_z = sqrt(SQR(width) + SQR(height)) / 2;
+ glUniform4f(glGetUniformLocation(shader, "r"),
max_z / M_PI / (fov[0] / 2.0),
max_z / M_PI / (fov[1] / 2.0),
max_z / M_PI / (fov[2] / 2.0),
max_z / M_PI / (fov[3] / 2.0));
- glUniform1f(glGetUniformLocation(frag_shader, "radius"),
+ glUniform1f(glGetUniformLocation(shader, "radius"),
config.radius);
- break;
+ break;
- case LensConfig::RECTILINEAR_SHRINK:
- max_z = sqrt(SQR(width) + SQR(height)) / 2;
- glUniform4f(glGetUniformLocation(frag_shader, "r"),
- max_z / M_PI / (fov[0] / 2.0),
- max_z / M_PI / (fov[1] / 2.0),
- max_z / M_PI / (fov[2] / 2.0),
- max_z / M_PI / (fov[3] / 2.0));
- glUniform1f(glGetUniformLocation(frag_shader, "radius"),
- config.radius);
- break;
+ case LensConfig::RECTILINEAR_SHRINK:
+ max_z = MAX(width, height) / 2 * config.radius;
+ glUniform4f(glGetUniformLocation(shader, "r"),
+ max_z / fov[0],
+ max_z / fov[1],
+ max_z / fov[2],
+ max_z / fov[3]);
+ break;
}
-
get_output()->init_screen();
get_output()->bind_texture(0);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
get_output()->draw_texture();
glUseProgram(0);
-
if( config.draw_guides ) {
int w = get_output()->get_w();
int h = get_output()->get_h();
dst->init_screen();
src->bind_texture(0);
dst->bind_texture(1);
- const char *shader_stack[] = { 0, 0, 0 };
+
+ const char *shader_stack[16];
+ memset(shader_stack,0, sizeof(shader_stack));
int current_shader = 0;
shader_stack[current_shader++] = get_pixels_frag;
shader_stack[current_shader++] = overlay_shaders[config.mode];
shader_stack[current_shader++] = put_pixels_frag;
-
- unsigned int shader_id = 0;
- shader_id = VFrame::make_shader(0,
- shader_stack[0],
- shader_stack[1],
- shader_stack[2],
- 0);
-
- glUseProgram(shader_id);
- glUniform1i(glGetUniformLocation(shader_id, "src_tex"), 0);
- glUniform1i(glGetUniformLocation(shader_id, "dst_tex"), 1);
- glUniform2f(glGetUniformLocation(shader_id, "dst_tex_dimensions"),
- (float)dst->get_texture_w(), (float)dst->get_texture_h());
- float chroma_offset = BC_CModels::is_yuv(dst->get_color_model()) ? 0.5 : 0.0;
- glUniform3f(glGetUniformLocation(shader_id, "chroma_offset"),
- 0.0, chroma_offset, chroma_offset);
-
+ shader_stack[current_shader] = 0;
+ unsigned int shader = VFrame::make_shader(shader_stack);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "src_tex"), 0);
+ glUniform1i(glGetUniformLocation(shader, "dst_tex"), 1);
+ glUniform2f(glGetUniformLocation(shader, "dst_tex_dimensions"),
+ (float)dst->get_texture_w(), (float)dst->get_texture_h());
+ float chroma_offset = BC_CModels::is_yuv(dst->get_color_model()) ? 0.5 : 0.0;
+ glUniform3f(glGetUniformLocation(shader, "chroma_offset"),
+ 0.0, chroma_offset, chroma_offset);
+ }
src->draw_texture();
glUseProgram(0);
get_output()->bind_texture(0);
unsigned int frag_shader = 0;
- switch(get_output()->get_color_model())
- {
- case BC_YUV888:
- case BC_YUVA8888:
- frag_shader = VFrame::make_shader(0,
- config.direction == 1 ? yuv_fwd_frag : yuv_rev_frag,
- 0);
+ switch( get_output()->get_color_model() ) {
+ case BC_YUV888:
+ case BC_YUVA8888:
+ frag_shader = VFrame::make_shader(0,
+ config.direction == 1 ? yuv_fwd_frag : yuv_rev_frag,
+ 0);
break;
- default:
- frag_shader = VFrame::make_shader(0,
- config.direction == 1 ? rgb_fwd_frag : rgb_rev_frag,
- 0);
+ default:
+ frag_shader = VFrame::make_shader(0,
+ config.direction == 1 ? rgb_fwd_frag : rgb_rev_frag,
+ 0);
break;
}
- if(frag_shader)
- {
+ if( frag_shader > 0 ) {
glUseProgram(frag_shader);
glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
}
get_output()->clear_pbuffer();
get_output()->bind_texture(0);
- unsigned int shader_id = VFrame::make_shader(0,
- output_frag,
- 0);
- glUseProgram(shader_id);
- glUniform1i(glGetUniformLocation(shader_id, "tex"), 0);
- glUniform1f(glGetUniformLocation(shader_id, "chroma_offset"),
- BC_CModels::is_yuv(get_output()->get_color_model()) ? 0.5 : 0.0);
+ unsigned int shader = VFrame::make_shader(0, output_frag, 0);
+ if( shader > 0 ) {
+ glUseProgram(shader);
+ glUniform1i(glGetUniformLocation(shader, "tex"), 0);
+ glUniform1f(glGetUniformLocation(shader, "chroma_offset"),
+ BC_CModels::is_yuv(get_output()->get_color_model()) ? 0.5 : 0.0);
+ }
get_output()->draw_texture();
glUseProgram(0);
return 0;
}
-int SwapFrames::handle_opengl()
-{
- return 0;
-}
-
void update_gui();
void save_data(KeyFrame *keyframe);
void read_data(KeyFrame *keyframe);
- int handle_opengl();
PLUGIN_CLASS_MEMBERS(SwapFramesConfig)
#include <string>
#include <string.h>
+#include "threshold.h"
+#include "bccolors.h"
#include "clip.h"
#include "bchash.h"
#include "filexml.h"
#include "histogramengine.h"
#include "language.h"
-#include "bccolors.h"
-#include "threshold.h"
+#include "playback3d.h"
#include "thresholdwindow.h"
#include "vframe.h"
-;
using ::std::string;
"uniform vec4 low_color;\n"
"uniform vec4 mid_color;\n"
"uniform vec4 high_color;\n"
+ "uniform mat3 rgb_to_yuv_matrix;\n"
+ "uniform float yminf;\n"
"void main()\n"
"{\n"
" vec4 pixel = texture2D(tex, gl_TexCoord[0].st);\n"
- " float v = dot(pixel.rgb, vec3(0.299, 0.587, 0.114));\n"
+ " float v = dot(pixel.rgb, rgb_to_yuv_matrix[0]) + yminf;\n"
" if(v < min)\n"
" pixel = low_color;\n"
" else if(v < max)\n"
get_output()->to_texture();
get_output()->enable_opengl();
- unsigned int shader = 0;
int color_model = get_output()->get_color_model();
bool is_yuv = BC_CModels::is_yuv(color_model);
bool has_alpha = BC_CModels::has_alpha(color_model);
- if(is_yuv)
- shader = VFrame::make_shader(0, yuv_shader, 0);
- else
- shader = VFrame::make_shader(0, rgb_shader, 0);
-
- if(shader > 0)
- {
+ unsigned int shader = VFrame::make_shader(0, is_yuv ? yuv_shader : rgb_shader, 0);
+ if( shader > 0 ) {
glUseProgram(shader);
glUniform1i(glGetUniformLocation(shader, "tex"), 0);
glUniform1f(glGetUniformLocation(shader, "min"), config.min);
glUniform1f(glGetUniformLocation(shader, "max"), config.max);
- if (is_yuv)
- {
+ if (is_yuv) {
float y_low, u_low, v_low;
float y_mid, u_mid, v_mid;
float y_high, u_high, v_high;
- YUV::yuv.rgb_to_yuv_f((float)config.low_color.r / 0xff,
- (float)config.low_color.g / 0xff,
- (float)config.low_color.b / 0xff,
- y_low,
- u_low,
- v_low);
- u_low += 0.5;
- v_low += 0.5;
- YUV::yuv.rgb_to_yuv_f((float)config.mid_color.r / 0xff,
- (float)config.mid_color.g / 0xff,
- (float)config.mid_color.b / 0xff,
- y_mid,
- u_mid,
- v_mid);
- u_mid += 0.5;
- v_mid += 0.5;
- YUV::yuv.rgb_to_yuv_f((float)config.high_color.r / 0xff,
- (float)config.high_color.g / 0xff,
- (float)config.high_color.b / 0xff,
- y_high,
- u_high,
- v_high);
- u_high += 0.5;
- v_high += 0.5;
+ YUV::yuv.rgb_to_yuv_f(
+ (float)config.low_color.r / 0xff,
+ (float)config.low_color.g / 0xff,
+ (float)config.low_color.b / 0xff,
+ y_low, u_low, v_low);
+ u_low += 0.5; v_low += 0.5;
+ YUV::yuv.rgb_to_yuv_f(
+ (float)config.mid_color.r / 0xff,
+ (float)config.mid_color.g / 0xff,
+ (float)config.mid_color.b / 0xff,
+ y_mid, u_mid, v_mid);
+ u_mid += 0.5; v_mid += 0.5;
+ YUV::yuv.rgb_to_yuv_f(
+ (float)config.high_color.r / 0xff,
+ (float)config.high_color.g / 0xff,
+ (float)config.high_color.b / 0xff,
+ y_high, u_high, v_high);
+ u_high += 0.5; v_high += 0.5;
glUniform4f(glGetUniformLocation(shader, "low_color"),
- y_low, u_low, v_low,
- has_alpha ? (float)config.low_color.a / 0xff : 1.0);
+ y_low, u_low, v_low,
+ has_alpha ? (float)config.low_color.a / 0xff : 1.0);
glUniform4f(glGetUniformLocation(shader, "mid_color"),
- y_mid, u_mid, v_mid,
- has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
+ y_mid, u_mid, v_mid,
+ has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
glUniform4f(glGetUniformLocation(shader, "high_color"),
- y_high, u_high, v_high,
- has_alpha ? (float)config.high_color.a / 0xff : 1.0);
- } else {
+ y_high, u_high, v_high,
+ has_alpha ? (float)config.high_color.a / 0xff : 1.0);
+ }
+ else {
glUniform4f(glGetUniformLocation(shader, "low_color"),
- (float)config.low_color.r / 0xff,
- (float)config.low_color.g / 0xff,
- (float)config.low_color.b / 0xff,
- has_alpha ? (float)config.low_color.a / 0xff : 1.0);
+ (float)config.low_color.r / 0xff,
+ (float)config.low_color.g / 0xff,
+ (float)config.low_color.b / 0xff,
+ has_alpha ? (float)config.low_color.a / 0xff : 1.0);
glUniform4f(glGetUniformLocation(shader, "mid_color"),
- (float)config.mid_color.r / 0xff,
- (float)config.mid_color.g / 0xff,
- (float)config.mid_color.b / 0xff,
- has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
+ (float)config.mid_color.r / 0xff,
+ (float)config.mid_color.g / 0xff,
+ (float)config.mid_color.b / 0xff,
+ has_alpha ? (float)config.mid_color.a / 0xff : 1.0);
glUniform4f(glGetUniformLocation(shader, "high_color"),
- (float)config.high_color.r / 0xff,
- (float)config.high_color.g / 0xff,
- (float)config.high_color.b / 0xff,
- has_alpha ? (float)config.high_color.a / 0xff : 1.0);
+ (float)config.high_color.r / 0xff,
+ (float)config.high_color.g / 0xff,
+ (float)config.high_color.b / 0xff,
+ has_alpha ? (float)config.high_color.a / 0xff : 1.0);
+ BC_GL_RGB_TO_YUV(shader);
}
}
*
*/
-#include "clip.h"
+#include "bccolors.h"
#include "bchash.h"
+#include "clip.h"
#include "filexml.h"
#include "keyframe.h"
#include "language.h"
}
}
-#define RGB_TO_VALUE(r, g, b) \
-((r) * R_TO_Y + (g) * G_TO_Y + (b) * B_TO_Y)
+#define RGB_TO_VALUE(r, g, b) YUV::yuv.rgb_to_y_f((r),(g),(b))
// Only AVERAGE and ACCUMULATE use this
#define SUBTRACT_ACCUM(type, \
{ \
unsigned int choice = invertion gradient_row[j]; \
{ \
- out_row[0] = framelist[choice]->get_rows()[i][j * components + 0]; \
- out_row[1] = framelist[choice]->get_rows()[i][j * components + 1]; \
- out_row[2] = framelist[choice]->get_rows()[i][j * components + 2]; \
+ type *in_row = (type *)framelist[choice]->get_rows()[i]; \
+ out_row[0] = in_row[j * components + 0]; \
+ out_row[1] = in_row[j * components + 1]; \
+ out_row[2] = in_row[j * components + 2]; \
if (components == 4) \
- out_row[3] = framelist[choice]->get_rows()[i][j * components + 3]; \
+ out_row[3] = in_row[j * components + 3]; \
} \
out_row += components; \
} \
static void get_mask_colors(int rgb, int color_model, int &rr, int &gg, int &bb)
{
int r = 0xff & (rgb>>16), g = 0xff & (rgb>>8), b = 0xff & (rgb>>0);
- if( BC_CModels::is_yuv(color_model) ) bc_rgb2yuv(r,g,b, r,g,b);
+ if( BC_CModels::is_yuv(color_model) ) YUV::yuv.rgb_to_yuv_8(r,g,b);
rr = r; gg = g; bb = b;
}
y = temp_type((float)y * y_scale + round); \
u = temp_type((float)(u - (max / 2 + 1)) * u_scale + round) + (max / 2 + 1); \
v = temp_type((float)(v - (max / 2 + 1)) * v_scale + round) + (max / 2 + 1); \
+ \
+ CLAMP(y, 0, max); \
+ CLAMP(u, 0, max); \
+ CLAMP(v, 0, max); \
} \
else \
{ \
projects / goodguy / history.git / commitdiff