+++ /dev/null
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-
-#include "clip.h"
-#include "edl.inc"
-#include "mutex.h"
-#include "overlayframe.h"
-#include "vframe.h"
-
-OverlayFrame::OverlayFrame(int cpus)
-{
- temp_frame = 0;
- blend_engine = 0;
- scale_engine = 0;
- scaletranslate_engine = 0;
- translate_engine = 0;
- this->cpus = cpus;
-}
-
-OverlayFrame::~OverlayFrame()
-{
-//printf("OverlayFrame::~OverlayFrame 1\n");
- if(temp_frame) delete temp_frame;
- if(scale_engine) delete scale_engine;
- if(translate_engine) delete translate_engine;
- if(blend_engine) delete blend_engine;
- if(scaletranslate_engine) delete scaletranslate_engine;
-//printf("OverlayFrame::~OverlayFrame 2\n");
-}
-
-
-
-
-
-
-
-
-// Verification:
-
-// (255 * 255 + 0 * 0) / 255 = 255
-// (255 * 127 + 255 * (255 - 127)) / 255 = 255
-
-// (65535 * 65535 + 0 * 0) / 65535 = 65535
-// (65535 * 32767 + 65535 * (65535 - 32767)) / 65535 = 65535
-
-
-// Branch prediction 4 U
-
-#define BLEND_3(max, type) \
-{ \
- int64_t r, g, b; \
- \
-/* if(mode != TRANSFER_NORMAL) printf("BLEND mode = %d\n", mode); */ \
- switch(mode) \
- { \
- case TRANSFER_DIVIDE: \
- r = output[0] ? (((int64_t)input1 * max) / output[0]) : max; \
- g = output[1] ? (((int64_t)input2 * max) / output[1]) : max; \
- b = output[2] ? (((int64_t)input3 * max) / output[2]) : max; \
- r = (r * opacity + output[0] * transparency) / max; \
- g = (g * opacity + output[1] * transparency) / max; \
- b = (b * opacity + output[2] * transparency) / max; \
- break; \
- case TRANSFER_MULTIPLY: \
- r = ((int64_t)input1 * output[0]) / max; \
- g = ((int64_t)input2 * output[1]) / max; \
- b = ((int64_t)input3 * output[2]) / max; \
- r = (r * opacity + output[0] * transparency) / max; \
- g = (g * opacity + output[1] * transparency) / max; \
- b = (b * opacity + output[2] * transparency) / max; \
- break; \
- case TRANSFER_SUBTRACT: \
- r = (((int64_t)input1 - output[0]) * opacity + output[0] * transparency) / max; \
- g = (((int64_t)input2 - output[1]) * opacity + output[1] * transparency) / max; \
- b = (((int64_t)input3 - output[2]) * opacity + output[2] * transparency) / max; \
- break; \
- case TRANSFER_ADDITION: \
- r = (((int64_t)input1 + output[0]) * opacity + output[0] * transparency) / max; \
- g = (((int64_t)input2 + output[1]) * opacity + output[1] * transparency) / max; \
- b = (((int64_t)input3 + output[2]) * opacity + output[2] * transparency) / max; \
- break; \
- case TRANSFER_REPLACE: \
- r = input1; \
- g = input2; \
- b = input3; \
- break; \
- case TRANSFER_NORMAL: \
- r = ((int64_t)input1 * opacity + output[0] * transparency) / max; \
- g = ((int64_t)input2 * opacity + output[1] * transparency) / max; \
- b = ((int64_t)input3 * opacity + output[2] * transparency) / max; \
- break; \
- } \
- \
- output[0] = (type)CLIP(r, 0, max); \
- output[1] = (type)CLIP(g, 0, max); \
- output[2] = (type)CLIP(b, 0, max); \
-}
-
-
-
-
-
-// Blending equations are drastically different for 3 and 4 components
-#define BLEND_4(max, type) \
-{ \
- int64_t r, g, b, a; \
- int64_t pixel_opacity, pixel_transparency; \
- \
- pixel_opacity = opacity * input4 / max; \
- pixel_transparency = (max - pixel_opacity) * output[3] / max; \
- \
- switch(mode) \
- { \
- case TRANSFER_DIVIDE: \
- r = output[0] ? (((int64_t)input1 * max) / output[0]) : max; \
- g = output[1] ? (((int64_t)input2 * max) / output[1]) : max; \
- b = output[2] ? (((int64_t)input3 * max) / output[2]) : max; \
- r = (r * pixel_opacity + output[0] * pixel_transparency) / max; \
- g = (g * pixel_opacity + output[1] * pixel_transparency) / max; \
- b = (b * pixel_opacity + output[2] * pixel_transparency) / max; \
- a = input4 > output[3] ? input4 : output[3]; \
- break; \
- case TRANSFER_MULTIPLY: \
- r = ((int64_t)input1 * output[0]) / max; \
- g = ((int64_t)input2 * output[1]) / max; \
- b = ((int64_t)input3 * output[2]) / max; \
- r = (r * pixel_opacity + output[0] * pixel_transparency) / max; \
- g = (g * pixel_opacity + output[1] * pixel_transparency) / max; \
- b = (b * pixel_opacity + output[2] * pixel_transparency) / max; \
- a = input4 > output[3] ? input4 : output[3]; \
- break; \
- case TRANSFER_SUBTRACT: \
- r = (((int64_t)input1 - output[0]) * pixel_opacity + output[0] * pixel_transparency) / max; \
- g = (((int64_t)input2 - output[1]) * pixel_opacity + output[1] * pixel_transparency) / max; \
- b = (((int64_t)input3 - output[2]) * pixel_opacity + output[2] * pixel_transparency) / max; \
- a = input4 > output[3] ? input4 : output[3]; \
- break; \
- case TRANSFER_ADDITION: \
- r = (((int64_t)input1 + output[0]) * pixel_opacity + output[0] * pixel_transparency) / max; \
- g = (((int64_t)input2 + output[1]) * pixel_opacity + output[1] * pixel_transparency) / max; \
- b = (((int64_t)input3 + output[2]) * pixel_opacity + output[2] * pixel_transparency) / max; \
- a = input4 > output[3] ? input4 : output[3]; \
- break; \
- case TRANSFER_REPLACE: \
- r = input1; \
- g = input2; \
- b = input3; \
- a = input4; \
- break; \
- case TRANSFER_NORMAL: \
- r = ((int64_t)input1 * pixel_opacity + output[0] * pixel_transparency) / max; \
- g = ((int64_t)input2 * pixel_opacity + output[1] * pixel_transparency) / max; \
- b = ((int64_t)input3 * pixel_opacity + output[2] * pixel_transparency) / max; \
- a = input4 > output[3] ? input4 : output[3]; \
- break; \
- } \
- \
- output[0] = (type)CLIP(r, 0, max); \
- output[1] = (type)CLIP(g, 0, max); \
- output[2] = (type)CLIP(b, 0, max); \
- output[3] = (type)a; \
-}
-
-
-
-
-
-
-
-
-// Bicubic algorithm using multiprocessors
-// input -> scale nearest integer boundaries -> temp -> translation -> blend -> output
-
-// Nearest neighbor algorithm using multiprocessors for blending
-// input -> scale + translate -> blend -> output
-
-
-int OverlayFrame::overlay(VFrame *output,
- VFrame *input,
- float in_x1,
- float in_y1,
- float in_x2,
- float in_y2,
- float out_x1,
- float out_y1,
- float out_x2,
- float out_y2,
- float alpha, // 0 - 1
- int mode,
- int interpolation_type)
-{
- float w_scale = (out_x2 - out_x1) / (in_x2 - in_x1);
- float h_scale = (out_y2 - out_y1) / (in_y2 - in_y1);
-
-//printf("OverlayFrame::overlay 1 %d %f\n", mode, alpha);
-// Limit values
- if(in_x1 < 0)
- {
- out_x1 += -in_x1 * w_scale;
- in_x1 = 0;
- }
- else
- if(in_x1 >= input->get_w())
- {
- out_x1 -= (in_x1 - input->get_w()) * w_scale;
- in_x1 = input->get_w();
- }
-
- if(in_y1 < 0)
- {
- out_y1 += -in_y1 * h_scale;
- in_y1 = 0;
- }
- else
- if(in_y1 >= input->get_h())
- {
- out_y1 -= (in_y1 - input->get_h()) * h_scale;
- in_y1 = input->get_h();
- }
-
- if(in_x2 < 0)
- {
- out_x2 += -in_x2 * w_scale;
- in_x2 = 0;
- }
- else
- if(in_x2 >= input->get_w())
- {
- out_x2 -= (in_x2 - input->get_w()) * w_scale;
- in_x2 = input->get_w();
- }
-
- if(in_y2 < 0)
- {
- out_y2 += -in_y2 * h_scale;
- in_y2 = 0;
- }
- else
- if(in_y2 >= input->get_h())
- {
- out_y2 -= (in_y2 - input->get_h()) * h_scale;
- in_y2 = input->get_h();
- }
-
- if(out_x1 < 0)
- {
- in_x1 += -out_x1 / w_scale;
- out_x1 = 0;
- }
- else
- if(out_x1 >= output->get_w())
- {
- in_x1 -= (out_x1 - output->get_w()) / w_scale;
- out_x1 = output->get_w();
- }
-
- if(out_y1 < 0)
- {
- in_y1 += -out_y1 / h_scale;
- out_y1 = 0;
- }
- else
- if(out_y1 >= output->get_h())
- {
- in_y1 -= (out_y1 - output->get_h()) / h_scale;
- out_y1 = output->get_h();
- }
-
- if(out_x2 < 0)
- {
- in_x2 += -out_x2 / w_scale;
- out_x2 = 0;
- }
- else
- if(out_x2 >= output->get_w())
- {
- in_x2 -= (out_x2 - output->get_w()) / w_scale;
- out_x2 = output->get_w();
- }
-
- if(out_y2 < 0)
- {
- in_y2 += -out_y2 / h_scale;
- out_y2 = 0;
- }
- else
- if(out_y2 >= output->get_h())
- {
- in_y2 -= (out_y2 - output->get_h()) / h_scale;
- out_y2 = output->get_h();
- }
-
-
-
-
-
- float in_w = in_x2 - in_x1;
- float in_h = in_y2 - in_y1;
- float out_w = out_x2 - out_x1;
- float out_h = out_y2 - out_y1;
-// Input for translation operation
- VFrame *translation_input = input;
-
-
-
-// printf("OverlayFrame::overlay %f %f %f %f -> %f %f %f %f\n", in_x1,
-// in_y1,
-// in_x2,
-// in_y2,
-// out_x1,
-// out_y1,
-// out_x2,
-// out_y2);
-
-
-
-
-
-// ****************************************************************************
-// Transfer to temp buffer by scaling nearest integer boundaries
-// ****************************************************************************
- if(interpolation_type != NEAREST_NEIGHBOR &&
- (!EQUIV(w_scale, 1) || !EQUIV(h_scale, 1)))
- {
-// Create integer boundaries for interpolation
- int in_x1_int = (int)in_x1;
- int in_y1_int = (int)in_y1;
- int in_x2_int = MIN((int)ceil(in_x2), input->get_w());
- int in_y2_int = MIN((int)ceil(in_y2), input->get_h());
-
-// Dimensions of temp frame. Integer boundaries scaled.
- int temp_w = (int)ceil(w_scale * (in_x2_int - in_x1_int));
- int temp_h = (int)ceil(h_scale * (in_y2_int - in_y1_int));
- VFrame *scale_output;
-
-
-
-#define NO_TRANSLATION1 \
- (EQUIV(in_x1, 0) && \
- EQUIV(in_y1, 0) && \
- EQUIV(out_x1, 0) && \
- EQUIV(out_y1, 0) && \
- EQUIV(in_x2, in_x2_int) && \
- EQUIV(in_y2, in_y2_int) && \
- EQUIV(out_x2, temp_w) && \
- EQUIV(out_y2, temp_h))
-
-
-#define NO_BLEND \
- (EQUIV(alpha, 1) && \
- (mode == TRANSFER_REPLACE || \
- (mode == TRANSFER_NORMAL && cmodel_components(input->get_color_model()) == 3)))
-
-
-
-
-
-// Prepare destination for operation
-
-// No translation and no blending. The blending operation is built into the
-// translation unit but not the scaling unit.
-// input -> output
- if(NO_TRANSLATION1 &&
- NO_BLEND)
- {
-// printf("OverlayFrame::overlay input -> output\n");
-
- scale_output = output;
- translation_input = 0;
- }
- else
-// If translation or blending
-// input -> nearest integer boundary temp
- {
- if(temp_frame &&
- (temp_frame->get_w() != temp_w ||
- temp_frame->get_h() != temp_h))
- {
- delete temp_frame;
- temp_frame = 0;
- }
-
- if(!temp_frame)
- {
- temp_frame = new VFrame(0,
- temp_w,
- temp_h,
- input->get_color_model(),
- -1);
- }
-//printf("OverlayFrame::overlay input -> temp\n");
-
-
- temp_frame->clear_frame();
-
-// printf("OverlayFrame::overlay 4 temp_w=%d temp_h=%d\n",
-// temp_w, temp_h);
- scale_output = temp_frame;
- translation_input = scale_output;
-
-// Adjust input coordinates to reflect new scaled coordinates.
- in_x1 = (in_x1 - in_x1_int) * w_scale;
- in_y1 = (in_y1 - in_y1_int) * h_scale;
- in_x2 = (in_x2 - in_x1_int) * w_scale;
- in_y2 = (in_y2 - in_y1_int) * h_scale;
- }
-
-
-
-
-// Scale input -> scale_output
- this->scale_output = scale_output;
- this->scale_input = input;
- this->w_scale = w_scale;
- this->h_scale = h_scale;
- this->in_x1_int = in_x1_int;
- this->in_y1_int = in_y1_int;
- this->out_w_int = temp_w;
- this->out_h_int = temp_h;
- this->interpolation_type = interpolation_type;
-
-//printf("OverlayFrame::overlay ScaleEngine 1 %d\n", out_h_int);
- if(!scale_engine) scale_engine = new ScaleEngine(this, cpus);
- scale_engine->process_packages();
-//printf("OverlayFrame::overlay ScaleEngine 2\n");
-
-
-
- }
-
-// printf("OverlayFrame::overlay 1 %.2f %.2f %.2f %.2f -> %.2f %.2f %.2f %.2f\n",
-// in_x1,
-// in_y1,
-// in_x2,
-// in_y2,
-// out_x1,
-// out_y1,
-// out_x2,
-// out_y2);
-
-
-
-
-
-#define NO_TRANSLATION2 \
- (EQUIV(in_x1, 0) && \
- EQUIV(in_y1, 0) && \
- EQUIV(in_x2, translation_input->get_w()) && \
- EQUIV(in_y2, translation_input->get_h()) && \
- EQUIV(out_x1, 0) && \
- EQUIV(out_y1, 0) && \
- EQUIV(out_x2, output->get_w()) && \
- EQUIV(out_y2, output->get_h())) \
-
-#define NO_SCALE \
- (EQUIV(out_x2 - out_x1, in_x2 - in_x1) && \
- EQUIV(out_y2 - out_y1, in_y2 - in_y1))
-
-
-
-
-//printf("OverlayFrame::overlay 4 %d\n", mode);
-
-
-
-
- if(translation_input)
- {
-// Direct copy
- if( NO_TRANSLATION2 &&
- NO_SCALE &&
- NO_BLEND)
- {
-//printf("OverlayFrame::overlay direct copy\n");
- output->copy_from(translation_input);
- }
- else
-// Blend only
- if( NO_TRANSLATION2 &&
- NO_SCALE)
- {
- if(!blend_engine) blend_engine = new BlendEngine(this, cpus);
-
-
- blend_engine->output = output;
- blend_engine->input = translation_input;
- blend_engine->alpha = alpha;
- blend_engine->mode = mode;
-
- blend_engine->process_packages();
- }
- else
-// Scale and translate using nearest neighbor
-// Translation is exactly on integer boundaries
- if(interpolation_type == NEAREST_NEIGHBOR ||
- EQUIV(in_x1, (int)in_x1) &&
- EQUIV(in_y1, (int)in_y1) &&
- EQUIV(in_x2, (int)in_x2) &&
- EQUIV(in_y2, (int)in_y2) &&
-
- EQUIV(out_x1, (int)out_x1) &&
- EQUIV(out_y1, (int)out_y1) &&
- EQUIV(out_x2, (int)out_x2) &&
- EQUIV(out_y2, (int)out_y2))
- {
-//printf("OverlayFrame::overlay NEAREST_NEIGHBOR 1\n");
- if(!scaletranslate_engine) scaletranslate_engine = new ScaleTranslateEngine(this, cpus);
-
-
- scaletranslate_engine->output = output;
- scaletranslate_engine->input = translation_input;
- scaletranslate_engine->in_x1 = (int)in_x1;
- scaletranslate_engine->in_y1 = (int)in_y1;
- scaletranslate_engine->in_x2 = (int)in_x2;
- scaletranslate_engine->in_y2 = (int)in_y2;
- scaletranslate_engine->out_x1 = (int)out_x1;
- scaletranslate_engine->out_y1 = (int)out_y1;
- scaletranslate_engine->out_x2 = (int)out_x2;
- scaletranslate_engine->out_y2 = (int)out_y2;
- scaletranslate_engine->alpha = alpha;
- scaletranslate_engine->mode = mode;
-
- scaletranslate_engine->process_packages();
- }
- else
-// Fractional translation
- {
-// Use fractional translation
-// printf("OverlayFrame::overlay temp -> output %.2f %.2f %.2f %.2f -> %.2f %.2f %.2f %.2f\n",
-// in_x1,
-// in_y1,
-// in_x2,
-// in_y2,
-// out_x1,
-// out_y1,
-// out_x2,
-// out_y2);
- this->translate_output = output;
- this->translate_input = translation_input;
- this->translate_in_x1 = in_x1;
- this->translate_in_y1 = in_y1;
- this->translate_in_x2 = in_x2;
- this->translate_in_y2 = in_y2;
- this->translate_out_x1 = out_x1;
- this->translate_out_y1 = out_y1;
- this->translate_out_x2 = out_x2;
- this->translate_out_y2 = out_y2;
- this->translate_alpha = alpha;
- this->translate_mode = mode;
-
-//printf("OverlayFrame::overlay 5 %d\n", mode);
- if(!translate_engine) translate_engine = new TranslateEngine(this, cpus);
- translate_engine->process_packages();
-
- }
- }
-//printf("OverlayFrame::overlay 2\n");
-
- return 0;
-}
-
-
-
-
-
-
-
-ScalePackage::ScalePackage()
-{
-}
-
-
-
-
-ScaleUnit::ScaleUnit(ScaleEngine *server, OverlayFrame *overlay)
- : LoadClient(server)
-{
- this->overlay = overlay;
-}
-
-ScaleUnit::~ScaleUnit()
-{
-}
-
-
-
-#define BILINEAR(max, type, components) \
-{ \
- float k_y = 1.0 / scale_h; \
- float k_x = 1.0 / scale_w; \
- type **in_rows = (type**)input->get_rows(); \
- type **out_rows = (type**)output->get_rows(); \
- type zero_r, zero_g, zero_b, zero_a; \
- int in_h_int = input->get_h(); \
- int in_w_int = input->get_w(); \
- int *table_int_x, *table_int_y; \
- int *table_frac_x, *table_frac_y; \
- \
- zero_r = 0; \
- zero_g = ((max + 1) >> 1) * (do_yuv); \
- zero_b = ((max + 1) >> 1) * (do_yuv); \
- if(components == 4) zero_a = 0; \
- \
- tabulate_blinear(table_int_x, table_frac_x, k_x, 0, out_w_int); \
- tabulate_blinear(table_int_y, table_frac_y, k_y, pkg->out_row1, pkg->out_row2); \
- \
- for(int i = pkg->out_row1; i < pkg->out_row2; i++) \
- { \
- int i_y = table_int_y[i - pkg->out_row1]; \
- uint64_t a = table_frac_y[i - pkg->out_row1]; \
- uint64_t anti_a = 0xffff - a; \
- type *in_row1 = in_rows[i_y + in_y1_int]; \
- type *in_row2 = (i_y + in_y1_int < in_h_int - 1) ? \
- in_rows[i_y + in_y1_int + 1] : \
- 0; \
- type *out_row = out_rows[i]; \
- \
- for(int j = 0; j < out_w_int; j++) \
- { \
- int i_x = table_int_x[j]; \
- uint64_t b = table_frac_x[j]; \
- uint64_t anti_b = 0xffff - b; \
- int x = i_x + in_x1_int; \
- uint64_t output1r, output1g, output1b, output1a; \
- uint64_t output2r, output2g, output2b, output2a; \
- uint64_t output3r, output3g, output3b, output3a; \
- uint64_t output4r, output4g, output4b, output4a; \
- \
- output1r = in_row1[x * components]; \
- output1g = in_row1[x * components + 1]; \
- output1b = in_row1[x * components + 2]; \
- if(components == 4) output1a = in_row1[x * components + 3]; \
- \
- if(x < in_w_int - 1) \
- { \
- output2r = in_row1[x * components + components]; \
- output2g = in_row1[x * components + components + 1]; \
- output2b = in_row1[x * components + components + 2]; \
- if(components == 4) output2a = in_row1[x * components + components + 3]; \
- \
- if(in_row2) \
- { \
- output4r = in_row2[x * components + components]; \
- output4g = in_row2[x * components + components + 1]; \
- output4b = in_row2[x * components + components + 2]; \
- if(components == 4) output4a = in_row2[x * components + components + 3]; \
- } \
- else \
- { \
- output4r = zero_r; \
- output4g = zero_g; \
- output4b = zero_b; \
- if(components == 4) output4a = zero_a; \
- } \
- } \
- else \
- { \
- output2r = zero_r; \
- output2g = zero_g; \
- output2b = zero_b; \
- if(components == 4) output2a = zero_a; \
- output4r = zero_r; \
- output4g = zero_g; \
- output4b = zero_b; \
- if(components == 4) output4a = zero_a; \
- } \
- \
- if(in_row2) \
- { \
- output3r = in_row2[x * components]; \
- output3g = in_row2[x * components + 1]; \
- output3b = in_row2[x * components + 2]; \
- if(components == 4) output3a = in_row2[x * components + 3]; \
- } \
- else \
- { \
- output3r = zero_r; \
- output3g = zero_g; \
- output3b = zero_b; \
- if(components == 4) output3a = zero_a; \
- } \
- \
- out_row[j * components] = \
- (type)(((anti_a) * (((anti_b) * output1r) + \
- (b * output2r)) + \
- a * (((anti_b) * output3r) + \
- (b * output4r))) / 0xffffffff); \
- out_row[j * components + 1] = \
- (type)(((anti_a) * (((anti_b) * output1g) + \
- (b * output2g)) + \
- a * (((anti_b) * output3g) + \
- (b * output4g))) / 0xffffffff); \
- out_row[j * components + 2] = \
- (type)(((anti_a) * (((anti_b) * output1b) + \
- (b * output2b)) + \
- a * (((anti_b) * output3b) + \
- (b * output4b))) / 0xffffffff); \
- if(components == 4) \
- out_row[j * components + 3] = \
- (type)(((anti_a) * (((anti_b) * output1a) + \
- (b * output2a)) + \
- a * (((anti_b) * output3a) + \
- (b * output4a))) / 0xffffffff); \
- } \
- } \
- \
- \
- delete [] table_int_x; \
- delete [] table_frac_x; \
- delete [] table_int_y; \
- delete [] table_frac_y; \
- \
-}
-
-
-#define BICUBIC(max, type, components) \
-{ \
- float k_y = 1.0 / scale_h; \
- float k_x = 1.0 / scale_w; \
- type **in_rows = (type**)input->get_rows(); \
- type **out_rows = (type**)output->get_rows(); \
- int *bspline_x, *bspline_y; \
- int in_h_int = input->get_h(); \
- int in_w_int = input->get_w(); \
- type zero_r, zero_g, zero_b, zero_a; \
- \
- zero_r = 0; \
- zero_b = ((max + 1) >> 1) * (do_yuv); \
- zero_g = ((max + 1) >> 1) * (do_yuv); \
- if(components == 4) \
- zero_a = 0; \
- \
- tabulate_bspline(bspline_x, \
- k_x, \
- out_w_int, \
- -1); \
- \
- tabulate_bspline(bspline_y, \
- k_y, \
- out_h_int, \
- 1); \
- \
- for(int i = pkg->out_row1; i < pkg->out_row2; i++) \
- { \
- int i_y = (int)(k_y * i); \
- \
- \
- for(int j = 0; j < out_w_int; j++) \
- { \
- int i_x = (int)(k_x * j); \
- uint64_t output1, output2, output3, output4; \
- output1 = 0; \
- output2 = 0; \
- output3 = 0; \
- if(components == 4) \
- output4 = 0; \
- int table_y = i * 4; \
- \
-/* Kernel */ \
- for(int m = -1; m < 3; m++) \
- { \
- uint64_t r1 = bspline_y[table_y++]; \
- int y = in_y1_int + i_y + m; \
- int table_x = j * 4; \
- \
- for(int n = -1; n < 3; n++) \
- { \
- uint64_t r2 = bspline_x[table_x++]; \
- int x = in_x1_int + i_x + n; \
- uint64_t r_square = r1 * r2; \
- \
-/* Inside boundary. */ \
- if(x >= 0 && \
- x < in_w_int && \
- y >= 0 && \
- y < in_h_int) \
- { \
- output1 += r_square * in_rows[y][x * components]; \
- output2 += r_square * in_rows[y][x * components + 1]; \
- output3 += r_square * in_rows[y][x * components + 2]; \
- if(components == 4) \
- output4 += r_square * in_rows[y][x * components + 3]; \
- } \
- else \
- { \
- output1 += r_square * zero_r; \
- output2 += r_square * zero_g; \
- output3 += r_square * zero_b; \
- if(components == 4) \
- output4 += r_square * zero_a; \
- } \
- } \
- } \
- \
- \
- out_rows[i][j * components] = (type)(output1 / 0xffffffff); \
- out_rows[i][j * components + 1] = (type)(output2 / 0xffffffff); \
- out_rows[i][j * components + 2] = (type)(output3 / 0xffffffff); \
- if(components == 4) \
- out_rows[i][j * components + 3] = (type)(output4 / 0xffffffff); \
- \
- } \
- } \
- \
- delete [] bspline_x; \
- delete [] bspline_y; \
-}
-
-
-
-
-// Pow function is not thread safe in Compaqt C
-#define CUBE(x) ((x) * (x) * (x))
-
-int ScaleUnit::cubic_bspline(float x)
-{
- float a, b, c, d;
-
- if((x + 2.0F) <= 0.0F)
- {
- a = 0.0F;
- }
- else
- {
- a = CUBE(x + 2.0F);
- }
-
-
- if((x + 1.0F) <= 0.0F)
- {
- b = 0.0F;
- }
- else
- {
- b = CUBE(x + 1.0F);
- }
-
- if(x <= 0)
- {
- c = 0.0F;
- }
- else
- {
- c = CUBE(x);
- }
-
- if((x - 1.0F) <= 0.0F)
- {
- d = 0.0F;
- }
- else
- {
- d = CUBE(x - 1.0F);
- }
-
-
- return (int)((a - (4.0F * b) + (6.0F * c) - (4.0F * d)) / 6.0 * 0x10000);
-}
-
-
-void ScaleUnit::tabulate_bspline(int* &table,
- float scale,
- int pixels,
- float coefficient)
-{
- table = new int[pixels * 4];
- for(int i = 0, j = 0; i < pixels; i++)
- {
- float f_x = (float)i * scale;
- float a = f_x - floor(f_x);
-
- for(float m = -1; m < 3; m++)
- {
- table[j++] = cubic_bspline(coefficient * (m - a));
- }
-
- }
-}
-
-void ScaleUnit::tabulate_blinear(int* &table_int,
- int* &table_frac,
- float scale,
- int pixel1,
- int pixel2)
-{
- table_int = new int[pixel2 - pixel1];
- table_frac = new int[pixel2 - pixel1];
-
- for(int i = pixel1, j = 0; i < pixel2; i++, j++)
- {
- float f_x = (float)i * scale;
- int i_x = (int)floor(f_x);
- int a = (int)((f_x - floor(f_x)) * 0xffff);
-
- table_int[j] = i_x;
- table_frac[j] = a;
- }
-}
-
-void ScaleUnit::process_package(LoadPackage *package)
-{
- ScalePackage *pkg = (ScalePackage*)package;
-
-// Arguments for macros
- VFrame *output = overlay->scale_output;
- VFrame *input = overlay->scale_input;
- float scale_w = overlay->w_scale;
- float scale_h = overlay->h_scale;
- int in_x1_int = overlay->in_x1_int;
- int in_y1_int = overlay->in_y1_int;
- int out_h_int = overlay->out_h_int;
- int out_w_int = overlay->out_w_int;
- int do_yuv =
- (overlay->scale_input->get_color_model() == BC_YUV888 ||
- overlay->scale_input->get_color_model() == BC_YUVA8888 ||
- overlay->scale_input->get_color_model() == BC_YUV161616 ||
- overlay->scale_input->get_color_model() == BC_YUVA16161616);
-
- if(overlay->interpolation_type == CUBIC_CUBIC ||
- (overlay->interpolation_type == CUBIC_LINEAR
- && overlay->w_scale > 1 &&
- overlay->h_scale > 1))
- {
-
- switch(overlay->scale_input->get_color_model())
- {
- case BC_RGB888:
- case BC_YUV888:
- BICUBIC(0xff, unsigned char, 3);
- break;
-
- case BC_RGBA8888:
- case BC_YUVA8888:
- BICUBIC(0xff, unsigned char, 4);
- break;
-
- case BC_RGB161616:
- case BC_YUV161616:
- BICUBIC(0xffff, uint16_t, 3);
- break;
-
- case BC_RGBA16161616:
- case BC_YUVA16161616:
- BICUBIC(0xffff, uint16_t, 4);
- break;
- }
- }
- else
-// Perform bilinear scaling input -> scale_output
- {
- switch(overlay->scale_input->get_color_model())
- {
- case BC_RGB888:
- case BC_YUV888:
- BILINEAR(0xff, unsigned char, 3);
- break;
-
- case BC_RGBA8888:
- case BC_YUVA8888:
- BILINEAR(0xff, unsigned char, 4);
- break;
-
- case BC_RGB161616:
- case BC_YUV161616:
- BILINEAR(0xffff, uint16_t, 3);
- break;
-
- case BC_RGBA16161616:
- case BC_YUVA16161616:
- BILINEAR(0xffff, uint16_t, 4);
- break;
- }
- }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-ScaleEngine::ScaleEngine(OverlayFrame *overlay, int cpus)
- : LoadServer(cpus, cpus)
-{
- this->overlay = overlay;
-}
-
-ScaleEngine::~ScaleEngine()
-{
-}
-
-void ScaleEngine::init_packages()
-{
- for(int i = 0; i < total_packages; i++)
- {
- ScalePackage *package = (ScalePackage*)packages[i];
- package->out_row1 = overlay->out_h_int / total_packages * i;
- package->out_row2 = package->out_row1 + overlay->out_h_int / total_packages;
-
- if(i >= total_packages - 1)
- package->out_row2 = overlay->out_h_int;
- }
-}
-
-LoadClient* ScaleEngine::new_client()
-{
- return new ScaleUnit(this, overlay);
-}
-
-LoadPackage* ScaleEngine::new_package()
-{
- return new ScalePackage;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-TranslatePackage::TranslatePackage()
-{
-}
-
-
-
-TranslateUnit::TranslateUnit(TranslateEngine *server, OverlayFrame *overlay)
- : LoadClient(server)
-{
- this->overlay = overlay;
-}
-
-TranslateUnit::~TranslateUnit()
-{
-}
-
-
-
-void TranslateUnit::translation_array(transfer_table* &table,
- float out_x1,
- float out_x2,
- float in_x1,
- float in_x2,
- int in_total,
- int out_total,
- int &out_x1_int,
- int &out_x2_int)
-{
- int out_w_int;
- float offset = out_x1 - in_x1;
-
- out_x1_int = (int)out_x1;
- out_x2_int = MIN((int)ceil(out_x2), out_total);
- out_w_int = out_x2_int - out_x1_int;
-
- table = new transfer_table[out_w_int];
- bzero(table, sizeof(transfer_table) * out_w_int);
-
-
-//printf("OverlayFrame::translation_array 1 %f %f -> %f %f\n", in_x1, in_x2, out_x1, out_x2);
-
- float in_x = in_x1;
- for(int out_x = out_x1_int; out_x < out_x2_int; out_x++)
- {
- transfer_table *entry = &table[out_x - out_x1_int];
-
- entry->in_x1 = (int)in_x;
- entry->in_x2 = (int)in_x + 1;
-
-// Get fraction of output pixel to fill
- entry->output_fraction = 1;
-
- if(out_x1 > out_x)
- {
- entry->output_fraction -= out_x1 - out_x;
- }
-
- if(out_x2 < out_x + 1)
- {
- entry->output_fraction = (out_x2 - out_x);
- }
-
-// Advance in_x until out_x_fraction is filled
- float out_x_fraction = entry->output_fraction;
- float in_x_fraction = floor(in_x + 1) - in_x;
-
- if(out_x_fraction <= in_x_fraction)
- {
- entry->in_fraction1 = out_x_fraction;
- entry->in_fraction2 = 0.0;
- in_x += out_x_fraction;
- }
- else
- {
- entry->in_fraction1 = in_x_fraction;
- in_x += out_x_fraction;
- entry->in_fraction2 = in_x - floor(in_x);
- }
-
-// Clip in_x
- if(entry->in_x2 >= in_total)
- {
- entry->in_x2 = in_total - 1;
- entry->in_fraction2 = 0.0;
- }
-
- if(entry->in_x1 >= in_total)
- {
- entry->in_x1 = in_total - 1;
- entry->in_fraction1 = 0.0;
- }
-// printf("OverlayFrame::translation_array 2 %d %d %d %f %f %f\n",
-// out_x,
-// entry->in_x1,
-// entry->in_x2,
-// entry->in_fraction1,
-// entry->in_fraction2,
-// entry->output_fraction);
- }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#define TRANSLATE(max, type, components) \
-{ \
- \
- type **in_rows = (type**)input->get_rows(); \
- type **out_rows = (type**)output->get_rows(); \
- \
-/* printf("OverlayFrame::translate 1 %.2f %.2f %.2f %.2f -> %.2f %.2f %.2f %.2f\n", */ \
-/* (in_x1), in_y1, in_x2, in_y2, out_x1, out_y1, out_x2, out_y2); */ \
- \
- unsigned int master_opacity = (int)(alpha * max + 0.5); \
- unsigned int master_transparency = max - master_opacity; \
- \
-/* printf("TRANSLATE %d\n", mode); */ \
- \
- for(int i = row1; i < row2; i++) \
- { \
- int in_y1 = y_table[i - out_y1_int].in_x1; \
- int in_y2 = y_table[i - out_y1_int].in_x2; \
- float y_fraction1 = y_table[i - out_y1_int].in_fraction1; \
- float y_fraction2 = y_table[i - out_y1_int].in_fraction2; \
- float y_output_fraction = y_table[i - out_y1_int].output_fraction; \
- type *in_row1 = in_rows[(in_y1)]; \
- type *in_row2 = in_rows[(in_y2)]; \
- type *out_row = out_rows[i]; \
- \
- for(int j = out_x1_int; j < out_x2_int; j++) \
- { \
- int in_x1 = x_table[j - out_x1_int].in_x1; \
- int in_x2 = x_table[j - out_x1_int].in_x2; \
- float x_fraction1 = x_table[j - out_x1_int].in_fraction1; \
- float x_fraction2 = x_table[j - out_x1_int].in_fraction2; \
- float x_output_fraction = x_table[j - out_x1_int].output_fraction; \
- type *output = &out_row[j * components]; \
- int input1, input2, input3, input4; \
- \
- input1 = (int)(in_row1[in_x1 * components] * x_fraction1 * y_fraction1 + \
- in_row1[in_x2 * components] * x_fraction2 * y_fraction1 + \
- in_row2[in_x1 * components] * x_fraction1 * y_fraction2 + \
- in_row2[in_x2 * components] * x_fraction2 * y_fraction2 + 0.5); \
- input2 = (int)(in_row1[in_x1 * components + 1] * x_fraction1 * y_fraction1 + \
- in_row1[in_x2 * components + 1] * x_fraction2 * y_fraction1 + \
- in_row2[in_x1 * components + 1] * x_fraction1 * y_fraction2 + \
- in_row2[in_x2 * components + 1] * x_fraction2 * y_fraction2 + 0.5); \
- input3 = (int)(in_row1[in_x1 * components + 2] * x_fraction1 * y_fraction1 + \
- in_row1[in_x2 * components + 2] * x_fraction2 * y_fraction1 + \
- in_row2[in_x1 * components + 2] * x_fraction1 * y_fraction2 + \
- in_row2[in_x2 * components + 2] * x_fraction2 * y_fraction2 + 0.5); \
- if(components == 4) \
- input4 = (int)(in_row1[in_x1 * components + 3] * x_fraction1 * y_fraction1 + \
- in_row1[in_x2 * components + 3] * x_fraction2 * y_fraction1 + \
- in_row2[in_x1 * components + 3] * x_fraction1 * y_fraction2 + \
- in_row2[in_x2 * components + 3] * x_fraction2 * y_fraction2 + 0.5); \
- \
- unsigned int opacity = (int)(master_opacity * \
- y_output_fraction * \
- x_output_fraction + 0.5); \
- unsigned int transparency = max - opacity; \
- \
-/* if(opacity != max) printf("TRANSLATE %x %d %d\n", opacity, j, i); */ \
- \
- if(components == 3) \
- { \
- BLEND_3(max, type); \
- } \
- else \
- { \
- BLEND_4(max, type); \
- } \
- } \
- } \
-}
-
-void TranslateUnit::process_package(LoadPackage *package)
-{
- TranslatePackage *pkg = (TranslatePackage*)package;
- int out_y1_int;
- int out_y2_int;
- int out_x1_int;
- int out_x2_int;
-
-
-// Variables for TRANSLATE
- VFrame *input = overlay->translate_input;
- VFrame *output = overlay->translate_output;
- float in_x1 = overlay->translate_in_x1;
- float in_y1 = overlay->translate_in_y1;
- float in_x2 = overlay->translate_in_x2;
- float in_y2 = overlay->translate_in_y2;
- float out_x1 = overlay->translate_out_x1;
- float out_y1 = overlay->translate_out_y1;
- float out_x2 = overlay->translate_out_x2;
- float out_y2 = overlay->translate_out_y2;
- float alpha = overlay->translate_alpha;
- int row1 = pkg->out_row1;
- int row2 = pkg->out_row2;
- int mode = overlay->translate_mode;
-
- transfer_table *x_table;
- transfer_table *y_table;
-
- translation_array(x_table,
- out_x1,
- out_x2,
- in_x1,
- in_x2,
- input->get_w(),
- output->get_w(),
- out_x1_int,
- out_x2_int);
- translation_array(y_table,
- out_y1,
- out_y2,
- in_y1,
- in_y2,
- input->get_h(),
- output->get_h(),
- out_y1_int,
- out_y2_int);
-
- switch(overlay->translate_input->get_color_model())
- {
- case BC_RGB888:
- case BC_YUV888:
- TRANSLATE(0xff, unsigned char, 3);
- break;
-
- case BC_RGBA8888:
- case BC_YUVA8888:
- TRANSLATE(0xff, unsigned char, 4);
- break;
-
- case BC_RGB161616:
- case BC_YUV161616:
- TRANSLATE(0xffff, uint16_t, 3);
- break;
-
- case BC_RGBA16161616:
- case BC_YUVA16161616:
- TRANSLATE(0xffff, uint16_t, 4);
- break;
- }
-
- delete [] x_table;
- delete [] y_table;
-}
-
-
-
-
-
-
-
-
-
-
-TranslateEngine::TranslateEngine(OverlayFrame *overlay, int cpus)
- : LoadServer(cpus, cpus)
-{
- this->overlay = overlay;
-}
-
-TranslateEngine::~TranslateEngine()
-{
-}
-
-void TranslateEngine::init_packages()
-{
- int out_y1_int = (int)overlay->translate_out_y1;
- int out_y2_int = MIN((int)ceil(overlay->translate_out_y2), overlay->translate_output->get_h());
- int out_h = out_y2_int - out_y1_int;
-
- for(int i = 0; i < total_packages; i++)
- {
- TranslatePackage *package = (TranslatePackage*)packages[i];
- package->out_row1 = (int)(out_y1_int + out_h /
- total_packages *
- i);
- package->out_row2 = (int)((float)package->out_row1 +
- out_h /
- total_packages);
- if(i >= total_packages - 1)
- package->out_row2 = out_y2_int;
- }
-}
-
-LoadClient* TranslateEngine::new_client()
-{
- return new TranslateUnit(this, overlay);
-}
-
-LoadPackage* TranslateEngine::new_package()
-{
- return new TranslatePackage;
-}
-
-
-
-
-
-
-
-
-#define SCALE_TRANSLATE(max, type, components) \
-{ \
- int64_t opacity = (int)(alpha * max + 0.5); \
- int64_t transparency = max - opacity; \
- int out_w = out_x2 - out_x1; \
- \
- for(int i = pkg->out_row1; i < pkg->out_row2; i++) \
- { \
- int in_y = y_table[i - out_y1]; \
- type *in_row = (type*)in_rows[in_y] + in_x1 * components; \
- type *out_row = (type*)out_rows[i] + out_x1 * components; \
- \
-/* X direction is scaled and requires a table lookup */ \
- if(out_w != in_x2 - in_x1) \
- { \
- for(int j = 0; j < out_w; j++) \
- { \
- int in_x = x_table[j]; \
- int input1, input2, input3, input4; \
- type *output = out_row + j * components; \
- \
- input1 = in_row[in_x * components]; \
- input2 = in_row[in_x * components + 1]; \
- input3 = in_row[in_x * components + 2]; \
- if(components == 4) \
- input4 = in_row[in_x * components + 3]; \
- \
- if(components == 3) \
- { \
- BLEND_3(max, type); \
- } \
- else \
- { \
- BLEND_4(max, type); \
- } \
- } \
- } \
- else \
-/* X direction is not scaled */ \
- { \
- for(int j = 0; j < out_w; j++) \
- { \
- int input1, input2, input3, input4; \
- type *output = out_row + j * components; \
- \
- input1 = in_row[j * components]; \
- input2 = in_row[j * components + 1]; \
- input3 = in_row[j * components + 2]; \
- if(components == 4) \
- input4 = in_row[j * components + 3]; \
- \
- if(components == 3) \
- { \
- BLEND_3(max, type); \
- } \
- else \
- { \
- BLEND_4(max, type); \
- } \
- } \
- } \
- } \
-}
-
-
-
-ScaleTranslateUnit::ScaleTranslateUnit(ScaleTranslateEngine *server, OverlayFrame *overlay)
- : LoadClient(server)
-{
- this->overlay = overlay;
- this->scale_translate = server;
-}
-
-ScaleTranslateUnit::~ScaleTranslateUnit()
-{
-}
-
-void ScaleTranslateUnit::scale_array(int* &table,
- int out_x1,
- int out_x2,
- int in_x1,
- int in_x2,
- int is_x)
-{
- float scale = (float)(out_x2 - out_x1) / (in_x2 - in_x1);
-
- table = new int[out_x2 - out_x1];
-
- if(!is_x)
- {
- for(int i = 0; i < out_x2 - out_x1; i++)
- {
- table[i] = (int)((float)i / scale + in_x1);
- }
- }
- else
- {
- for(int i = 0; i < out_x2 - out_x1; i++)
- {
- table[i] = (int)((float)i / scale);
- }
- }
-}
-
-
-void ScaleTranslateUnit::process_package(LoadPackage *package)
-{
- ScaleTranslatePackage *pkg = (ScaleTranslatePackage*)package;
-
-// Args for NEAREST_NEIGHBOR_MACRO
- VFrame *output = scale_translate->output;
- VFrame *input = scale_translate->input;
- int in_x1 = scale_translate->in_x1;
- int in_y1 = scale_translate->in_y1;
- int in_x2 = scale_translate->in_x2;
- int in_y2 = scale_translate->in_y2;
- int out_x1 = scale_translate->out_x1;
- int out_y1 = scale_translate->out_y1;
- int out_x2 = scale_translate->out_x2;
- int out_y2 = scale_translate->out_y2;
- float alpha = scale_translate->alpha;
- int mode = scale_translate->mode;
-
- int *x_table;
- int *y_table;
- unsigned char **in_rows = input->get_rows();
- unsigned char **out_rows = output->get_rows();
-
- scale_array(x_table,
- out_x1,
- out_x2,
- in_x1,
- in_x2,
- 1);
- scale_array(y_table,
- out_y1,
- out_y2,
- in_y1,
- in_y2,
- 0);
-
-
- switch(input->get_color_model())
- {
- case BC_RGB888:
- case BC_YUV888:
- SCALE_TRANSLATE(0xff, uint8_t, 3);
- break;
-
- case BC_RGBA8888:
- case BC_YUVA8888:
- SCALE_TRANSLATE(0xff, uint8_t, 4);
- break;
-
-
- case BC_RGB161616:
- case BC_YUV161616:
- SCALE_TRANSLATE(0xffff, uint16_t, 3);
- break;
-
- case BC_RGBA16161616:
- case BC_YUVA16161616:
- SCALE_TRANSLATE(0xffff, uint16_t, 4);
- break;
- }
-
- delete [] x_table;
- delete [] y_table;
-
-};
-
-
-
-
-
-
-
-
-
-ScaleTranslateEngine::ScaleTranslateEngine(OverlayFrame *overlay, int cpus)
- : LoadServer(cpus, cpus)
-{
- this->overlay = overlay;
-}
-
-ScaleTranslateEngine::~ScaleTranslateEngine()
-{
-}
-
-void ScaleTranslateEngine::init_packages()
-{
- int out_h = out_y2 - out_y1;
-
- for(int i = 0; i < total_packages; i++)
- {
- ScaleTranslatePackage *package = (ScaleTranslatePackage*)packages[i];
- package->out_row1 = (int)(out_y1 + out_h /
- total_packages *
- i);
- package->out_row2 = (int)((float)package->out_row1 +
- out_h /
- total_packages);
- if(i >= total_packages - 1)
- package->out_row2 = out_y2;
- }
-}
-
-LoadClient* ScaleTranslateEngine::new_client()
-{
- return new ScaleTranslateUnit(this, overlay);
-}
-
-LoadPackage* ScaleTranslateEngine::new_package()
-{
- return new ScaleTranslatePackage;
-}
-
-
-ScaleTranslatePackage::ScaleTranslatePackage()
-{
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#define BLEND_ONLY(type, max, components) \
-{ \
- int64_t opacity = (int)(alpha * max + 0.5); \
- int64_t transparency = max - opacity; \
- \
- type** output_rows = (type**)output->get_rows(); \
- type** input_rows = (type**)input->get_rows(); \
- int w = input->get_w(); \
- int h = input->get_h(); \
- \
- for(int i = pkg->out_row1; i < pkg->out_row2; i++) \
- { \
- type* in_row = input_rows[i]; \
- type* output = output_rows[i]; \
- \
- for(int j = 0; j < w; j++) \
- { \
- int input1, input2, input3, input4; \
- input1 = in_row[j * components]; \
- input2 = in_row[j * components + 1]; \
- input3 = in_row[j * components + 2]; \
- if(components == 4) input4 = in_row[j * components + 3]; \
- \
- \
- if(components == 3) \
- { \
- BLEND_3(max, type); \
- } \
- else \
- { \
- BLEND_4(max, type); \
- } \
- \
- input += components; \
- output += components; \
- } \
- } \
-}
-
-
-
-
-BlendUnit::BlendUnit(BlendEngine *server, OverlayFrame *overlay)
- : LoadClient(server)
-{
- this->overlay = overlay;
- this->blend_engine = server;
-}
-
-BlendUnit::~BlendUnit()
-{
-}
-
-void BlendUnit::process_package(LoadPackage *package)
-{
- BlendPackage *pkg = (BlendPackage*)package;
-
-
- VFrame *output = blend_engine->output;
- VFrame *input = blend_engine->input;
- float alpha = blend_engine->alpha;
- int mode = blend_engine->mode;
-
- switch(input->get_color_model())
- {
- case BC_RGB888:
- case BC_YUV888:
- BLEND_ONLY(unsigned char, 0xff, 3);
- break;
- case BC_RGBA8888:
- case BC_YUVA8888:
- BLEND_ONLY(unsigned char, 0xff, 4);
- break;
- case BC_RGB161616:
- case BC_YUV161616:
- BLEND_ONLY(uint16_t, 0xffff, 3);
- break;
- case BC_RGBA16161616:
- case BC_YUVA16161616:
- BLEND_ONLY(uint16_t, 0xffff, 4);
- break;
- }
-}
-
-
-
-BlendEngine::BlendEngine(OverlayFrame *overlay, int cpus)
- : LoadServer(cpus, cpus)
-{
- this->overlay = overlay;
-}
-
-BlendEngine::~BlendEngine()
-{
-}
-
-void BlendEngine::init_packages()
-{
- for(int i = 0; i < total_packages; i++)
- {
- BlendPackage *package = (BlendPackage*)packages[i];
- package->out_row1 = (int)(input->get_h() /
- total_packages *
- i);
- package->out_row2 = (int)((float)package->out_row1 +
- input->get_h() /
- total_packages);
-
- if(i >= total_packages - 1)
- package->out_row2 = input->get_h();
- }
-}
-
-LoadClient* BlendEngine::new_client()
-{
- return new BlendUnit(this, overlay);
-}
-
-LoadPackage* BlendEngine::new_package()
-{
- return new BlendPackage;
-}
-
-
-BlendPackage::BlendPackage()
-{
-}
-
-
projects / goodguy / history.git / blobdiff