cinelerra-5.1/cinelerra/affine.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_GL
  23 #define GL_GLEXT_PROTOTYPES
  24 #include <GL/gl.h>
  25 #endif
  26
  27 #include "affine.h"
  28 #include "interp.h"
  29 #include "clip.h"
  30 #include "vframe.h"
  31
  32
  33 #include <math.h>
  34 #include <stdint.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37
  38 AffineMatrix::AffineMatrix()
  39 {
  40         bzero(values, sizeof(values));
  41 }
  42
  43 void AffineMatrix::identity()
  44 {
  45         bzero(values, sizeof(values));
  46         values[0][0] = 1;
  47         values[1][1] = 1;
  48         values[2][2] = 1;
  49 }
  50
  51 void AffineMatrix::translate(double x, double y)
  52 {
  53         double g = values[2][0];
  54         double h = values[2][1];
  55         double i = values[2][2];
  56         values[0][0] += x * g;
  57         values[0][1] += x * h;
  58         values[0][2] += x * i;
  59         values[1][0] += y * g;
  60         values[1][1] += y * h;
  61         values[1][2] += y * i;
  62 }
  63
  64 void AffineMatrix::scale(double x, double y)
  65 {
  66         values[0][0] *= x;
  67         values[0][1] *= x;
  68         values[0][2] *= x;
  69
  70         values[1][0] *= y;
  71         values[1][1] *= y;
  72         values[1][2] *= y;
  73 }
  74
  75 void AffineMatrix::multiply(AffineMatrix *dst)
  76 {
  77         AffineMatrix tmp;
  78
  79         for( int i=0; i<3; ++i ) {
  80                 double t1 = values[i][0], t2 = values[i][1], t3 = values[i][2];
  81                 for( int j=0; j<3; ++j ) {
  82                         tmp.values[i][j]  = t1 * dst->values[0][j];
  83                         tmp.values[i][j] += t2 * dst->values[1][j];
  84                         tmp.values[i][j] += t3 * dst->values[2][j];
  85                 }
  86         }
  87         dst->copy_from(&tmp);
  88 }
  89
  90 double AffineMatrix::determinant()
  91 {
  92         double determinant;
  93
  94         determinant  =
  95                 values[0][0] * (values[1][1] * values[2][2] - values[1][2] * values[2][1]);
  96         determinant -=
  97                 values[1][0] * (values[0][1] * values[2][2] - values[0][2] * values[2][1]);
  98         determinant +=
  99                 values[2][0] * (values[0][1] * values[1][2] - values[0][2] * values[1][1]);
 100
 101         return determinant;
 102 }
 103
 104 void AffineMatrix::invert(AffineMatrix *dst)
 105 {
 106         double det_1;
 107
 108         det_1 = determinant();
 109
 110         if(det_1 == 0.0)
 111         return;
 112
 113         det_1 = 1.0 / det_1;
 114
 115         dst->values[0][0] =
 116                 (values[1][1] * values[2][2] - values[1][2] * values[2][1]) * det_1;
 117
 118         dst->values[1][0] =
 119                 - (values[1][0] * values[2][2] - values[1][2] * values[2][0]) * det_1;
 120
 121         dst->values[2][0] =
 122                 (values[1][0] * values[2][1] - values[1][1] * values[2][0]) * det_1;
 123
 124         dst->values[0][1] =
 125                 - (values[0][1] * values[2][2] - values[0][2] * values[2][1] ) * det_1;
 126
 127         dst->values[1][1] =
 128                 (values[0][0] * values[2][2] - values[0][2] * values[2][0]) * det_1;
 129
 130         dst->values[2][1] =
 131                 - (values[0][0] * values[2][1] - values[0][1] * values[2][0]) * det_1;
 132
 133         dst->values[0][2] =
 134                 (values[0][1] * values[1][2] - values[0][2] * values[1][1]) * det_1;
 135
 136         dst->values[1][2] =
 137                 - (values[0][0] * values[1][2] - values[0][2] * values[1][0]) * det_1;
 138
 139         dst->values[2][2] =
 140                 (values[0][0] * values[1][1] - values[0][1] * values[1][0]) * det_1;
 141 }
 142
 143 void AffineMatrix::copy_from(AffineMatrix *src)
 144 {
 145         memcpy(&values[0][0], &src->values[0][0], sizeof(values));
 146 }
 147
 148 void AffineMatrix::set_matrix(
 149         double in_x1, double in_y1, double in_x2, double in_y2,
 150         double out_x1, double out_y1, double out_x2, double out_y2,
 151         double out_x3, double out_y3, double out_x4, double out_y4)
 152 {
 153         double scalex = in_x2 > in_x1 ? 1./(in_x2 - in_x1) : 1.0;
 154         double scaley = in_y2 > in_y1 ? 1./(in_y2 - in_y1) : 1.0;
 155         double dx1 = out_x2 - out_x4, dx2 = out_x3 - out_x4;
 156         double dx3 = out_x1 - out_x2 + out_x4 - out_x3;
 157
 158         double dy1 = out_y2 - out_y4, dy2 = out_y3 - out_y4;
 159         double dy3 = out_y1 - out_y2 + out_y4 - out_y3;
 160         double det = dx1 * dy2 - dy1 * dx2;
 161         if( !det ) { identity();  return; }
 162
 163         AffineMatrix m;
 164         m.values[2][0] = (dx3 * dy2 - dy3 * dx2) / det;
 165         m.values[2][1] = (dx1 * dy3 - dy1 * dx3) / det;
 166         m.values[0][0] = out_x2 - out_x1 + m.values[2][0] * out_x2;
 167         m.values[0][1] = out_x3 - out_x1 + m.values[2][1] * out_x3;
 168         m.values[0][2] = out_x1;
 169         m.values[1][0] = out_y2 - out_y1 + m.values[2][0] * out_y2;
 170         m.values[1][1] = out_y3 - out_y1 + m.values[2][1] * out_y3;
 171         m.values[1][2] = out_y1;
 172         m.values[2][2] = 1.0;
 173
 174         identity();
 175         translate(-in_x1, -in_y1);
 176         scale(scalex, scaley);
 177         m.multiply(this);
 178 }
 179
 180 void AffineMatrix::transform_point(float x,
 181         float y,
 182         float *newx,
 183         float *newy)
 184 {
 185         double w;
 186
 187         w = values[2][0] * x + values[2][1] * y + values[2][2];
 188         w = !w ? 1 : 1/w;
 189
 190         *newx = (values[0][0] * x + values[0][1] * y + values[0][2]) * w;
 191         *newy = (values[1][0] * x + values[1][1] * y + values[1][2]) * w;
 192 }
 193
 194 void AffineMatrix::dump()
 195 {
 196         printf("AffineMatrix::dump\n");
 197         printf("%f %f %f\n", values[0][0], values[0][1], values[0][2]);
 198         printf("%f %f %f\n", values[1][0], values[1][1], values[1][2]);
 199         printf("%f %f %f\n", values[2][0], values[2][1], values[2][2]);
 200 }
 201
 202
 203
 204
 205
 206 AffinePackage::AffinePackage()
 207  : LoadPackage()
 208 {
 209 }
 210
 211
 212
 213
 214 AffineUnit::AffineUnit(AffineEngine *server)
 215  : LoadClient(server)
 216 {
 217         this->server = server;
 218 }
 219
 220
 221 static inline float transform_cubic(float dx,
 222                 float p0, float p1, float p2, float p3)
 223 {
 224 /* Catmull-Rom - not bad */
 225         float result = ((( (- p0 + 3*p1 - 3*p2 + p3) * dx +
 226                          ( 2*p0 - 5*p1 + 4*p2 - p3 ) ) * dx +
 227                          ( - p0 + p2 ) ) * dx + (p1 + p1) ) / 2;
 228 // printf("%f %f %f %f %f\n", result, p0, p1, p2, p3);
 229         return result;
 230 }
 231
 232 static inline float transform_linear(float dx,
 233                 float p1, float p2)
 234 {
 235         float result = p1 * (1-dx) + p2 * dx;
 236         return result;
 237 }
 238
 239
 240 void AffineUnit::process_package(LoadPackage *package)
 241 {
 242         AffinePackage *pkg = (AffinePackage*)package;
 243         int min_in_x = server->in_x;
 244         int min_in_y = server->in_y;
 245         int max_in_x = server->in_x + server->in_w - 1;
 246         int max_in_y = server->in_y + server->in_h - 1;
 247
 248
 249 // printf("AffineUnit::process_package %d %d %d %d %d\n",
 250 // __LINE__,
 251 // min_in_x,
 252 // min_in_y,
 253 // max_in_x,
 254 // max_in_y);
 255         int min_out_x = server->out_x;
 256         //int min_out_y = server->out_y;
 257         int max_out_x = server->out_x + server->out_w;
 258         //int max_out_y = server->out_y + server->out_h;
 259
 260 // Amount to shift the input coordinates relative to the output coordinates
 261 // To get the pivots to line up
 262         int pivot_offset_x = server->in_pivot_x - server->out_pivot_x;
 263         int pivot_offset_y = server->in_pivot_y - server->out_pivot_y;
 264
 265 // Calculate real coords
 266         float out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4;
 267         if( server->mode == AffineEngine::STRETCH ||
 268             server->mode == AffineEngine::PERSPECTIVE ||
 269             server->mode == AffineEngine::ROTATE ||
 270             server->mode == AffineEngine::TRANSFORM ) {
 271                 out_x1 = (float)server->in_x + (float)server->x1 * server->in_w / 100;
 272                 out_y1 = (float)server->in_y + (float)server->y1 * server->in_h / 100;
 273                 out_x2 = (float)server->in_x + (float)server->x2 * server->in_w / 100;
 274                 out_y2 = (float)server->in_y + (float)server->y2 * server->in_h / 100;
 275                 out_x3 = (float)server->in_x + (float)server->x3 * server->in_w / 100;
 276                 out_y3 = (float)server->in_y + (float)server->y3 * server->in_h / 100;
 277                 out_x4 = (float)server->in_x + (float)server->x4 * server->in_w / 100;
 278                 out_y4 = (float)server->in_y + (float)server->y4 * server->in_h / 100;
 279         }
 280         else {
 281                 out_x1 = (float)server->in_x + (float)server->x1 * server->in_w / 100;
 282                 out_y1 = server->in_y;
 283                 out_x2 = out_x1 + server->in_w;
 284                 out_y2 = server->in_y;
 285                 out_x4 = (float)server->in_x + (float)server->x4 * server->in_w / 100;
 286                 out_y4 = server->in_y + server->in_h;
 287                 out_x3 = out_x4 + server->in_w;
 288                 out_y3 = server->in_y + server->in_h;
 289         }
 290
 291
 292
 293 // Rotation with OpenGL uses a simple quad.
 294         if( server->mode == AffineEngine::ROTATE &&
 295             server->use_opengl ) {
 296 #ifdef HAVE_GL
 297                 out_x1 -= pivot_offset_x;  out_y1 -= pivot_offset_y;
 298                 out_x2 -= pivot_offset_x;  out_y2 -= pivot_offset_y;
 299                 out_x3 -= pivot_offset_x;  out_y3 -= pivot_offset_y;
 300                 out_x4 -= pivot_offset_x;  out_y4 -= pivot_offset_y;
 301
 302                 server->output->to_texture();
 303                 server->output->enable_opengl();
 304                 server->output->init_screen();
 305                 server->output->bind_texture(0);
 306                 server->output->clear_pbuffer();
 307
 308                 int texture_w = server->output->get_texture_w();
 309                 int texture_h = server->output->get_texture_h();
 310                 float output_h = server->output->get_h();
 311                 float in_x1 = (float)server->in_x / texture_w;
 312                 float in_x2 = (float)(server->in_x + server->in_w) / texture_w;
 313                 float in_y1 = (float)server->in_y / texture_h;
 314                 float in_y2 = (float)(server->in_y + server->in_h) / texture_h;
 315
 316 // printf("%f %f %f %f\n%f,%f %f,%f %f,%f %f,%f\n", in_x1, in_y1, in_x2, in_y2,
 317 // out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4);
 318
 319                 glBegin(GL_QUADS);
 320                 glNormal3f(0, 0, 1.0);
 321
 322                 glTexCoord2f(in_x1, in_y1);
 323                 glVertex3f(out_x1, -output_h+out_y1, 0);
 324
 325                 glTexCoord2f(in_x2, in_y1);
 326                 glVertex3f(out_x2, -output_h+out_y2, 0);
 327
 328                 glTexCoord2f(in_x2, in_y2);
 329                 glVertex3f(out_x3, -output_h+out_y3, 0);
 330
 331                 glTexCoord2f(in_x1, in_y2);
 332                 glVertex3f(out_x4, -output_h+out_y4, 0);
 333
 334
 335                 glEnd();
 336
 337                 server->output->set_opengl_state(VFrame::SCREEN);
 338 #endif
 339         }
 340         else
 341         if( server->mode == AffineEngine::PERSPECTIVE ||
 342             server->mode == AffineEngine::SHEER ||
 343             server->mode == AffineEngine::ROTATE ||
 344             server->mode == AffineEngine::TRANSFORM ) {
 345                 AffineMatrix matrix;
 346                 float temp;
 347 // swap points 3 & 4
 348                 temp = out_x4;
 349                 out_x4 = out_x3;
 350                 out_x3 = temp;
 351                 temp = out_y4;
 352                 out_y4 = out_y3;
 353                 out_y3 = temp;
 354
 355
 356
 357
 358
 359                 if( server->mode != AffineEngine::TRANSFORM ) {
 360                         matrix.set_matrix(server->in_x, server->in_y,
 361                                 server->in_x + server->in_w,
 362                                 server->in_y + server->in_h,
 363                                 out_x1, out_y1, out_x2, out_y2,
 364                                 out_x3, out_y3, out_x4, out_y4);
 365                 }
 366                 else {
 367                         matrix.copy_from(&server->matrix);
 368                 }
 369
 370 //printf("AffineUnit::process_package %d\n%f %f %f\n%f %f %f\n%f %f %f\n", __LINE__,
 371 // matrix.values[0][0], matrix.values[0][1], matrix.values[0][2],
 372 // matrix.values[1][0], matrix.values[1][1], matrix.values[1][2],
 373 // matrix.values[2][0], matrix.values[2][1], matrix.values[2][2]);
 374                 int reverse = !server->forward;
 375                 float tx, ty, tw;
 376                 float xinc, yinc, winc;
 377                 AffineMatrix m, im;
 378                 float ttx = 0, tty = 0;
 379                 int tx1 = 0, ty1 = 0, tx2 = 0, ty2 = 0;
 380
 381                 if(reverse) {
 382                         m.copy_from(&matrix);
 383                         m.invert(&im);
 384                         matrix.copy_from(&im);
 385                 }
 386                 else {
 387                         matrix.invert(&m);
 388                 }
 389
 390                 float dx1 = 0, dy1 = 0;
 391                 float dx2 = 0, dy2 = 0;
 392                 float dx3 = 0, dy3 = 0;
 393                 float dx4 = 0, dy4 = 0;
 394                 matrix.transform_point(server->in_x, server->in_y, &dx1, &dy1);
 395                 matrix.transform_point(server->in_x + server->in_w, server->in_y, &dx2, &dy2);
 396                 matrix.transform_point(server->in_x, server->in_y + server->in_h, &dx3, &dy3);
 397                 matrix.transform_point(server->in_x + server->in_w, server->in_y + server->in_h, &dx4, &dy4);
 398
 399 //printf("AffineUnit::process_package 1 y1=%d y2=%d\n", pkg->y1, pkg->y2);
 400 //printf("AffineUnit::process_package 1 %f %f %f %f\n", dy1, dy2, dy3, dy4);
 401 // printf("AffineUnit::process_package %d use_opengl=%d\n",
 402 // __LINE__, server->use_opengl);
 403
 404                 if( server->use_opengl &&
 405                     server->interpolation == AffineEngine::AF_DEFAULT ) {
 406 #ifdef HAVE_GL
 407                         static const char *affine_frag =
 408                                 "uniform sampler2D tex;\n"
 409                                 "uniform mat3 affine_matrix;\n"
 410                                 "uniform vec2 texture_extents;\n"
 411                                 "uniform vec2 image_extents;\n"
 412                                 "uniform vec4 border_color;\n"
 413                                 "void main()\n"
 414                                 "{\n"
 415                                 "       vec2 outcoord = gl_TexCoord[0].st;\n"
 416                                 "       outcoord *= texture_extents;\n"
 417                                 "       mat3 coord_matrix = mat3(\n"
 418                                 "               outcoord.x, outcoord.y, 1.0, \n"
 419                                 "               outcoord.x, outcoord.y, 1.0, \n"
 420                                 "               outcoord.x, outcoord.y, 1.0);\n"
 421                                 "       mat3 incoord_matrix = affine_matrix * coord_matrix;\n"
 422                                 "       vec2 incoord = vec2(incoord_matrix[0][0], incoord_matrix[0][1]);\n"
 423                                 "       incoord /= incoord_matrix[0][2];\n"
 424                                 "       incoord /= texture_extents;\n"
 425                                 "       if(incoord.x > image_extents.x || incoord.y > image_extents.y)\n"
 426                                 "               gl_FragColor = border_color;\n"
 427                                 "       else\n"
 428                                 "               gl_FragColor = texture2D(tex, incoord);\n"
 429                                 "}\n";
 430
 431                         float affine_matrix[9] = {
 432                                 (float)m.values[0][0], (float)m.values[1][0], (float)m.values[2][0],
 433                                 (float)m.values[0][1], (float)m.values[1][1], (float)m.values[2][1],
 434                                 (float)m.values[0][2], (float)m.values[1][2], (float)m.values[2][2]
 435                         };
 436
 437
 438                         server->output->to_texture();
 439                         server->output->enable_opengl();
 440                         unsigned int frag_shader = VFrame::make_shader(0, affine_frag, 0);
 441                         if( frag_shader > 0 ) {
 442                                 glUseProgram(frag_shader);
 443                                 glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
 444                                 glUniformMatrix3fv(glGetUniformLocation(frag_shader, "affine_matrix"),
 445                                         1, 0, affine_matrix);
 446                                 glUniform2f(glGetUniformLocation(frag_shader, "texture_extents"),
 447                                         (GLfloat)server->output->get_texture_w(),
 448                                         (GLfloat)server->output->get_texture_h());
 449                                 glUniform2f(glGetUniformLocation(frag_shader, "image_extents"),
 450                                         (GLfloat)server->output->get_w() / server->output->get_texture_w(),
 451                                         (GLfloat)server->output->get_h() / server->output->get_texture_h());
 452                                 float border_color[] = { 0, 0, 0, 0 };
 453                                 if(BC_CModels::is_yuv(server->output->get_color_model())) {
 454                                         border_color[1] = 0.5;
 455                                         border_color[2] = 0.5;
 456                                 }
 457                                 if(!BC_CModels::has_alpha(server->output->get_color_model())) {
 458                                         border_color[3] = 1.0;
 459                                 }
 460
 461                                 glUniform4fv(glGetUniformLocation(frag_shader, "border_color"),
 462                                         1, (GLfloat*)border_color);
 463                                 server->output->init_screen();
 464                                 server->output->bind_texture(0);
 465                                 glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
 466                                 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
 467                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
 468                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
 469                                 server->output->draw_texture();
 470                                 glUseProgram(0);
 471                                 server->output->set_opengl_state(VFrame::SCREEN);
 472                         }
 473                         return;
 474 #endif // HAVE_GL
 475                 }
 476
 477 #define ROUND(x) ((int)((x > 0) ? (x) + 0.5 : (x) - 0.5))
 478 #define MIN4(a,b,c,d) MIN(MIN(MIN(a,b),c),d)
 479 #define MAX4(a,b,c,d) MAX(MAX(MAX(a,b),c),d)
 480
 481         tx1 = ROUND(MIN4(dx1 - pivot_offset_x, dx2 - pivot_offset_x, dx3 - pivot_offset_x, dx4 - pivot_offset_x));
 482         ty1 = ROUND(MIN4(dy1 - pivot_offset_y, dy2 - pivot_offset_y, dy3 - pivot_offset_y, dy4 - pivot_offset_y));
 483
 484         tx2 = ROUND(MAX4(dx1 - pivot_offset_x, dx2 - pivot_offset_x, dx3 - pivot_offset_x, dx4 - pivot_offset_x));
 485         ty2 = ROUND(MAX4(dy1 - pivot_offset_y, dy2 - pivot_offset_y, dy3 - pivot_offset_y, dy4 - pivot_offset_y));
 486
 487         CLAMP(ty1, pkg->y1, pkg->y2);
 488         CLAMP(ty2, pkg->y1, pkg->y2);
 489         CLAMP(tx1, server->out_x, server->out_x + server->out_w);
 490         CLAMP(tx2, server->out_x, server->out_x + server->out_w);
 491
 492
 493         xinc = m.values[0][0];
 494         yinc = m.values[1][0];
 495         winc = m.values[2][0];
 496
 497 //printf("AffineUnit::process_package 2 tx1=%d ty1=%d tx2=%d ty2=%d %f %f\n",
 498 // tx1, ty1, tx2, ty2, out_x4, out_y4);
 499 //printf("AffineUnit::process_package %d %d %d %d %d\n",
 500 // __LINE__, min_in_x, max_in_x, min_in_y, max_in_y);
 501
 502 #define DO_INTERP(tag, interp, components, type, temp_type, chroma, max) \
 503 case tag: { \
 504     type **inp_rows = (type**)server->input->get_rows(); \
 505     type **out_rows = (type**)server->output->get_rows(); \
 506     float round_factor = sizeof(type) < 4 ? 0.5 : 0; \
 507     INTERP_SETUP(inp_rows, max, min_in_x,min_in_y, max_in_x,max_in_y); \
 508  \
 509     for( int y=ty1; y<ty2; ++y ) { \
 510         type *out_row = (type*)out_rows[y]; \
 511         int x1 = tx1, x2 = tx2; \
 512         if( x1 < min_out_x ) x1 = min_out_x; \
 513         if( x2 > max_out_x ) x2 = max_out_x; \
 514         tx = xinc * x1 + m.values[0][1] * (y + pivot_offset_y) + m.values[0][2] \
 515             + pivot_offset_x * xinc; \
 516         ty = yinc * x1 + m.values[1][1] * (y + pivot_offset_y) + m.values[1][2] \
 517             + pivot_offset_x * yinc; \
 518         tw = winc * x1 + m.values[2][1] * (y + pivot_offset_y) + m.values[2][2] \
 519             + pivot_offset_x * winc; \
 520         type *out = out_row + x1 * components; \
 521  \
 522         for( int x=x1; x<x2; ++x ) { \
 523 /* Normalize homogeneous coords */ \
 524             if( tw == 0.0 ) { ttx = 0.0; tty = 0.0; } \
 525             else { ttx = tx / tw; tty = ty / tw; } \
 526             interp##_SETUP(type, components, ttx, tty); \
 527             *out++ = ((temp_type)interp##_interp(0, 0) + round_factor); \
 528             interp##_next(); \
 529             *out++ = ((temp_type)interp##_interp(chroma, chroma) + round_factor); \
 530             interp##_next(); \
 531             *out++ = ((temp_type)interp##_interp(chroma, chroma) + round_factor); \
 532             if( components == 4 ) { \
 533                 interp##_next(); \
 534                 *out++ = ((temp_type)interp##_interp(0, 0) + round_factor); \
 535             } \
 536  \
 537 /*  increment the transformed coordinates  */ \
 538             tx += xinc;  ty += yinc;  tw += winc; \
 539         } \
 540     } \
 541 } break
 542
 543 // printf("AffineUnit::process_package %d tx1=%d ty1=%d tx2=%d ty2=%d\n",
 544 // __LINE__, tx1, ty1, tx2, ty2);
 545
 546                 switch( server->interpolation ) {
 547                 case AffineEngine::AF_NEAREST:
 548                         switch( server->input->get_color_model() ) {
 549                         DO_INTERP( BC_RGB_FLOAT, nearest, 3, float, float, 0x0, 1.0);
 550                         DO_INTERP( BC_RGB888, nearest, 3, unsigned char, int, 0x0, 0xff);
 551                         DO_INTERP( BC_RGBA_FLOAT, nearest, 4, float, float, 0x0, 1.0);
 552                         DO_INTERP( BC_RGBA8888, nearest, 4, unsigned char, int, 0x0, 0xff);
 553                         DO_INTERP( BC_YUV888, nearest, 3, unsigned char, int, 0x80, 0xff);
 554                         DO_INTERP( BC_YUVA8888, nearest, 4, unsigned char, int, 0x80, 0xff);
 555                         DO_INTERP( BC_RGB161616, nearest, 3, uint16_t, int, 0x0, 0xffff);
 556                         DO_INTERP( BC_RGBA16161616, nearest, 4, uint16_t, int, 0x0, 0xffff);
 557                         DO_INTERP( BC_YUV161616, nearest, 3, uint16_t, int, 0x8000, 0xffff);
 558                         DO_INTERP( BC_YUVA16161616, nearest, 4, uint16_t, int, 0x8000, 0xffff);
 559                         }
 560                         break;
 561                 case AffineEngine::AF_LINEAR:
 562                         switch( server->input->get_color_model() ) {
 563                         DO_INTERP( BC_RGB_FLOAT, bi_linear, 3, float, float, 0x0, 1.0);
 564                         DO_INTERP( BC_RGB888, bi_linear, 3, unsigned char, int, 0x0, 0xff);
 565                         DO_INTERP( BC_RGBA_FLOAT, bi_linear, 4, float, float, 0x0, 1.0);
 566                         DO_INTERP( BC_RGBA8888, bi_linear, 4, unsigned char, int, 0x0, 0xff);
 567                         DO_INTERP( BC_YUV888, bi_linear, 3, unsigned char, int, 0x80, 0xff);
 568                         DO_INTERP( BC_YUVA8888, bi_linear, 4, unsigned char, int, 0x80, 0xff);
 569                         DO_INTERP( BC_RGB161616, bi_linear, 3, uint16_t, int, 0x0, 0xffff);
 570                         DO_INTERP( BC_RGBA16161616, bi_linear, 4, uint16_t, int, 0x0, 0xffff);
 571                         DO_INTERP( BC_YUV161616, bi_linear, 3, uint16_t, int, 0x8000, 0xffff);
 572                         DO_INTERP( BC_YUVA16161616, bi_linear, 4, uint16_t, int, 0x8000, 0xffff);
 573                         }
 574                         break;
 575                 default:
 576                 case AffineEngine::AF_CUBIC:
 577                         switch( server->input->get_color_model() ) {
 578                         DO_INTERP( BC_RGB_FLOAT, bi_cubic, 3, float, float, 0x0, 1.0);
 579                         DO_INTERP( BC_RGB888, bi_cubic, 3, unsigned char, int, 0x0, 0xff);
 580                         DO_INTERP( BC_RGBA_FLOAT, bi_cubic, 4, float, float, 0x0, 1.0);
 581                         DO_INTERP( BC_RGBA8888, bi_cubic, 4, unsigned char, int, 0x0, 0xff);
 582                         DO_INTERP( BC_YUV888, bi_cubic, 3, unsigned char, int, 0x80, 0xff);
 583                         DO_INTERP( BC_YUVA8888, bi_cubic, 4, unsigned char, int, 0x80, 0xff);
 584                         DO_INTERP( BC_RGB161616, bi_cubic, 3, uint16_t, int, 0x0, 0xffff);
 585                         DO_INTERP( BC_RGBA16161616, bi_cubic, 4, uint16_t, int, 0x0, 0xffff);
 586                         DO_INTERP( BC_YUV161616, bi_cubic, 3, uint16_t, int, 0x8000, 0xffff);
 587                         DO_INTERP( BC_YUVA16161616, bi_cubic, 4, uint16_t, int, 0x8000, 0xffff);
 588                         }
 589                         break;
 590                 }
 591         }
 592         else
 593         {
 594                 int min_x = server->in_x * AFFINE_OVERSAMPLE;
 595                 int min_y = server->in_y * AFFINE_OVERSAMPLE;
 596                 int max_x = server->in_x * AFFINE_OVERSAMPLE + server->in_w * AFFINE_OVERSAMPLE - 1;
 597                 int max_y = server->in_y * AFFINE_OVERSAMPLE + server->in_h * AFFINE_OVERSAMPLE - 1;
 598                 float top_w = out_x2 - out_x1;
 599                 float bottom_w = out_x3 - out_x4;
 600                 float left_h = out_y4 - out_y1;
 601                 float right_h = out_y3 - out_y2;
 602                 float out_w_diff = bottom_w - top_w;
 603                 float out_left_diff = out_x4 - out_x1;
 604                 float out_h_diff = right_h - left_h;
 605                 float out_top_diff = out_y2 - out_y1;
 606                 float distance1 = DISTANCE(out_x1, out_y1, out_x2, out_y2);
 607                 float distance2 = DISTANCE(out_x2, out_y2, out_x3, out_y3);
 608                 float distance3 = DISTANCE(out_x3, out_y3, out_x4, out_y4);
 609                 float distance4 = DISTANCE(out_x4, out_y4, out_x1, out_y1);
 610                 float max_v = MAX(distance1, distance3);
 611                 float max_h = MAX(distance2, distance4);
 612                 float max_dimension = MAX(max_v, max_h);
 613                 float min_dimension = MIN(server->in_h, server->in_w);
 614                 float step = min_dimension / max_dimension / AFFINE_OVERSAMPLE;
 615                 float x_f = server->in_x;
 616                 float y_f = server->in_y;
 617                 float h_f = server->in_h;
 618                 float w_f = server->in_w;
 619
 620                 if(server->use_opengl) {
 621                         return;
 622                 }
 623
 624 // Projection
 625 #define DO_STRETCH(tag, type, components) \
 626 case tag: { \
 627         type **in_rows = (type**)server->input->get_rows(); \
 628         type **out_rows = (type**)server->temp->get_rows(); \
 629  \
 630         for(float in_y = pkg->y1; in_y < pkg->y2; in_y += step) \
 631         { \
 632                 int i = (int)in_y; \
 633                 type *in_row = in_rows[i]; \
 634                 for(float in_x = x_f; in_x < w_f; in_x += step) \
 635                 { \
 636                         int j = (int)in_x; \
 637                         float in_x_fraction = (in_x - x_f) / w_f; \
 638                         float in_y_fraction = (in_y - y_f) / h_f; \
 639                         int out_x = (int)((out_x1 + \
 640                                 out_left_diff * in_y_fraction + \
 641                                 (top_w + out_w_diff * in_y_fraction) * in_x_fraction) *  \
 642                                 AFFINE_OVERSAMPLE); \
 643                         int out_y = (int)((out_y1 +  \
 644                                 out_top_diff * in_x_fraction + \
 645                                 (left_h + out_h_diff * in_x_fraction) * in_y_fraction) * \
 646                                 AFFINE_OVERSAMPLE); \
 647                         CLAMP(out_x, min_x, max_x); \
 648                         CLAMP(out_y, min_y, max_y); \
 649                         type *dst = out_rows[out_y] + out_x * components; \
 650                         type *src = in_row + j * components; \
 651                         dst[0] = src[0]; \
 652                         dst[1] = src[1]; \
 653                         dst[2] = src[2]; \
 654                         if(components == 4) dst[3] = src[3]; \
 655                 } \
 656         } \
 657 } break
 658
 659                 switch( server->input->get_color_model() ) {
 660                 DO_STRETCH( BC_RGB_FLOAT, float, 3 );
 661                 DO_STRETCH( BC_RGB888, unsigned char, 3 );
 662                 DO_STRETCH( BC_RGBA_FLOAT, float, 4 );
 663                 DO_STRETCH( BC_RGBA8888, unsigned char, 4 );
 664                 DO_STRETCH( BC_YUV888, unsigned char, 3 );
 665                 DO_STRETCH( BC_YUVA8888, unsigned char, 4 );
 666                 DO_STRETCH( BC_RGB161616, uint16_t, 3 );
 667                 DO_STRETCH( BC_RGBA16161616, uint16_t, 4 );
 668                 DO_STRETCH( BC_YUV161616, uint16_t, 3 );
 669                 DO_STRETCH( BC_YUVA16161616, uint16_t, 4 );
 670                 }
 671         }
 672 }
 673
 674
 675 AffineEngine::AffineEngine(int total_clients, int total_packages)
 676  : LoadServer(total_clients, total_packages) //(1, 1)
 677 {
 678         user_in_viewport = 0;
 679         user_in_pivot = 0;
 680         user_out_viewport = 0;
 681         user_out_pivot = 0;
 682         use_opengl = 0;
 683         in_x = in_y = in_w = in_h = 0;
 684         out_x = out_y = out_w = out_h = 0;
 685         in_pivot_x = in_pivot_y = 0;
 686         out_pivot_x = out_pivot_y = 0;
 687         interpolation = AF_DEFAULT;
 688         this->total_packages = total_packages;
 689 }
 690
 691 void AffineEngine::init_packages()
 692 {
 693         int y1 = 0, npkgs = get_total_packages();
 694         for( int i=0; i<npkgs; ) {
 695                 AffinePackage *package = (AffinePackage*)get_package(i);
 696                 int y2 = out_y + (out_h * ++i / npkgs);
 697                 package->y1 = y1;  package->y2 = y2;  y1 = y2;
 698         }
 699 }
 700
 701 LoadClient* AffineEngine::new_client()
 702 {
 703         return new AffineUnit(this);
 704 }
 705
 706 LoadPackage* AffineEngine::new_package()
 707 {
 708         return new AffinePackage;
 709 }
 710
 711 void AffineEngine::process(VFrame *output, VFrame *input, VFrame *temp, int mode,
 712         float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4,
 713         int forward)
 714 {
 715
 716
 717 // printf("AffineEngine::process %d %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\n",
 718 // __LINE__, x1, y1, x2, y2, x3, y3, x4, y4);
 719 //
 720 // printf("AffineEngine::process %d %d %d %d %d\n",
 721 // __LINE__, in_x, in_y, in_w, in_h);
 722 //
 723 // printf("AffineEngine::process %d %d %d %d %d\n",
 724 // __LINE__, out_x, out_y, out_w, out_h);
 725 //
 726 // printf("AffineEngine::process %d %d %d %d %d\n",
 727 // __LINE__, in_pivot_x, in_pivot_y, out_pivot_x, out_pivot_y);
 728 //
 729 // printf("AffineEngine::process %d %d %d %d %d\n",
 730 // __LINE__, user_in_pivot, user_out_pivot, user_in_viewport, user_out_viewport);
 731
 732         this->output = output;
 733         this->input = input;
 734         this->temp = temp;
 735         this->mode = mode;
 736         this->x1 = x1;  this->y1 = y1;
 737         this->x2 = x2;  this->y2 = y2;
 738         this->x3 = x3;  this->y3 = y3;
 739         this->x4 = x4;  this->y4 = y4;
 740         this->forward = forward;
 741
 742         if(!user_in_viewport) {
 743                 in_x = 0;  in_y = 0;
 744                 in_w = input->get_w();
 745                 in_h = input->get_h();
 746         }
 747
 748         if(!user_out_viewport) {
 749                 out_x = 0;  out_y = 0;
 750                 out_w = output->get_w();
 751                 out_h = output->get_h();
 752         }
 753
 754         if(use_opengl) {
 755                 set_package_count(1);
 756                 process_single();
 757         }
 758         else {
 759                 set_package_count(total_packages);
 760                 process_packages();
 761         }
 762 }
 763
 764 void AffineEngine::set_matrix(
 765         double in_x1, double in_y1, double in_x2, double in_y2,
 766         double out_x1, double out_y1, double out_x2, double out_y2,
 767         double out_x3, double out_y3, double out_x4, double out_y4)
 768 {
 769         matrix.set_matrix(in_x1, in_y1, in_x2, in_y2,
 770                 out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4);
 771 }
 772
 773
 774 void AffineEngine::rotate(VFrame *output,
 775         VFrame *input,
 776         float angle)
 777 {
 778         this->output = output;
 779         this->input = input;
 780         this->temp = 0;
 781         this->mode = ROTATE;
 782         this->forward = 1;
 783
 784         if( !user_in_viewport ) {
 785                 in_x = 0;  in_y = 0;
 786                 in_w = input->get_w();
 787                 in_h = input->get_h();
 788 // DEBUG
 789 // in_x = 4;
 790 // in_w = 2992;
 791 // in_y = 4;
 792 // in_h = 2992;
 793 // printf("AffineEngine::rotate %d %d %d %d %d\n", __LINE__, in_x, in_w, in_y, in_h);
 794         }
 795
 796         if( !user_in_pivot ) {
 797                 in_pivot_x = in_x + in_w / 2;
 798                 in_pivot_y = in_y + in_h / 2;
 799         }
 800
 801         if( !user_out_viewport ) {
 802                 out_x = 0;  out_y = 0;
 803                 out_w = output->get_w();
 804                 out_h = output->get_h();
 805         }
 806
 807         if( !user_out_pivot ) {
 808                 out_pivot_x = out_x + out_w / 2;
 809                 out_pivot_y = out_y + out_h / 2;
 810         }
 811
 812 // All subscripts are clockwise around the quadrangle
 813         angle = angle * 2 * M_PI / 360;
 814         double angle1 = atan2((double)(in_pivot_y - in_y), (double)(in_pivot_x - in_x)) + angle;
 815         double angle2 = atan2((double)(in_x + in_w - in_pivot_x), (double)(in_pivot_y - in_y)) + angle;
 816         double angle3 = atan2((double)(in_y + in_h - in_pivot_y), (double)(in_x + in_w - in_pivot_x)) + angle;
 817         double angle4 = atan2((double)(in_pivot_x - in_x), (double)(in_y + in_h - in_pivot_y)) + angle;
 818         double radius1 = DISTANCE(in_x, in_y, in_pivot_x, in_pivot_y);
 819         double radius2 = DISTANCE(in_x + in_w, in_y, in_pivot_x, in_pivot_y);
 820         double radius3 = DISTANCE(in_x + in_w, in_y + in_h, in_pivot_x, in_pivot_y);
 821         double radius4 = DISTANCE(in_x, in_y + in_h, in_pivot_x, in_pivot_y);
 822
 823         x1 = ((in_pivot_x - in_x) - cos(angle1) * radius1) * 100 / in_w;
 824         y1 = ((in_pivot_y - in_y) - sin(angle1) * radius1) * 100 / in_h;
 825         x2 = ((in_pivot_x - in_x) + sin(angle2) * radius2) * 100 / in_w;
 826         y2 = ((in_pivot_y - in_y) - cos(angle2) * radius2) * 100 / in_h;
 827         x3 = ((in_pivot_x - in_x) + cos(angle3) * radius3) * 100 / in_w;
 828         y3 = ((in_pivot_y - in_y) + sin(angle3) * radius3) * 100 / in_h;
 829         x4 = ((in_pivot_x - in_x) - sin(angle4) * radius4) * 100 / in_w;
 830         y4 = ((in_pivot_y - in_y) + cos(angle4) * radius4) * 100 / in_h;
 831
 832 // printf("AffineEngine::rotate angle=%f\n",
 833 // angle);
 834
 835 //
 836 // printf("     angle1=%f angle2=%f angle3=%f angle4=%f\n",
 837 // angle1 * 360 / 2 / M_PI,  angle2 * 360 / 2 / M_PI,
 838 // angle3 * 360 / 2 / M_PI,  angle4 * 360 / 2 / M_PI);
 839 //
 840 // printf("     radius1=%f radius2=%f radius3=%f radius4=%f\n",
 841 // radius1, radius2, radius3, radius4);
 842 //
 843 // printf("     x1=%f y1=%f x2=%f y2=%f x3=%f y3=%f x4=%f y4=%f\n",
 844 // x1 * w / 100, y1 * h / 100,
 845 // x2 * w / 100, y2 * h / 100,
 846 // x3 * w / 100, y3 * h / 100,
 847 // x4 * w / 100, y4 * h / 100);
 848
 849         if(use_opengl) {
 850                 set_package_count(1);
 851                 process_single();
 852         }
 853         else {
 854                 set_package_count(total_packages);
 855                 process_packages();
 856         }
 857 }
 858
 859 void AffineEngine::set_in_viewport(int x, int y, int w, int h)
 860 {
 861         this->in_x = x;  this->in_y = y;
 862         this->in_w = w;  this->in_h = h;
 863         this->user_in_viewport = 1;
 864 }
 865
 866 void AffineEngine::set_out_viewport(int x, int y, int w, int h)
 867 {
 868         this->out_x = x;  this->out_y = y;
 869         this->out_w = w;  this->out_h = h;
 870         this->user_out_viewport = 1;
 871 }
 872
 873 void AffineEngine::set_viewport(int x, int y, int w, int h)
 874 {
 875         set_in_viewport(x, y, w, h);
 876         set_out_viewport(x, y, w, h);
 877 }
 878
 879 void AffineEngine::set_opengl(int value)
 880 {
 881         this->use_opengl = value;
 882 }
 883
 884 void AffineEngine::set_in_pivot(int x, int y)
 885 {
 886         this->in_pivot_x = x;
 887         this->in_pivot_y = y;
 888         this->user_in_pivot = 1;
 889 }
 890
 891 void AffineEngine::set_out_pivot(int x, int y)
 892 {
 893         this->out_pivot_x = x;
 894         this->out_pivot_y = y;
 895         this->user_out_pivot = 1;
 896 }
 897
 898 void AffineEngine::set_pivot(int x, int y)
 899 {
 900         set_in_pivot(x, y);
 901         set_out_pivot(x, y);
 902 }
 903
 904 void AffineEngine::unset_pivot()
 905 {
 906         user_in_pivot = 0;
 907         user_out_pivot = 0;
 908 }
 909
 910 void AffineEngine::unset_viewport()
 911 {
 912         user_in_viewport = 0;
 913         user_out_viewport = 0;
 914 }
 915
 916
 917 void AffineEngine::set_interpolation(int type)
 918 {
 919         interpolation = type;
 920 }