void ConfigDialog::_init()
{
// Video settings
QStringList windowedModesList;
int windowedModesCurrent = -1;
for (unsigned int i = 0; i < numWindowedModes; ++i) {
windowedModesList.append(WindowedModes[i].description);
if (WindowedModes[i].width == config.video.windowedWidth &&
WindowedModes[i].height == config.video.windowedHeight)
windowedModesCurrent = i;
}
ui->windowedResolutionComboBox->insertItems(0, windowedModesList);
if (windowedModesCurrent > -1)
ui->windowedResolutionComboBox->setCurrentIndex(windowedModesCurrent);
else
ui->windowedResolutionComboBox->setCurrentText(
QString::number(config.video.windowedWidth) + " x " +
QString::number(config.video.windowedHeight)
);
// matches w x h where w is 300-7999 and h is 200-3999, spaces around x optional
QRegExp windowedRegExp("([3-9][0-9]{2}|[1-7][0-9]{3}) ?x ?([2-9][0-9]{2}|[1-3][0-9]{3})");
QValidator *windowedValidator = new QRegExpValidator(windowedRegExp, this);
ui->windowedResolutionComboBox->setValidator(windowedValidator);
ui->cropImageComboBox->setCurrentIndex(config.video.cropMode);
ui->cropImageWidthSpinBox->setValue(config.video.cropWidth);
ui->cropImageHeightSpinBox->setValue(config.video.cropHeight);
ui->cropImageCustomFrame->setVisible(config.video.cropMode == Config::cmCustom);
QStringList fullscreenModesList, fullscreenRatesList;
int fullscreenMode, fullscreenRate;
fillFullscreenResolutionsList(fullscreenModesList, fullscreenMode, fullscreenRatesList, fullscreenRate);
ui->fullScreenResolutionComboBox->insertItems(0, fullscreenModesList);
ui->fullScreenResolutionComboBox->setCurrentIndex(fullscreenMode);
ui->fullScreenRefreshRateComboBox->setCurrentIndex(fullscreenRate);
ui->aliasingSlider->setValue(powof(config.video.multisampling));
ui->aliasingLabelVal->setText(QString::number(config.video.multisampling));
ui->anisotropicSlider->setValue(config.texture.maxAnisotropy);
ui->vSyncCheckBox->setChecked(config.video.verticalSync != 0);
switch (config.texture.bilinearMode) {
case BILINEAR_3POINT:
ui->blnr3PointRadioButton->setChecked(true);
break;
case BILINEAR_STANDARD:
ui->blnrStandardRadioButton->setChecked(true);
break;
}
switch (config.texture.screenShotFormat) {
case 0:
ui->pngRadioButton->setChecked(true);
break;
case 1:
ui->jpegRadioButton->setChecked(true);
break;
}
// Emulation settings
ui->emulateLodCheckBox->setChecked(config.generalEmulation.enableLOD != 0);
ui->emulateNoiseCheckBox->setChecked(config.generalEmulation.enableNoise != 0);
ui->enableHWLightingCheckBox->setChecked(config.generalEmulation.enableHWLighting != 0);
ui->enableShadersStorageCheckBox->setChecked(config.generalEmulation.enableShadersStorage != 0);
ui->customSettingsCheckBox->setChecked(config.generalEmulation.enableCustomSettings != 0);
switch (config.generalEmulation.correctTexrectCoords) {
case Config::tcDisable:
ui->fixTexrectDisableRadioButton->setChecked(true);
break;
case Config::tcSmart:
ui->fixTexrectSmartRadioButton->setChecked(true);
break;
case Config::tcForce:
ui->fixTexrectForceRadioButton->setChecked(true);
break;
}
ui->nativeRes2D_checkBox->toggle();
ui->nativeRes2D_checkBox->setChecked(config.generalEmulation.enableNativeResTexrects != 0);
ui->gammaCorrectionCheckBox->toggle();
ui->gammaCorrectionCheckBox->setChecked(config.gammaCorrection.force != 0);
ui->gammaLevelSpinBox->setValue(config.gammaCorrection.level);
ui->frameBufferSwapComboBox->setCurrentIndex(config.frameBufferEmulation.bufferSwapMode);
ui->fbInfoEnableCheckBox->toggle();
ui->fbInfoEnableCheckBox->setChecked(config.frameBufferEmulation.fbInfoDisabled == 0);
ui->frameBufferCheckBox->toggle();
const bool fbEmulationEnabled = config.frameBufferEmulation.enable != 0;
ui->frameBufferCheckBox->setChecked(fbEmulationEnabled);
ui->frameBufferInfoFrame->setVisible(!fbEmulationEnabled);
ui->frameBufferInfoFrame2->setVisible(!fbEmulationEnabled);
ui->copyColorBufferComboBox->setCurrentIndex(config.frameBufferEmulation.copyToRDRAM);
ui->copyDepthBufferComboBox->setCurrentIndex(config.frameBufferEmulation.copyDepthToRDRAM);
ui->RenderFBCheckBox->setChecked(config.frameBufferEmulation.copyFromRDRAM != 0);
ui->n64DepthCompareCheckBox->toggle();
ui->n64DepthCompareCheckBox->setChecked(config.frameBufferEmulation.N64DepthCompare != 0);
switch (config.frameBufferEmulation.aspect) {
case Config::aStretch:
ui->aspectStretchRadioButton->setChecked(true);
break;
case Config::a43:
ui->aspect43RadioButton->setChecked(true);
break;
case Config::a169:
ui->aspect169RadioButton->setChecked(true);
break;
case Config::aAdjust:
ui->aspectAdjustRadioButton->setChecked(true);
break;
}
ui->resolutionFactorSlider->valueChanged(2);
ui->factor0xRadioButton->toggle();
ui->factor1xRadioButton->toggle();
ui->factorXxRadioButton->toggle();
switch (config.frameBufferEmulation.nativeResFactor) {
case 0:
ui->factor0xRadioButton->setChecked(true);
break;
case 1:
ui->factor1xRadioButton->setChecked(true);
break;
default:
ui->factorXxRadioButton->setChecked(true);
ui->resolutionFactorSlider->setValue(config.frameBufferEmulation.nativeResFactor);
break;
}
ui->copyAuxBuffersCheckBox->setChecked(config.frameBufferEmulation.copyAuxToRDRAM != 0);
ui->readColorChunkCheckBox->setChecked(config.frameBufferEmulation.fbInfoReadColorChunk != 0);
ui->readColorChunkCheckBox->setEnabled(fbEmulationEnabled && config.frameBufferEmulation.fbInfoDisabled == 0);
ui->readDepthChunkCheckBox->setChecked(config.frameBufferEmulation.fbInfoReadDepthChunk != 0);
ui->readDepthChunkCheckBox->setEnabled(fbEmulationEnabled && config.frameBufferEmulation.fbInfoDisabled == 0);
// Texture filter settings
ui->filterComboBox->setCurrentIndex(config.textureFilter.txFilterMode);
ui->enhancementComboBox->setCurrentIndex(config.textureFilter.txEnhancementMode);
ui->textureFilterCacheSpinBox->setValue(config.textureFilter.txCacheSize / gc_uMegabyte);
ui->deposterizeCheckBox->setChecked(config.textureFilter.txDeposterize != 0);
ui->ignoreBackgroundsCheckBox->setChecked(config.textureFilter.txFilterIgnoreBG != 0);
ui->texturePackOnCheckBox->toggle();
ui->texturePackOnCheckBox->setChecked(config.textureFilter.txHiresEnable != 0);
ui->alphaChannelCheckBox->setChecked(config.textureFilter.txHiresFullAlphaChannel != 0);
ui->alternativeCRCCheckBox->setChecked(config.textureFilter.txHresAltCRC != 0);
ui->textureDumpCheckBox->setChecked(config.textureFilter.txDump != 0);
ui->force16bppCheckBox->setChecked(config.textureFilter.txForce16bpp != 0);
ui->compressCacheCheckBox->setChecked(config.textureFilter.txCacheCompression != 0);
ui->saveTextureCacheCheckBox->setChecked(config.textureFilter.txSaveCache != 0);
ui->txPathLabel->setText(QString::fromWCharArray(config.textureFilter.txPath));
ui->txCachePathLabel->setText(QString::fromWCharArray(config.textureFilter.txCachePath));
ui->txDumpPathLabel->setText(QString::fromWCharArray(config.textureFilter.txDumpPath));
// OSD settings
QString fontName(config.font.name.c_str());
ui->fontLineEdit->setText(fontName);
m_font = QFont(fontName.left(fontName.indexOf(".ttf")));
m_font.setPixelSize(config.font.size);
ui->fontLineEdit->setHidden(true);
ui->fontSizeSpinBox->setValue(config.font.size);
m_color = QColor(config.font.color[0], config.font.color[1], config.font.color[2]);
QPalette palette;
palette.setColor(QPalette::WindowText, m_color);
palette.setColor(QPalette::Window, Qt::black);
ui->fontPreviewLabel->setAutoFillBackground(true);
ui->fontPreviewLabel->setPalette(palette);
ui->PickFontColorButton->setStyleSheet(QString("color:") + m_color.name());
switch (config.onScreenDisplay.pos) {
case Config::posTopLeft:
ui->topLeftPushButton->setChecked(true);
break;
case Config::posTopCenter:
ui->topPushButton->setChecked(true);
break;
case Config::posTopRight:
ui->topRightPushButton->setChecked(true);
break;
case Config::posBottomLeft:
ui->bottomLeftPushButton->setChecked(true);
break;
case Config::posBottomCenter:
ui->bottomPushButton->setChecked(true);
break;
case Config::posBottomRight:
ui->bottomRightPushButton->setChecked(true);
break;
}
ui->fpsCheckBox->setChecked(config.onScreenDisplay.fps != 0);
ui->visCheckBox->setChecked(config.onScreenDisplay.vis != 0);
ui->percentCheckBox->setChecked(config.onScreenDisplay.percent != 0);
ui->internalResolutionCheckBox->setChecked(config.onScreenDisplay.internalResolution != 0);
ui->renderingResolutionCheckBox->setChecked(config.onScreenDisplay.renderingResolution != 0);
// Buttons
ui->buttonBox->button(QDialogButtonBox::Ok)->setText(tr("OK"));
ui->buttonBox->button(QDialogButtonBox::Cancel)->setText(tr("Cancel"));
ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setText(tr("Restore Defaults"));
ui->dumpLowCheckBox->setChecked((config.debug.dumpMode & DEBUG_LOW) != 0);
ui->dumpNormalCheckBox->setChecked((config.debug.dumpMode & DEBUG_NORMAL) != 0);
ui->dumpDetailCheckBox->setChecked((config.debug.dumpMode & DEBUG_DETAIL) != 0);
#ifndef DEBUG_DUMP
for (int i = 0; i < ui->tabWidget->count(); ++i) {
if (tr("Debug") == ui->tabWidget->tabText(i)) {
ui->tabWidget->removeTab(i);
break;
}
}
#endif
}
void
kernel (int type, double *parameters, int nb_param, type_AF ker)
{
int line, col;
double doppler, delay;
double inter;
/* some tests */
if ((ker.N_doppler <1) || (ker.N_delay < 1))
{
printf("kernel.c : invalid number of lines / columns in the kernel matrix \n");
exit(0);
}
switch (type)
{
/***************************************************************
* Multiform Tiltable Exponentiel Kernel *
***************************************************************
* The parameters vector is made of *
* alpha, beta, gamma, r, tau0, nu0, lambda] *
* see the reference : *
* H. Costa and G.F. Boudreaux-Bartels, *
* Design of Time-Frequency Representations Using a *
* Multiform, Tiltable Exponential Kernel *
* IEEE Trans. on Signal Processing *
* October 1995, vol. 43, no 10, pp 2283-2301 *
***************************************************************/
/* LOCAL VARIABLES *
* Name | role *
* A | intermediary in the computation of the *
* | MTEK kernel *
***************************************************************/
case MTEK:
{
/* local variables for the MTEK */
double A;
/* Kernel Construction */
for (line = 0; line < ker.N_doppler; line++)
{
doppler = (line - ker.N_doppler / 2.0 + 1.0) / ker.N_doppler;
for (col = 0; col < ker.N_delay; col++)
{
delay = col - ker.N_delay / 2.0 + 1.0;
A = (doppler * delay) / (TAU_0 * NU_0);
/* case of the symmetrical kernel */
if ((BETA == 2) && (GAMMA == 0.5))
{
A = ABS (A);
}
/* case where the marginals do not have to be verified */
if (ALPHA == 0)
{
inter = sqr (delay / TAU_0) + sqr (doppler / NU_0)
+ 2.0
* R * A;
}
/* case where the marginals have to be verified */
else
{
inter = sqr (delay / TAU_0) * powof (sqr (doppler /
NU_0), ALPHA)
+ sqr (doppler / NU_0) * powof (sqr (delay /
TAU_0), ALPHA)
+ 2.0 * R * A;
}
/* test to avoid the computation of log(0) */
if (inter == 0)
{
ker.real_part[idx (line, col, ker.N_doppler)] = 1.0;
}
else
{
ker.real_part[idx (line, col, ker.N_doppler)] =
exp (-pi * powof (sqr (inter), LAMBDA));
}
inter = 0;
A = 0;
}
}
}
break;
/***************************************************************
* Radially Gaussian kernel *
***************************************************************
* The parameters vector is made according to the rule : *
* if the order of the kernel is p, the vector is *
* [ c ,a1 , ... , ap, b1,... ,bp] where c is the constant *
* ai are the cosine coefficients and bi the sine *
* coefficients in the Fourier series decomposition of the *
* contour. See the reference : *
* M. Davy and C. Doncarli, *
* Optimal Kernels of Time-Frequency Representations for *
* Signal Classification, *
* TFTS 1998, pp 581-584. *
***************************************************************/
/* LOCAL VARIABLES *
* Name | role *
* order | Fixes the maximum p in the vector of params*
* p | Current parameter p in the vector of params*
* a,b | Vectors containing the parameters ap, bp *
* | from the vector of params *
* c | The minimum value of the contour function *
* inter, mini | Intermediary values in the computations *
* phi | angle parameter in the polar coordinates *
* rho2 | square radius parameter in polar coord. *
***************************************************************/
case RGK:
{
/* local variables for the RGK */
int order, p;
double *a, *b;
double c, inter, mini;
double phi, rho2;
/* some error cases to avoid ... */
if (ISODD(nb_param) == 0)
{
printf("kernel.c : the number of RGK parameters must be ODD\n");
exit(0);
}
order = (nb_param - 1) / 2;
/* memory allocation for a and b */
a = (double *) ALLOC ( order , sizeof(double) );
b = (double *) ALLOC ( order , sizeof(double) );
/* variables recovery */
c = parameters[0];
for (p = 0; p < order; p++)
{
a[p] = parameters[p + 1];
b[p] = parameters[order + p + 1];
}
/*-----------------------------------------------*/
/* Kernel Construction */
/*-----------------------------------------------*/
/* minimum value of the contour function */
mini = 0;
/* construction of the matrix of the contour function */
for (line = 0; line < ker.N_doppler; line++)
{
/* current doppler value */
doppler = (line - ker.N_doppler / 2.0 + 1.0) / ker.N_doppler;
/* normalization of the doppler to have angles in radians */
doppler = doppler * sqrt (ker.N_delay);
for (col = 0; col < ker.N_delay; col++)
{
/* currrent delay value */
delay = col - ker.N_delay / 2.0 + 1.0;
/* normalization of the delay to have angles in radians */
delay = delay / sqrt (ker.N_delay);
/* computation of the angles in the ambiguity plane */
if (((delay > 0) && (doppler > 0))
|| ((delay < 0) && (doppler < 0)))
{
phi = atan (doppler / delay);
}
else
{
phi = atan (doppler / delay) + pi;
}
inter = 0;
for (p = 0; p < order; p++)
{
inter = inter + a[p] * cos (2.0 * (p + 1) * phi) +
b[p]
* sin (2.0 * (p + 1) * phi);
}
/* look for the minimum */
if (inter < mini)
{
mini = inter;
}
/* matrix of the contour function : each element in this */
/* matrix contains the value of the contour function for */
/* the corresponding delay and doppler values */
ker.real_part[idx (line, col, ker.N_doppler)] = inter;
}
}
/* construction of the RGK matrix */
for (line = 0; line < ker.N_doppler; line++)
{
/* current normalized doppler */
doppler = (line - ker.N_doppler / 2.0 + 1.0) / ker.N_doppler;
doppler = doppler * sqrt (ker.N_delay);
for (col = 0; col < ker.N_delay; col++)
{
/* current normalized delay */
delay = col - ker.N_delay / 2.0 + 1.0;
delay = delay / sqrt (ker.N_delay);
/* Square Polar radius */
rho2 = sqr (doppler) + sqr (delay);
ker.real_part[idx (line, col, ker.N_doppler)] =
exp (-(rho2 / 2.0) /
sqr (ker.real_part[idx (line, col, ker.N_doppler)]
- mini + c));
/* case of the center of the ambiguity plane */
if ((delay == 0) && (doppler == 0))
ker.real_part[idx (line, col, ker.N_doppler)] = 1.0;
}
}
/* free the memory used here */
FREE (a);
FREE (b);
}
break;
/***************************************************************
* Generalized Marginals Choi-Williams *
***************************************************************
* The parameters vector is made of the width of the *
* branches "sigma" and the angle of each branch theta_i *
* (0 to Pi). The number of branches is given by the number *
* of coefficients *
* [ sigma theta_1 theta_2 ... theta_p] *
* *
* see the reference : *
* X.-G. Xia and Y. Owechko and B. H. Soffer and R. M. Matic, *
* Generalized-Marginal Time-Frequency Distributions, *
* TFTS 1996, pp. 509-51 *
***************************************************************/
/* LOCAL VARIABLES *
* Name | role *
* N_Branch | Number of kernel branches *
* branch | Current branch number *
* angle | vector of branches angles *
* sigma | value of the parameter sigma (kernel width)*
* inter | intermediary variable *
***************************************************************/
case GMCWK:
{
/* local variables for the RGK */
int N_branch, branch;
double *angle, sigma, inter;
/* some error cases to avoid ... */
if (nb_param < 2)
{
printf("kernel.c : at least 2 GMCWK parameters required\n");
exit(0);
}
/* variables recovery */
sigma = parameters[0];
N_branch = nb_param - 1;
/* recovery of the angles */
angle = &(parameters[1]);
/* Kernel Construction */
for (line = 0; line < ker.N_doppler; line++)
{
doppler = (line - ker.N_doppler / 2.0 + 1.0)
/ ker.N_doppler;
doppler = doppler * sqrt (ker.N_delay);
for (col = 0; col < ker.N_delay; col++)
{
delay = col - ker.N_delay / 2.0 + 1.0;
delay = delay / sqrt (ker.N_delay);
inter = 1;
for (branch = 0; branch < N_branch; branch++)
{
inter = inter
* sqr (doppler * cos (angle[branch])
+ delay * sin (angle[branch]));
}
ker.real_part[idx (line, col, ker.N_doppler)] =
exp (-inter / sigma);
}
}
}
break;
/***************************************************************
* Wigner-Ville kernel *
***************************************************************
* No parameter is required. The matrix is equal to *
* one in each point *
***************************************************************/
case WIGNER:
{
/* Kernel Construction */
for (line = 0; line < ker.N_doppler; line++)
{
for (col = 0; col < ker.N_delay; col++)
{
ker.real_part[idx (line, col, ker.N_doppler)] = 1.0;
}
}
}
break;
/***************************************************************
* Spectrogram kernel *
***************************************************************
* The paremters are the window points in the time *
* domain. The kernel is the ambiguity function of the window *
***************************************************************/
/* LOCAL VARIABLES *
* Name | role *
* window | structure containing the window of the *
* | spectrogram *
* AF_h | Ambiguity function of th window *
* min_delay | | in order to pad with zeros, defines the *
* max_delay | | indices where the zero padding begins/ends *
* index | indice to access the elements in matrices *
* | (stored as vectors) *
***************************************************************/
case SPECTRO:
{
/* local variable */
type_signal window;
type_AF AF_h;
int min_delay, max_delay, index;
/* some error cases to avoid ... */
if (ISODD(nb_param) == 1)
{
printf("kernel.c : the window length must be EVEN for SPECTRO\n");
exit(0);
}
/* initialization of the local variables : window */
window.length = ker.N_delay;
window.is_complex = TRUE;
/* creation of memory */
window.real_part = (double *) ALLOC (window.length, sizeof (double));
window.imag_part = (double *) ALLOC (window.length, sizeof (double));
min_delay = (int) (window.length / 2 - nb_param / 2);
max_delay = (int) (window.length / 2 + nb_param / 2 - 1);
/* initialization of the imaginary part for the window
and zero padding out of [min_delay;max_delay] */
for (col = 0; col < window.length; col++)
{
if ((col >= min_delay) && (col <= max_delay))
{
window.real_part[col] = parameters[col - min_delay];
}
else
{
window.real_part[col] = 0;
}
window.imag_part[col] = 0;
}
/* initialization of the local variables : AF_h */
AF_h.N_doppler = ker.N_doppler;
AF_h.N_delay = ker.N_delay;
AF_h.is_complex = TRUE;
mem_alloc_AF (&AF_h, NULL, NULL, NULL, NULL);
for (index = 0; index < AF_h.N_delay; index++)
{
AF_h.delay_bins[index] = -AF_h.N_delay / 2.0 + 1.0 + index;
}
/* computation of the AF of the window */
af (window, AF_h);
/* Warning : if ker.N_delay != ker.N_doppler,
one must add or suppress lines in this AF */
for (line = 0; line < ker.N_doppler; line++)
{
for (col = 0; col < ker.N_delay; col++)
{
index = idx (line, col, ker.N_delay);
ker.real_part[idx (line, col, ker.N_doppler)] =
sqrt (sqr (AF_h.real_part[index])
+ sqr (AF_h.imag_part[index]));
}
}
/* free memory !! */
mem_free_AF (&AF_h);
FREE (window.real_part);
FREE (window.imag_part);
}
break;
}
}
