aspect = 1.0;
radius = 1.0;
mode = SPHERICAL_SHRINK;
- interp = INTERP_BILINEAR;
+ interp = INTERP_DEFAULT;
center_x = 50.0;
center_y = 50.0;
draw_guides = 0;
void LensInterp::create_objects()
{
+ add_item(new LensInterpItem(_("Default"), LensConfig::INTERP_DEFAULT));
add_item(new LensInterpItem(_("Nearest"), LensConfig::INTERP_NEAREST));
add_item(new LensInterpItem(_("BiLinear"), LensConfig::INTERP_BILINEAR));
add_item(new LensInterpItem(_("BiCubic"), LensConfig::INTERP_BICUBIC));
NEW_WINDOW_MACRO(LensMain, LensGUI)
LOAD_CONFIGURATION_MACRO(LensMain, LensConfig)
int LensMain::is_realtime() { return 1; }
-const char* LensMain::plugin_title() { return _("Lens"); }
+const char* LensMain::plugin_title() { return N_("Lens"); }
void LensMain::update_gui()
{
// cause data to be stored directly in text
- output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
+ output.set_shared_output(keyframe->xbuf);
output.tag.set_title("LENS");
for( int i = 0; i < FOV_CHANNELS; ++i ) {
sprintf(string, "FOCAL_LENGTH%d", i);
char string[BCTEXTLEN];
- input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
+ input.set_shared_input(keyframe->xbuf);
int result = 0;
int64_t start_position,
double frame_rate)
{
- VFrame *input;
load_configuration();
+ int use_opengl = config.interp != LensConfig::INTERP_DEFAULT ? 0 :
+ get_use_opengl();
+ VFrame *input = use_opengl ? frame :
+ new_temp(frame->get_w(), frame->get_h(), frame->get_color_model());
+ read_frame(input, 0, start_position, frame_rate, use_opengl);
- if( get_use_opengl() ) {
- input = frame;
- }
- else {
- input = new_temp(frame->get_w(), frame->get_h(), frame->get_color_model());
- }
-
- read_frame(input,
- 0,
- start_position,
- frame_rate,
- get_use_opengl());
-
-
- if( get_use_opengl() ) {
+ if( use_opengl ) {
run_opengl();
return 0;
}
- else {
- if( !engine ) engine = new LensEngine(this);
- engine->process_packages();
- if( config.draw_guides ) {
+
+ if( !engine ) engine = new LensEngine(this);
+ engine->process_packages();
+
+ if( config.draw_guides ) {
// Draw center
#define CENTER_H 20
#define CENTER_W 20
} \
}
- int w = get_output()->get_w();
- int h = get_output()->get_h();
- int center_x = (int)(config.center_x * w / 100);
- int center_y = (int)(config.center_y * h / 100);
- switch( get_output()->get_color_model() )
- {
- case BC_RGB_FLOAT:
- DRAW_GUIDES(3, float, 1.0)
- break;
- case BC_RGBA_FLOAT:
- DRAW_GUIDES(4, float, 1.0)
- break;
- case BC_RGB888:
- DRAW_GUIDES(3, unsigned char, 0xff)
- break;
- case BC_RGBA8888:
- DRAW_GUIDES(4, unsigned char, 0xff)
- break;
- case BC_YUV888:
- DRAW_GUIDES(3, unsigned char, 0xff)
- break;
- case BC_YUVA8888:
- DRAW_GUIDES(4, unsigned char, 0xff)
- break;
- }
-
+ int w = get_output()->get_w();
+ int h = get_output()->get_h();
+ int center_x = (int)(config.center_x * w / 100);
+ int center_y = (int)(config.center_y * h / 100);
+ switch( get_output()->get_color_model() ) {
+ case BC_RGB_FLOAT:
+ DRAW_GUIDES(3, float, 1.0)
+ break;
+ case BC_RGBA_FLOAT:
+ DRAW_GUIDES(4, float, 1.0)
+ break;
+ case BC_RGB888:
+ DRAW_GUIDES(3, unsigned char, 0xff)
+ break;
+ case BC_RGBA8888:
+ DRAW_GUIDES(4, unsigned char, 0xff)
+ break;
+ case BC_YUV888:
+ DRAW_GUIDES(3, unsigned char, 0xff)
+ break;
+ case BC_YUVA8888:
+ DRAW_GUIDES(4, unsigned char, 0xff)
+ break;
}
}
"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();
break; \
} \
break; \
+ case LensConfig::INTERP_DEFAULT: \
case LensConfig::INTERP_BILINEAR: \
switch( icolor_model ) { \
case BC_RGB888: \
projects / goodguy / history.git / blobdiff