368 lines
9.0 KiB
C++
368 lines
9.0 KiB
C++
#include <precomp.h>
|
|
|
|
#include <api/wnd/popup.h>
|
|
#include <math.h>
|
|
#include <api/skin/skinparse.h>
|
|
#include <api/service/svc_enum.h>
|
|
#include <api/service/svcs/svc_skinfilter.h>
|
|
#include <api/skin/widgets/seqvis.h>
|
|
#include <api/core/api_core.h>
|
|
#include <tataki/canvas/bltcanvas.h>
|
|
const wchar_t eqVisXuiStr[] = L"EQVis"; // This is the xml tag
|
|
char eqVisXuiSvcName[] = "EQVis xui object"; // this is the name of the xuiservice
|
|
XMLParamPair SEQVis::params[] =
|
|
{
|
|
{
|
|
SEQVIS_SETCOLORBOTTOM, L"COLORBOTTOM"
|
|
},
|
|
{SEQVIS_SETCOLORMIDDLE, L"COLORMIDDLE"},
|
|
{SEQVIS_SETCOLORPREAMP, L"COLORPREAMP"},
|
|
{SEQVIS_SETCOLORTOP, L"COLORTOP"},
|
|
{SEQVIS_SETALPHA, L"GAMMA"}, // BACKWARD COMPAT
|
|
};
|
|
SEQVis::SEQVis()
|
|
{
|
|
getScriptObject()->vcpu_setInterface(eqvisGuid, (void *)static_cast<SEQVis *>(this));
|
|
getScriptObject()->vcpu_setClassName(L"EqVis");
|
|
getScriptObject()->vcpu_setController(eqvisController);
|
|
colortop = colormid = colorbottom = 0xffffff;
|
|
colorpreamp = 0x888888;
|
|
shadedColors = NULL;
|
|
bc = NULL;
|
|
sfe = new SkinFilterEnum();
|
|
|
|
while (1)
|
|
{
|
|
svc_skinFilter *obj = sfe->getNext();
|
|
if (!obj) break;
|
|
filters.addItem(obj);
|
|
}
|
|
xuihandle = newXuiHandle();
|
|
CreateXMLParameters(xuihandle);
|
|
|
|
}
|
|
|
|
void SEQVis::CreateXMLParameters(int master_handle)
|
|
{
|
|
//SEQVIS_PARENT::CreateXMLParameters(master_handle);
|
|
int numParams = sizeof(params) / sizeof(params[0]);
|
|
hintNumberOfParams(xuihandle, numParams);
|
|
for (int i = 0;i < numParams;i++)
|
|
addParam(xuihandle, params[i], XUI_ATTRIBUTE_IMPLIED);
|
|
}
|
|
|
|
int SEQVis::onInit()
|
|
{
|
|
SEQVIS_PARENT::onInit();
|
|
WASABI_API_MEDIACORE->core_addCallback(0, this);
|
|
return 1;
|
|
}
|
|
|
|
SEQVis::~SEQVis()
|
|
{
|
|
foreach(filters)
|
|
sfe->release(filters.getfor());
|
|
endfor;
|
|
delete sfe;
|
|
if (shadedColors) FREE(shadedColors);
|
|
delete(bc);
|
|
WASABI_API_MEDIACORE->core_delCallback(0, this);
|
|
}
|
|
|
|
int SEQVis::setXuiParam(int _xuihandle, int attrid, const wchar_t *paramname, const wchar_t *strvalue)
|
|
{
|
|
if (_xuihandle != xuihandle) return SEQVIS_PARENT::setXuiParam(_xuihandle, attrid, paramname, strvalue);
|
|
switch (attrid)
|
|
{
|
|
case SEQVIS_SETALPHA:
|
|
getGuiObject()->guiobject_setAlpha(WTOI(strvalue));
|
|
break;
|
|
case SEQVIS_SETCOLORTOP:
|
|
colortop = RGBTOBGR(SkinParser::parseColor(strvalue));
|
|
break;
|
|
case SEQVIS_SETCOLORMIDDLE:
|
|
colormid = RGBTOBGR(SkinParser::parseColor(strvalue));
|
|
break;
|
|
case SEQVIS_SETCOLORBOTTOM:
|
|
colorbottom = RGBTOBGR(SkinParser::parseColor(strvalue));
|
|
break;
|
|
case SEQVIS_SETCOLORPREAMP:
|
|
colorpreamp = RGBTOBGR(SkinParser::parseColor(strvalue));
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void SEQVis::splineGetPoint(spline_struct *s, float frame, float *out)
|
|
{
|
|
int i, i_1, i0, i1, i2;
|
|
float time1, time2, time3;
|
|
float t1, t2, t3, t4, u1, u2, u3, u4, v1, v2, v3;
|
|
float a, b, c, d;
|
|
|
|
float *keys = s->keys;
|
|
|
|
a = (1 - s->tens) * (1 + s->cont) * (1 + s->bias);
|
|
b = (1 - s->tens) * (1 - s->cont) * (1 - s->bias);
|
|
c = (1 - s->tens) * (1 - s->cont) * (1 + s->bias);
|
|
d = (1 - s->tens) * (1 + s->cont) * (1 - s->bias);
|
|
v1 = t1 = -a / 2.0f; u1 = a;
|
|
u2 = (-6 - 2 * a + 2 * b + c) / 2.0f; v2 = (a - b) / 2.0f; t2 = (4 + a - b - c) / 2.0f;
|
|
t3 = (-4 + b + c - d) / 2.0f;
|
|
u3 = (6 - 2 * b - c + d) / 2.0f;
|
|
v3 = b / 2.0f;
|
|
t4 = d / 2.0f; u4 = -t4;
|
|
|
|
i0 = (int) frame;
|
|
i_1 = i0 - 1;
|
|
while (i_1 < 0) i_1 += s->numKeys;
|
|
i1 = i0 + 1;
|
|
while (i1 >= s->numKeys) i1 -= s->numKeys;
|
|
i2 = i0 + 2;
|
|
while (i2 >= s->numKeys) i2 -= s->numKeys;
|
|
time1 = frame - (float)((int) frame);
|
|
time2 = time1 * time1;
|
|
time3 = time2 * time1;
|
|
i0 *= s->keyWidth;
|
|
i1 *= s->keyWidth;
|
|
i2 *= s->keyWidth;
|
|
i_1 *= s->keyWidth;
|
|
for (i = 0; i < s->keyWidth; i ++)
|
|
{
|
|
a = t1 * keys[i + i_1] + t2 * keys[i + i0] + t3 * keys[i + i1] + t4 * keys[i + i2];
|
|
b = u1 * keys[i + i_1] + u2 * keys[i + i0] + u3 * keys[i + i1] + u4 * keys[i + i2];
|
|
c = v1 * keys[i + i_1] + v2 * keys[i + i0] + v3 * keys[i + i1];
|
|
*out++ = a * time3 + b * time2 + c * time1 + keys[i + i0];
|
|
}
|
|
}
|
|
|
|
void SEQVis::DrawEQVis()
|
|
{
|
|
|
|
if (!shadedColors) return ;
|
|
|
|
float keys[12] = {0};
|
|
spline_struct spline = {keys, 1, 12, 0.0f, 0.0f, 0.1f};
|
|
|
|
MEMSET(specData, 0, cur_w*cur_h*4);
|
|
|
|
int ph = (int)((127 + WASABI_API_MEDIACORE->core_getEqPreamp(0)) * ((float)cur_h) / 256.0f);
|
|
ph *= cur_w;
|
|
for (int j = 0;j < cur_w;j++)
|
|
specData[j + ph] = colorpreamp | 0xFF000000; // alpha :)
|
|
|
|
{
|
|
int x;
|
|
int last_p = -1;
|
|
for (x = 0; x < 10; x ++)
|
|
keys[x + 1] = (127 - WASABI_API_MEDIACORE->core_getEqBand(0, x)) * ((float)cur_h) / 256.0f;
|
|
keys[0] = keys[1];
|
|
keys[11] = keys[10];
|
|
|
|
for (x = 0; x < cur_w; x ++)
|
|
{
|
|
float p;
|
|
int this_p;
|
|
splineGetPoint(&spline, 1.0f + x / (cur_w*11.0f / 100.0f), &p);
|
|
this_p = (int)p;
|
|
if (this_p < 0) this_p = 0;
|
|
if (this_p >= cur_h) this_p = cur_h - 1;
|
|
if (last_p == -1 || this_p == last_p)
|
|
specData[x + this_p*cur_w] = shadedColors[this_p];
|
|
else
|
|
{
|
|
if (this_p < last_p)
|
|
for (int j = 0;j < last_p - this_p + 1;j++)
|
|
specData[x + (this_p + j)*cur_w] = shadedColors[this_p + j];
|
|
else if (this_p > last_p)
|
|
for (int j = 0;j < this_p - last_p + 1;j++)
|
|
specData[x + (last_p + j)*cur_w] = shadedColors[last_p + j];
|
|
}
|
|
last_p = this_p;
|
|
}
|
|
}
|
|
invalidate();
|
|
invalidated = 1; // rerun filter
|
|
}
|
|
|
|
int SEQVis::onPaint(Canvas *canvas)
|
|
{
|
|
PaintCanvas paintcanvas;
|
|
if (canvas == NULL)
|
|
{
|
|
if (!paintcanvas.beginPaint(this)) return 0;
|
|
canvas = &paintcanvas;
|
|
}
|
|
|
|
SEQVIS_PARENT::onPaint(canvas);
|
|
|
|
RECT s, r;
|
|
getClientRect(&r);
|
|
s.left = 0;
|
|
s.top = 0;
|
|
s.right = cur_w;
|
|
s.bottom = cur_h;
|
|
|
|
if (invalidated)
|
|
{
|
|
SkinBitmap *b = bc->getSkinBitmap();
|
|
foreach(filters)
|
|
filters.getfor()->filterBitmap((unsigned char *)bc->getBits(), b->getWidth(), b->getHeight(), 32, NULL, L"Vis/Eq");
|
|
endfor;
|
|
invalidated = 0;
|
|
b->stretchToRectAlpha(canvas, &s, &r, getPaintingAlpha());
|
|
}
|
|
else
|
|
{
|
|
bc->stretchToRectAlpha(canvas, &s, &r, getPaintingAlpha());
|
|
//SkinBitmap *b = bc->getSkinBitmap();
|
|
//b->stretchToRectAlpha(canvas, &s, &r, getPaintingAlpha());
|
|
}
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
int SEQVis::corecb_onEQBandChange(int b, int newval)
|
|
{
|
|
DrawEQVis();
|
|
return 0;
|
|
}
|
|
|
|
int SEQVis::corecb_onEQPreampChange(int newval)
|
|
{
|
|
DrawEQVis();
|
|
return 0;
|
|
}
|
|
|
|
void SEQVis::reloadResources()
|
|
{
|
|
SEQVIS_PARENT::reloadResources();
|
|
DrawEQVis();
|
|
invalidate();
|
|
}
|
|
|
|
int SEQVis::onResize()
|
|
{
|
|
SEQVIS_PARENT::onResize();
|
|
RECT r;
|
|
getClientRect(&r);
|
|
|
|
cur_h = r.bottom - r.top;
|
|
if (cur_h <= 0) cur_h = 1;
|
|
cur_w = r.right - r.left;
|
|
if (cur_w <= 0) cur_w = 1;
|
|
|
|
delete bc;
|
|
bc = new BltCanvas(cur_w, -cur_h);
|
|
specData = (int *)bc->getBits();
|
|
MEMSET(specData, 0, cur_w*cur_h*4);
|
|
|
|
if (shadedColors) FREE(shadedColors);
|
|
shadedColors = (int *)MALLOC(sizeof(int) * cur_h);
|
|
int r1 = colortop & 0xff0000;
|
|
int g1 = (colortop & 0x00ff00) << 8;
|
|
int b1 = (colortop & 0x0000ff) << 16;
|
|
int r2 = colormid & 0xff0000;
|
|
int g2 = (colormid & 0x00ff00) << 8;
|
|
int b2 = (colormid & 0x0000ff) << 16;
|
|
int r3 = colorbottom & 0xff0000;
|
|
int g3 = (colorbottom & 0x00ff00) << 8;
|
|
int b3 = (colorbottom & 0x0000ff) << 16;
|
|
int l = cur_h / 2;
|
|
if (!l) l = 1;
|
|
int i;
|
|
for (i = 0;i < l;i++)
|
|
{
|
|
int r = r1 + ((r2 - r1) * i / l);
|
|
int g = g1 + ((g2 - g1) * i / l);
|
|
int b = b1 + ((b2 - b1) * i / l);
|
|
shadedColors[i] = (r & 0xff0000);
|
|
shadedColors[i] += ((g & 0xff0000) >> 8);
|
|
shadedColors[i] += ((b & 0xff0000) >> 16);
|
|
shadedColors[i] += 0xff000000; // alpha?
|
|
}
|
|
for (i = l;i < cur_h;i++)
|
|
{
|
|
int r = r2 + ((r3 - r2) * (i - l) / l);
|
|
int g = g2 + ((g3 - g2) * (i - l) / l);
|
|
int b = b2 + ((b3 - b2) * (i - l) / l);
|
|
shadedColors[i] = (r & 0xff0000);
|
|
shadedColors[i] += ((g & 0xff0000) >> 8);
|
|
shadedColors[i] += ((b & 0xff0000) >> 16);
|
|
shadedColors[i] += 0xff000000; // alpha?
|
|
}
|
|
DrawEQVis();
|
|
|
|
return 1;
|
|
}
|
|
|
|
EqVisScriptController _eqvisController;
|
|
EqVisScriptController *eqvisController = &_eqvisController;
|
|
|
|
// -- Functions table -------------------------------------
|
|
function_descriptor_struct EqVisScriptController::exportedFunction[] = {
|
|
{L"fake", 0, (void*)SEQVis::script_vcpu_fake },
|
|
};
|
|
|
|
// --------------------------------------------------------
|
|
|
|
const wchar_t *EqVisScriptController::getClassName()
|
|
{
|
|
return L"EqVis";
|
|
}
|
|
|
|
const wchar_t *EqVisScriptController::getAncestorClassName()
|
|
{
|
|
return L"GuiObject";
|
|
}
|
|
|
|
ScriptObject *EqVisScriptController::instantiate()
|
|
{
|
|
SEQVis *eqv = new SEQVis;
|
|
ASSERT(eqv != NULL);
|
|
return eqv->getScriptObject();
|
|
}
|
|
|
|
void EqVisScriptController::destroy(ScriptObject *o)
|
|
{
|
|
SEQVis *eqv = static_cast<SEQVis *>(o->vcpu_getInterface(eqvisGuid));
|
|
ASSERT(eqv != NULL);
|
|
delete eqv;
|
|
}
|
|
|
|
void *EqVisScriptController::encapsulate(ScriptObject *o)
|
|
{
|
|
return NULL; // no encapsulation for eqvis yet
|
|
}
|
|
|
|
void EqVisScriptController::deencapsulate(void *o)
|
|
{}
|
|
|
|
int EqVisScriptController::getNumFunctions()
|
|
{
|
|
return sizeof(exportedFunction) / sizeof(function_descriptor_struct);
|
|
}
|
|
|
|
const function_descriptor_struct *EqVisScriptController::getExportedFunctions()
|
|
{
|
|
return exportedFunction;
|
|
}
|
|
|
|
GUID EqVisScriptController::getClassGuid()
|
|
{
|
|
return eqvisGuid;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
|
|
scriptVar SEQVis::script_vcpu_fake(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|