4 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
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.
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.
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
23 #define GL_GLEXT_PROTOTYPES
37 AffineMatrix::AffineMatrix()
39 bzero(values, sizeof(values));
42 void AffineMatrix::identity()
44 bzero(values, sizeof(values));
50 void AffineMatrix::translate(double x, double y)
52 double g = values[2][0];
53 double h = values[2][1];
54 double i = values[2][2];
55 values[0][0] += x * g;
56 values[0][1] += x * h;
57 values[0][2] += x * i;
58 values[1][0] += y * g;
59 values[1][1] += y * h;
60 values[1][2] += y * i;
63 void AffineMatrix::scale(double x, double y)
74 void AffineMatrix::multiply(AffineMatrix *dst)
80 for (i = 0; i < 3; i++)
85 for (j = 0; j < 3; j++)
87 tmp.values[i][j] = t1 * dst->values[0][j];
88 tmp.values[i][j] += t2 * dst->values[1][j];
89 tmp.values[i][j] += t3 * dst->values[2][j];
95 double AffineMatrix::determinant()
100 values[0][0] * (values[1][1] * values[2][2] - values[1][2] * values[2][1]);
102 values[1][0] * (values[0][1] * values[2][2] - values[0][2] * values[2][1]);
104 values[2][0] * (values[0][1] * values[1][2] - values[0][2] * values[1][1]);
109 void AffineMatrix::invert(AffineMatrix *dst)
113 det_1 = determinant();
121 (values[1][1] * values[2][2] - values[1][2] * values[2][1]) * det_1;
124 - (values[1][0] * values[2][2] - values[1][2] * values[2][0]) * det_1;
127 (values[1][0] * values[2][1] - values[1][1] * values[2][0]) * det_1;
130 - (values[0][1] * values[2][2] - values[0][2] * values[2][1] ) * det_1;
133 (values[0][0] * values[2][2] - values[0][2] * values[2][0]) * det_1;
136 - (values[0][0] * values[2][1] - values[0][1] * values[2][0]) * det_1;
139 (values[0][1] * values[1][2] - values[0][2] * values[1][1]) * det_1;
142 - (values[0][0] * values[1][2] - values[0][2] * values[1][0]) * det_1;
145 (values[0][0] * values[1][1] - values[0][1] * values[1][0]) * det_1;
148 void AffineMatrix::copy_from(AffineMatrix *src)
150 memcpy(&values[0][0], &src->values[0][0], sizeof(values));
153 void AffineMatrix::transform_point(float x,
160 w = values[2][0] * x + values[2][1] * y + values[2][2];
167 *newx = (values[0][0] * x + values[0][1] * y + values[0][2]) * w;
168 *newy = (values[1][0] * x + values[1][1] * y + values[1][2]) * w;
171 void AffineMatrix::dump()
173 printf("AffineMatrix::dump\n");
174 printf("%f %f %f\n", values[0][0], values[0][1], values[0][2]);
175 printf("%f %f %f\n", values[1][0], values[1][1], values[1][2]);
176 printf("%f %f %f\n", values[2][0], values[2][1], values[2][2]);
183 AffinePackage::AffinePackage()
191 AffineUnit::AffineUnit(AffineEngine *server)
194 this->server = server;
205 void AffineUnit::calculate_matrix(
218 AffineMatrix *result)
224 scalex = scaley = 1.0;
226 if((in_x2 - in_x1) > 0)
227 scalex = 1.0 / (double)(in_x2 - in_x1);
229 if((in_y2 - in_y1) > 0)
230 scaley = 1.0 / (double)(in_y2 - in_y1);
232 /* Determine the perspective transform that maps from
233 * the unit cube to the transformed coordinates
235 double dx1, dx2, dx3, dy1, dy2, dy3;
238 dx1 = out_x2 - out_x4;
239 dx2 = out_x3 - out_x4;
240 dx3 = out_x1 - out_x2 + out_x4 - out_x3;
242 dy1 = out_y2 - out_y4;
243 dy2 = out_y3 - out_y4;
244 dy3 = out_y1 - out_y2 + out_y4 - out_y3;
245 // printf("AffineUnit::calculate_matrix %f %f %f %f %f %f\n",
254 /* Is the mapping affine? */
255 if((dx3 == 0.0) && (dy3 == 0.0))
257 matrix.values[0][0] = out_x2 - out_x1;
258 matrix.values[0][1] = out_x4 - out_x2;
259 matrix.values[0][2] = out_x1;
260 matrix.values[1][0] = out_y2 - out_y1;
261 matrix.values[1][1] = out_y4 - out_y2;
262 matrix.values[1][2] = out_y1;
263 matrix.values[2][0] = 0.0;
264 matrix.values[2][1] = 0.0;
268 det1 = dx3 * dy2 - dy3 * dx2;
269 det2 = dx1 * dy2 - dy1 * dx2;
270 matrix.values[2][0] = det1 / det2;
271 det1 = dx1 * dy3 - dy1 * dx3;
272 det2 = dx1 * dy2 - dy1 * dx2;
273 matrix.values[2][1] = det1 / det2;
275 matrix.values[0][0] = out_x2 - out_x1 + matrix.values[2][0] * out_x2;
276 matrix.values[0][1] = out_x3 - out_x1 + matrix.values[2][1] * out_x3;
277 matrix.values[0][2] = out_x1;
279 matrix.values[1][0] = out_y2 - out_y1 + matrix.values[2][0] * out_y2;
280 matrix.values[1][1] = out_y3 - out_y1 + matrix.values[2][1] * out_y3;
281 matrix.values[1][2] = out_y1;
284 matrix.values[2][2] = 1.0;
286 // printf("AffineUnit::calculate_matrix 1 %f %f\n", dx3, dy3);
290 result->translate(-in_x1, -in_y1);
291 result->scale(scalex, scaley);
292 matrix.multiply(result);
293 // double test[3][3] = { { 0.0896, 0.0, 0.0 },
294 // { 0.0, 0.0896, 0.0 },
295 // { -0.00126, 0.0, 1.0 } };
296 // memcpy(&result->values[0][0], test, sizeof(test));
297 // printf("AffineUnit::calculate_matrix 4 %p\n", result);
303 static inline float transform_cubic(float dx,
304 float jm1, float j, float jp1, float jp2)
306 /* Catmull-Rom - not bad */
307 float result = ((( ( - jm1 + 3.0 * j - 3.0 * jp1 + jp2 ) * dx +
308 ( 2.0 * jm1 - 5.0 * j + 4.0 * jp1 - jp2 ) ) * dx +
309 ( - jm1 + jp1 ) ) * dx + (j + j) ) / 2.0;
310 // printf("%f %f %f %f %f\n", result, jm1, j, jp1, jp2);
315 void AffineUnit::process_package(LoadPackage *package)
317 AffinePackage *pkg = (AffinePackage*)package;
318 int min_in_x = server->in_x;
319 int min_in_y = server->in_y;
320 int max_in_x = server->in_x + server->in_w - 1;
321 int max_in_y = server->in_y + server->in_h - 1;
324 // printf("AffineUnit::process_package %d %d %d %d %d\n",
330 int min_out_x = server->out_x;
331 //int min_out_y = server->out_y;
332 int max_out_x = server->out_x + server->out_w;
333 //int max_out_y = server->out_y + server->out_h;
335 // Amount to shift the input coordinates relative to the output coordinates
336 // To get the pivots to line up
337 int pivot_offset_x = server->in_pivot_x - server->out_pivot_x;
338 int pivot_offset_y = server->in_pivot_y - server->out_pivot_y;
340 // Calculate real coords
341 float out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4;
342 if(server->mode == AffineEngine::STRETCH ||
343 server->mode == AffineEngine::PERSPECTIVE ||
344 server->mode == AffineEngine::ROTATE ||
345 server->mode == AffineEngine::TRANSFORM)
347 out_x1 = (float)server->in_x + (float)server->x1 * server->in_w / 100;
348 out_y1 = (float)server->in_y + (float)server->y1 * server->in_h / 100;
349 out_x2 = (float)server->in_x + (float)server->x2 * server->in_w / 100;
350 out_y2 = (float)server->in_y + (float)server->y2 * server->in_h / 100;
351 out_x3 = (float)server->in_x + (float)server->x3 * server->in_w / 100;
352 out_y3 = (float)server->in_y + (float)server->y3 * server->in_h / 100;
353 out_x4 = (float)server->in_x + (float)server->x4 * server->in_w / 100;
354 out_y4 = (float)server->in_y + (float)server->y4 * server->in_h / 100;
358 out_x1 = (float)server->in_x + (float)server->x1 * server->in_w / 100;
359 out_y1 = server->in_y;
360 out_x2 = out_x1 + server->in_w;
361 out_y2 = server->in_y;
362 out_x4 = (float)server->in_x + (float)server->x4 * server->in_w / 100;
363 out_y4 = server->in_y + server->in_h;
364 out_x3 = out_x4 + server->in_w;
365 out_y3 = server->in_y + server->in_h;
370 // Rotation with OpenGL uses a simple quad.
371 if(server->mode == AffineEngine::ROTATE &&
375 server->output->to_texture();
376 server->output->enable_opengl();
377 server->output->init_screen();
378 server->output->bind_texture(0);
379 server->output->clear_pbuffer();
381 int texture_w = server->output->get_texture_w();
382 int texture_h = server->output->get_texture_h();
383 float output_h = server->output->get_h();
384 float in_x1 = (float)server->in_x / texture_w;
385 float in_x2 = (float)(server->in_x + server->in_w) / texture_w;
386 float in_y1 = (float)server->in_y / texture_h;
387 float in_y2 = (float)(server->in_y + server->in_h) / texture_h;
389 // printf("%f %f %f %f\n%f,%f %f,%f %f,%f %f,%f\n", in_x1, in_y1, in_x2, in_y2,
390 // out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4);
393 glNormal3f(0, 0, 1.0);
395 glTexCoord2f(in_x1, in_y1);
396 glVertex3f(out_x1, -output_h+out_y1, 0);
398 glTexCoord2f(in_x2, in_y1);
399 glVertex3f(out_x2, -output_h+out_y2, 0);
401 glTexCoord2f(in_x2, in_y2);
402 glVertex3f(out_x3, -output_h+out_y3, 0);
404 glTexCoord2f(in_x1, in_y2);
405 glVertex3f(out_x4, -output_h+out_y4, 0);
410 server->output->set_opengl_state(VFrame::SCREEN);
414 if(server->mode == AffineEngine::PERSPECTIVE ||
415 server->mode == AffineEngine::SHEER ||
416 server->mode == AffineEngine::ROTATE ||
417 server->mode == AffineEngine::TRANSFORM)
433 if(server->mode != AffineEngine::TRANSFORM)
438 server->in_x + server->in_w,
439 server->in_y + server->in_h,
452 matrix.copy_from(&server->matrix);
455 // printf("AffineUnit::process_package %d\n%f %f %f\n%f %f %f\n%f %f %f\n",
457 // matrix.values[0][0],
458 // matrix.values[0][1],
459 // matrix.values[0][2],
460 // matrix.values[1][0],
461 // matrix.values[1][1],
462 // matrix.values[1][2],
463 // matrix.values[2][0],
464 // matrix.values[2][1],
465 // matrix.values[2][2]);
467 int reverse = !server->forward;
469 float xinc, yinc, winc;
471 float ttx = 0, tty = 0;
472 int itx = 0, ity = 0;
473 int tx1 = 0, ty1 = 0, tx2 = 0, ty2 = 0;
477 m.copy_from(&matrix);
479 matrix.copy_from(&im);
491 float dx1 = 0, dy1 = 0;
492 float dx2 = 0, dy2 = 0;
493 float dx3 = 0, dy3 = 0;
494 float dx4 = 0, dy4 = 0;
495 matrix.transform_point(server->in_x, server->in_y, &dx1, &dy1);
496 matrix.transform_point(server->in_x + server->in_w, server->in_y, &dx2, &dy2);
497 matrix.transform_point(server->in_x, server->in_y + server->in_h, &dx3, &dy3);
498 matrix.transform_point(server->in_x + server->in_w, server->in_y + server->in_h, &dx4, &dy4);
500 //printf("AffineUnit::process_package 1 y1=%d y2=%d\n", pkg->y1, pkg->y2);
501 //printf("AffineUnit::process_package 1 %f %f %f %f\n", dy1, dy2, dy3, dy4);
502 // printf("AffineUnit::process_package %d use_opengl=%d\n",
503 // __LINE__, server->use_opengl);
509 if(server->use_opengl)
512 static const char *affine_frag =
513 "uniform sampler2D tex;\n"
514 "uniform mat3 affine_matrix;\n"
515 "uniform vec2 texture_extents;\n"
516 "uniform vec2 image_extents;\n"
517 "uniform vec4 border_color;\n"
520 " vec2 outcoord = gl_TexCoord[0].st;\n"
521 " outcoord *= texture_extents;\n"
522 " mat3 coord_matrix = mat3(\n"
523 " outcoord.x, outcoord.y, 1.0, \n"
524 " outcoord.x, outcoord.y, 1.0, \n"
525 " outcoord.x, outcoord.y, 1.0);\n"
526 " mat3 incoord_matrix = affine_matrix * coord_matrix;\n"
527 " vec2 incoord = vec2(incoord_matrix[0][0], incoord_matrix[0][1]);\n"
528 " incoord /= incoord_matrix[0][2];\n"
529 " incoord /= texture_extents;\n"
530 " if(incoord.x > image_extents.x || incoord.y > image_extents.y)\n"
531 " gl_FragColor = border_color;\n"
533 " gl_FragColor = texture2D(tex, incoord);\n"
536 float affine_matrix[9] = {
537 (float)m.values[0][0], (float)m.values[1][0], (float)m.values[2][0],
538 (float)m.values[0][1], (float)m.values[1][1], (float)m.values[2][1],
539 (float)m.values[0][2], (float)m.values[1][2], (float)m.values[2][2]
543 server->output->to_texture();
544 server->output->enable_opengl();
545 unsigned int frag_shader = VFrame::make_shader(0,
550 glUseProgram(frag_shader);
551 glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0);
552 glUniformMatrix3fv(glGetUniformLocation(frag_shader, "affine_matrix"),
556 glUniform2f(glGetUniformLocation(frag_shader, "texture_extents"),
557 (GLfloat)server->output->get_texture_w(),
558 (GLfloat)server->output->get_texture_h());
559 glUniform2f(glGetUniformLocation(frag_shader, "image_extents"),
560 (GLfloat)server->output->get_w() / server->output->get_texture_w(),
561 (GLfloat)server->output->get_h() / server->output->get_texture_h());
562 float border_color[] = { 0, 0, 0, 0 };
563 if(BC_CModels::is_yuv(server->output->get_color_model()))
565 border_color[1] = 0.5;
566 border_color[2] = 0.5;
568 if(!BC_CModels::has_alpha(server->output->get_color_model()))
570 border_color[3] = 1.0;
573 glUniform4fv(glGetUniformLocation(frag_shader, "border_color"),
575 (GLfloat*)border_color);
576 server->output->init_screen();
577 server->output->bind_texture(0);
578 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
579 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
580 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
581 server->output->draw_texture();
583 server->output->set_opengl_state(VFrame::SCREEN);
594 #define ROUND(x) ((int)((x > 0) ? (x) + 0.5 : (x) - 0.5))
595 #define MIN4(a,b,c,d) MIN(MIN(MIN(a,b),c),d)
596 #define MAX4(a,b,c,d) MAX(MAX(MAX(a,b),c),d)
598 tx1 = ROUND(MIN4(dx1 - pivot_offset_x, dx2 - pivot_offset_x, dx3 - pivot_offset_x, dx4 - pivot_offset_x));
599 ty1 = ROUND(MIN4(dy1 - pivot_offset_y, dy2 - pivot_offset_y, dy3 - pivot_offset_y, dy4 - pivot_offset_y));
601 tx2 = ROUND(MAX4(dx1 - pivot_offset_x, dx2 - pivot_offset_x, dx3 - pivot_offset_x, dx4 - pivot_offset_x));
602 ty2 = ROUND(MAX4(dy1 - pivot_offset_y, dy2 - pivot_offset_y, dy3 - pivot_offset_y, dy4 - pivot_offset_y));
604 CLAMP(ty1, pkg->y1, pkg->y2);
605 CLAMP(ty2, pkg->y1, pkg->y2);
606 CLAMP(tx1, server->out_x, server->out_x + server->out_w);
607 CLAMP(tx2, server->out_x, server->out_x + server->out_w);
610 xinc = m.values[0][0];
611 yinc = m.values[1][0];
612 winc = m.values[2][0];
614 //printf("AffineUnit::process_package 2 tx1=%d ty1=%d tx2=%d ty2=%d %f %f\n", tx1, ty1, tx2, ty2, out_x4, out_y4);
615 //printf("AffineUnit::process_package %d %d %d %d %d\n",
622 #define CUBIC_ROW(in_row, chroma_offset) \
623 transform_cubic(dx, \
624 in_row[col1_offset] - chroma_offset, \
625 in_row[col2_offset] - chroma_offset, \
626 in_row[col3_offset] - chroma_offset, \
627 in_row[col4_offset] - chroma_offset)
630 #define TRANSFORM(components, type, temp_type, chroma_offset, max) \
632 type **in_rows = (type**)server->input->get_rows(); \
633 float round_factor = 0.0; \
634 if(sizeof(type) < 4) round_factor = 0.5; \
635 for(int y = ty1; y < ty2; y++) \
637 type *out_row = (type*)server->output->get_rows()[y]; \
641 tx = xinc * (tx1 + 0.5) + \
642 m.values[0][1] * (y + pivot_offset_y + 0.5) + \
644 pivot_offset_x * xinc; \
645 ty = yinc * (tx1 + 0.5) + \
646 m.values[1][1] * (y + pivot_offset_y + 0.5) + \
648 pivot_offset_x * yinc; \
649 tw = winc * (tx1 + 0.5) + \
650 m.values[2][1] * (y + pivot_offset_y + 0.5) + \
652 pivot_offset_x * winc; \
657 m.values[0][1] * (y + pivot_offset_y) + \
659 pivot_offset_x * xinc; \
661 m.values[1][1] * (y + pivot_offset_y) + \
663 pivot_offset_x * yinc; \
665 m.values[2][1] * (y + pivot_offset_y) + \
667 pivot_offset_x * winc; \
671 out_row += tx1 * components; \
672 for(int x = tx1; x < tx2; x++) \
674 /* Normalize homogeneous coords */ \
694 int row1 = ity - 1; \
696 int row3 = ity + 1; \
697 int row4 = ity + 2; \
698 CLAMP(row1, min_in_y, max_in_y); \
699 CLAMP(row2, min_in_y, max_in_y); \
700 CLAMP(row3, min_in_y, max_in_y); \
701 CLAMP(row4, min_in_y, max_in_y); \
703 /* Set destination pixels if in clipping region */ \
708 if(itx >= min_in_x && \
713 type *src = in_rows[ity] + itx * components; \
714 *out_row++ = *src++; \
715 *out_row++ = *src++; \
716 *out_row++ = *src++; \
717 if(components == 4) *out_row++ = *src; \
720 /* Fill with chroma */ \
723 *out_row++ = chroma_offset; \
724 *out_row++ = chroma_offset; \
725 if(components == 4) *out_row++ = 0; \
729 /* Bicubic algorithm */ \
734 /* clipping region */ \
735 if ((itx + 2) >= min_in_x && \
736 (itx - 1) <= max_in_x && \
737 (ity + 2) >= min_in_y && \
738 (ity - 1) <= max_in_y) \
742 /* the fractional error */ \
746 /* Row and column offsets in cubic block */ \
747 int col1 = itx - 1; \
749 int col3 = itx + 1; \
750 int col4 = itx + 2; \
751 CLAMP(col1, min_in_x, max_in_x); \
752 CLAMP(col2, min_in_x, max_in_x); \
753 CLAMP(col3, min_in_x, max_in_x); \
754 CLAMP(col4, min_in_x, max_in_x); \
755 int col1_offset = col1 * components; \
756 int col2_offset = col2 * components; \
757 int col3_offset = col3 * components; \
758 int col4_offset = col4 * components; \
760 type *row1_ptr = in_rows[row1]; \
761 type *row2_ptr = in_rows[row2]; \
762 type *row3_ptr = in_rows[row3]; \
763 type *row4_ptr = in_rows[row4]; \
764 temp_type r, g, b, a; \
766 r = (temp_type)(transform_cubic(dy, \
767 CUBIC_ROW(row1_ptr, 0x0), \
768 CUBIC_ROW(row2_ptr, 0x0), \
769 CUBIC_ROW(row3_ptr, 0x0), \
770 CUBIC_ROW(row4_ptr, 0x0)) + \
777 g = (temp_type)(transform_cubic(dy, \
778 CUBIC_ROW(row1_ptr, chroma_offset), \
779 CUBIC_ROW(row2_ptr, chroma_offset), \
780 CUBIC_ROW(row3_ptr, chroma_offset), \
781 CUBIC_ROW(row4_ptr, chroma_offset)) + \
783 g += chroma_offset; \
789 b = (temp_type)(transform_cubic(dy, \
790 CUBIC_ROW(row1_ptr, chroma_offset), \
791 CUBIC_ROW(row2_ptr, chroma_offset), \
792 CUBIC_ROW(row3_ptr, chroma_offset), \
793 CUBIC_ROW(row4_ptr, chroma_offset)) + \
795 b += chroma_offset; \
797 if(components == 4) \
803 a = (temp_type)(transform_cubic(dy, \
804 CUBIC_ROW(row1_ptr, 0x0), \
805 CUBIC_ROW(row2_ptr, 0x0), \
806 CUBIC_ROW(row3_ptr, 0x0), \
807 CUBIC_ROW(row4_ptr, 0x0)) + \
811 if(sizeof(type) < 4) \
813 *out_row++ = CLIP(r, 0, max); \
814 *out_row++ = CLIP(g, 0, max); \
815 *out_row++ = CLIP(b, 0, max); \
816 if(components == 4) *out_row++ = CLIP(a, 0, max); \
823 if(components == 4) *out_row++ = a; \
827 /* Fill with chroma */ \
830 *out_row++ = chroma_offset; \
831 *out_row++ = chroma_offset; \
832 if(components == 4) *out_row++ = 0; \
837 out_row += components; \
840 /* increment the transformed coordinates */ \
851 // printf("AffineUnit::process_package %d tx1=%d ty1=%d tx2=%d ty2=%d\n",
852 // __LINE__, tx1, ty1, tx2, ty2);
853 switch(server->input->get_color_model())
856 TRANSFORM(3, float, float, 0x0, 1.0)
859 TRANSFORM(3, unsigned char, int, 0x0, 0xff)
862 TRANSFORM(4, float, float, 0x0, 1.0)
865 TRANSFORM(4, unsigned char, int, 0x0, 0xff)
869 // TRANSFORM(3, unsigned char, int, 0x80, 0xff)
872 unsigned char **in_rows = (unsigned char**)server->input->get_rows();
873 float round_factor = 0.0;
874 if(sizeof(unsigned char) < 4) round_factor = 0.5;
876 for(int y = ty1; y < ty2; y++)
878 //printf("AffineUnit::process_package %d y=%d tx1=%d tx2=%d ty1=%d ty2=%d\n",
879 //__LINE__, y, tx1, tx2, ty1, ty2);
880 unsigned char *out_row = (unsigned char*)server->output->get_rows()[y];
884 tx = xinc * (tx1 + 0.5) +
885 m.values[0][1] * (y + pivot_offset_y + 0.5) +
887 pivot_offset_x * xinc;
888 ty = yinc * (tx1 + 0.5) +
889 m.values[1][1] * (y + pivot_offset_y + 0.5) +
891 pivot_offset_x * yinc;
892 tw = winc * (tx1 + 0.5) +
893 m.values[2][1] * (y + pivot_offset_y + 0.5) +
895 pivot_offset_x * winc;
900 m.values[0][1] * (y + pivot_offset_y) +
902 pivot_offset_x * xinc;
904 m.values[1][1] * (y + pivot_offset_y) +
906 pivot_offset_x * yinc;
908 m.values[2][1] * (y + pivot_offset_y) +
910 pivot_offset_x * winc;
915 for(int x = tx1; x < tx2; x++)
917 /* Normalize homogeneous coords */
941 CLAMP(row1, min_in_y, max_in_y);
942 CLAMP(row2, min_in_y, max_in_y);
943 CLAMP(row3, min_in_y, max_in_y);
944 CLAMP(row4, min_in_y, max_in_y);
946 /* Set destination pixels if in clipping region */
951 if(itx >= min_in_x &&
956 unsigned char *src = in_rows[ity] + itx * 3;
960 if(3 == 4) *out_row++ = *src;
963 /* Fill with chroma */
968 if(3 == 4) *out_row++ = 0;
972 /* Bicubic algorithm */
977 /* clipping region */
978 if ((itx + 2) >= min_in_x &&
979 (itx - 1) <= max_in_x &&
980 (ity + 2) >= min_in_y &&
981 (ity - 1) <= max_in_y)
985 /* the fractional error */
989 /* Row and column offsets in cubic block */
994 CLAMP(col1, min_in_x, max_in_x);
995 CLAMP(col2, min_in_x, max_in_x);
996 CLAMP(col3, min_in_x, max_in_x);
997 CLAMP(col4, min_in_x, max_in_x);
998 int col1_offset = col1 * 3;
999 int col2_offset = col2 * 3;
1000 int col3_offset = col3 * 3;
1001 int col4_offset = col4 * 3;
1003 unsigned char *row1_ptr = in_rows[row1];
1004 unsigned char *row2_ptr = in_rows[row2];
1005 unsigned char *row3_ptr = in_rows[row3];
1006 unsigned char *row4_ptr = in_rows[row4];
1009 r = (int)(transform_cubic(dy,
1010 CUBIC_ROW(row1_ptr, 0x0),
1011 CUBIC_ROW(row2_ptr, 0x0),
1012 CUBIC_ROW(row3_ptr, 0x0),
1013 CUBIC_ROW(row4_ptr, 0x0)) +
1020 g = (int)(transform_cubic(dy,
1021 CUBIC_ROW(row1_ptr, 0x80),
1022 CUBIC_ROW(row2_ptr, 0x80),
1023 CUBIC_ROW(row3_ptr, 0x80),
1024 CUBIC_ROW(row4_ptr, 0x80)) +
1032 b = (int)(transform_cubic(dy,
1033 CUBIC_ROW(row1_ptr, 0x80),
1034 CUBIC_ROW(row2_ptr, 0x80),
1035 CUBIC_ROW(row3_ptr, 0x80),
1036 CUBIC_ROW(row4_ptr, 0x80)) +
1046 a = (int)(transform_cubic(dy,
1047 CUBIC_ROW(row1_ptr, 0x0),
1048 CUBIC_ROW(row2_ptr, 0x0),
1049 CUBIC_ROW(row3_ptr, 0x0),
1050 CUBIC_ROW(row4_ptr, 0x0)) +
1054 if(sizeof(unsigned char) < 4)
1056 *out_row++ = CLIP(r, 0, 0xff);
1057 *out_row++ = CLIP(g, 0, 0xff);
1058 *out_row++ = CLIP(b, 0, 0xff);
1059 if(3 == 4) *out_row++ = CLIP(a, 0, 0xff);
1066 if(3 == 4) *out_row++ = a;
1070 /* Fill with chroma */
1075 if(3 == 4) *out_row++ = 0;
1083 /* increment the transformed coordinates */
1093 TRANSFORM(4, unsigned char, int, 0x80, 0xff)
1096 TRANSFORM(3, uint16_t, int, 0x0, 0xffff)
1098 case BC_RGBA16161616:
1099 TRANSFORM(4, uint16_t, int, 0x0, 0xffff)
1102 TRANSFORM(3, uint16_t, int, 0x8000, 0xffff)
1104 case BC_YUVA16161616:
1105 TRANSFORM(4, uint16_t, int, 0x8000, 0xffff)
1112 int min_x = server->in_x * AFFINE_OVERSAMPLE;
1113 int min_y = server->in_y * AFFINE_OVERSAMPLE;
1114 int max_x = server->in_x * AFFINE_OVERSAMPLE + server->in_w * AFFINE_OVERSAMPLE - 1;
1115 int max_y = server->in_y * AFFINE_OVERSAMPLE + server->in_h * AFFINE_OVERSAMPLE - 1;
1116 float top_w = out_x2 - out_x1;
1117 float bottom_w = out_x3 - out_x4;
1118 float left_h = out_y4 - out_y1;
1119 float right_h = out_y3 - out_y2;
1120 float out_w_diff = bottom_w - top_w;
1121 float out_left_diff = out_x4 - out_x1;
1122 float out_h_diff = right_h - left_h;
1123 float out_top_diff = out_y2 - out_y1;
1124 float distance1 = DISTANCE(out_x1, out_y1, out_x2, out_y2);
1125 float distance2 = DISTANCE(out_x2, out_y2, out_x3, out_y3);
1126 float distance3 = DISTANCE(out_x3, out_y3, out_x4, out_y4);
1127 float distance4 = DISTANCE(out_x4, out_y4, out_x1, out_y1);
1128 float max_v = MAX(distance1, distance3);
1129 float max_h = MAX(distance2, distance4);
1130 float max_dimension = MAX(max_v, max_h);
1131 float min_dimension = MIN(server->in_h, server->in_w);
1132 float step = min_dimension / max_dimension / AFFINE_OVERSAMPLE;
1133 float x_f = server->in_x;
1134 float y_f = server->in_y;
1135 float h_f = server->in_h;
1136 float w_f = server->in_w;
1140 if(server->use_opengl)
1148 #define DO_STRETCH(type, components) \
1150 type **in_rows = (type**)server->input->get_rows(); \
1151 type **out_rows = (type**)server->temp->get_rows(); \
1153 for(float in_y = pkg->y1; in_y < pkg->y2; in_y += step) \
1155 int i = (int)in_y; \
1156 type *in_row = in_rows[i]; \
1157 for(float in_x = x_f; in_x < w_f; in_x += step) \
1159 int j = (int)in_x; \
1160 float in_x_fraction = (in_x - x_f) / w_f; \
1161 float in_y_fraction = (in_y - y_f) / h_f; \
1162 int out_x = (int)((out_x1 + \
1163 out_left_diff * in_y_fraction + \
1164 (top_w + out_w_diff * in_y_fraction) * in_x_fraction) * \
1165 AFFINE_OVERSAMPLE); \
1166 int out_y = (int)((out_y1 + \
1167 out_top_diff * in_x_fraction + \
1168 (left_h + out_h_diff * in_x_fraction) * in_y_fraction) * \
1169 AFFINE_OVERSAMPLE); \
1170 CLAMP(out_x, min_x, max_x); \
1171 CLAMP(out_y, min_y, max_y); \
1172 type *dst = out_rows[out_y] + out_x * components; \
1173 type *src = in_row + j * components; \
1177 if(components == 4) dst[3] = src[3]; \
1182 switch(server->input->get_color_model())
1185 DO_STRETCH(float, 3)
1188 DO_STRETCH(unsigned char, 3)
1191 DO_STRETCH(float, 4)
1194 DO_STRETCH(unsigned char, 4)
1197 DO_STRETCH(unsigned char, 3)
1200 DO_STRETCH(unsigned char, 4)
1203 DO_STRETCH(uint16_t, 3)
1205 case BC_RGBA16161616:
1206 DO_STRETCH(uint16_t, 4)
1209 DO_STRETCH(uint16_t, 3)
1211 case BC_YUVA16161616:
1212 DO_STRETCH(uint16_t, 4)
1227 AffineEngine::AffineEngine(int total_clients,
1231 total_clients, total_packages
1234 user_in_viewport = 0;
1236 user_out_viewport = 0;
1239 in_x = in_y = in_w = in_h = 0;
1240 out_x = out_y = out_w = out_h = 0;
1241 in_pivot_x = in_pivot_y = 0;
1242 out_pivot_x = out_pivot_y = 0;
1243 this->total_packages = total_packages;
1246 void AffineEngine::init_packages()
1248 for(int i = 0; i < get_total_packages(); i++)
1250 AffinePackage *package = (AffinePackage*)get_package(i);
1251 package->y1 = out_y + (out_h * i / get_total_packages());
1252 package->y2 = out_y + (out_h * (i + 1) / get_total_packages());
1256 LoadClient* AffineEngine::new_client()
1258 return new AffineUnit(this);
1261 LoadPackage* AffineEngine::new_package()
1263 return new AffinePackage;
1266 void AffineEngine::process(VFrame *output,
1282 // printf("AffineEngine::process %d %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\n",
1293 // printf("AffineEngine::process %d %d %d %d %d\n",
1295 // in_x, in_y, in_w, in_h);
1297 // printf("AffineEngine::process %d %d %d %d %d\n",
1299 // out_x, out_y, out_w, out_h);
1301 // printf("AffineEngine::process %d %d %d %d %d\n",
1303 // in_pivot_x, in_pivot_y, out_pivot_x, out_pivot_y);
1305 // printf("AffineEngine::process %d %d %d %d %d\n",
1309 // user_in_viewport,
1310 // user_out_viewport);
1312 this->output = output;
1313 this->input = input;
1324 this->forward = forward;
1327 if(!user_in_viewport)
1331 in_w = input->get_w();
1332 in_h = input->get_h();
1335 if(!user_out_viewport)
1339 out_w = output->get_w();
1340 out_h = output->get_h();
1345 set_package_count(1);
1350 set_package_count(total_packages);
1358 void AffineEngine::rotate(VFrame *output,
1362 this->output = output;
1363 this->input = input;
1365 this->mode = ROTATE;
1368 if(!user_in_viewport)
1372 in_w = input->get_w();
1373 in_h = input->get_h();
1379 // printf("AffineEngine::rotate %d %d %d %d %d\n", __LINE__, in_x, in_w, in_y, in_h);
1384 in_pivot_x = in_x + in_w / 2;
1385 in_pivot_y = in_y + in_h / 2;
1388 if(!user_out_viewport)
1392 out_w = output->get_w();
1393 out_h = output->get_h();
1398 out_pivot_x = out_x + out_w / 2;
1399 out_pivot_y = out_y + out_h / 2;
1402 // All subscripts are clockwise around the quadrangle
1403 angle = angle * 2 * M_PI / 360;
1404 double angle1 = atan((double)(in_pivot_y - in_y) / (double)(in_pivot_x - in_x)) + angle;
1405 double angle2 = atan((double)(in_x + in_w - in_pivot_x) / (double)(in_pivot_y - in_y)) + angle;
1406 double angle3 = atan((double)(in_y + in_h - in_pivot_y) / (double)(in_x + in_w - in_pivot_x)) + angle;
1407 double angle4 = atan((double)(in_pivot_x - in_x) / (double)(in_y + in_h - in_pivot_y)) + angle;
1408 double radius1 = DISTANCE(in_x, in_y, in_pivot_x, in_pivot_y);
1409 double radius2 = DISTANCE(in_x + in_w, in_y, in_pivot_x, in_pivot_y);
1410 double radius3 = DISTANCE(in_x + in_w, in_y + in_h, in_pivot_x, in_pivot_y);
1411 double radius4 = DISTANCE(in_x, in_y + in_h, in_pivot_x, in_pivot_y);
1413 x1 = ((in_pivot_x - in_x) - cos(angle1) * radius1) * 100 / in_w;
1414 y1 = ((in_pivot_y - in_y) - sin(angle1) * radius1) * 100 / in_h;
1415 x2 = ((in_pivot_x - in_x) + sin(angle2) * radius2) * 100 / in_w;
1416 y2 = ((in_pivot_y - in_y) - cos(angle2) * radius2) * 100 / in_h;
1417 x3 = ((in_pivot_x - in_x) + cos(angle3) * radius3) * 100 / in_w;
1418 y3 = ((in_pivot_y - in_y) + sin(angle3) * radius3) * 100 / in_h;
1419 x4 = ((in_pivot_x - in_x) - sin(angle4) * radius4) * 100 / in_w;
1420 y4 = ((in_pivot_y - in_y) + cos(angle4) * radius4) * 100 / in_h;
1422 // printf("AffineEngine::rotate angle=%f\n",
1426 // printf(" angle1=%f angle2=%f angle3=%f angle4=%f\n",
1427 // angle1 * 360 / 2 / M_PI,
1428 // angle2 * 360 / 2 / M_PI,
1429 // angle3 * 360 / 2 / M_PI,
1430 // angle4 * 360 / 2 / M_PI);
1432 // printf(" radius1=%f radius2=%f radius3=%f radius4=%f\n",
1438 // printf(" x1=%f y1=%f x2=%f y2=%f x3=%f y3=%f x4=%f y4=%f\n",
1450 set_package_count(1);
1455 set_package_count(total_packages);
1460 void AffineEngine::set_matrix(AffineMatrix *matrix)
1462 for(int i = 0; i < 3; i++)
1464 for(int j = 0; j < 3; j++)
1466 this->matrix.values[i][j] = matrix->values[i][j];
1471 void AffineEngine::set_in_viewport(int x, int y, int w, int h)
1477 this->user_in_viewport = 1;
1480 void AffineEngine::set_out_viewport(int x, int y, int w, int h)
1486 this->user_out_viewport = 1;
1489 void AffineEngine::set_viewport(int x, int y, int w, int h)
1491 set_in_viewport(x, y, w, h);
1492 set_out_viewport(x, y, w, h);
1495 void AffineEngine::set_opengl(int value)
1497 this->use_opengl = value;
1500 void AffineEngine::set_in_pivot(int x, int y)
1502 this->in_pivot_x = x;
1503 this->in_pivot_y = y;
1504 this->user_in_pivot = 1;
1507 void AffineEngine::set_out_pivot(int x, int y)
1509 this->out_pivot_x = x;
1510 this->out_pivot_y = y;
1511 this->user_out_pivot = 1;
1514 void AffineEngine::set_pivot(int x, int y)
1517 set_out_pivot(x, y);
1520 void AffineEngine::unset_pivot()
1526 void AffineEngine::unset_viewport()
1528 user_in_viewport = 0;
1529 user_out_viewport = 0;