kopia lustrzana https://github.com/windytan/slowrx
134 wiersze
3.7 KiB
C
134 wiersze
3.7 KiB
C
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include <fftw3.h>
|
|
#include <gtk/gtk.h>
|
|
#include <alsa/asoundlib.h>
|
|
|
|
#include "common.h"
|
|
|
|
/* Find the slant angle of the sync singnal and adjust sample rate to cancel it out
|
|
* Length: number of PCM samples to process
|
|
* Mode: one of M1, M2, S1, S2, R72, R36 ...
|
|
* Rate: approximate sampling rate used
|
|
* Skip: pointer to variable where the skip amount will be returned
|
|
* returns adjusted sample rate
|
|
*
|
|
*/
|
|
double FindSync (guchar Mode, double Rate, int *Skip) {
|
|
|
|
int LineWidth = ModeSpec[Mode].LineTime / ModeSpec[Mode].SyncTime * 4;
|
|
int x,y;
|
|
int q, d, qMost, dMost;
|
|
gushort xAcc[700] = {0};
|
|
gushort lines[600][(MAXSLANT-MINSLANT)*2];
|
|
gushort cy, cx, Retries = 0;
|
|
gboolean SyncImg[700][630] = {{FALSE}};
|
|
double t=0, slantAngle, s;
|
|
double ConvoFilter[8] = { 1,1,1,1,-1,-1,-1,-1 };
|
|
double convd, maxconvd=0;
|
|
int xmax=0;
|
|
|
|
// Repeat until slant < 0.5° or until we give up
|
|
while (TRUE) {
|
|
|
|
// Draw the 2D sync signal at current rate
|
|
|
|
for (y=0; y<ModeSpec[Mode].NumLines; y++) {
|
|
for (x=0; x<LineWidth; x++) {
|
|
t = (y + 1.0*x/LineWidth) * ModeSpec[Mode].LineTime;
|
|
SyncImg[x][y] = HasSync[ (int)( t * Rate / 13.0) ];
|
|
}
|
|
}
|
|
|
|
/** Linear Hough transform **/
|
|
|
|
dMost = qMost = 0;
|
|
memset(lines, 0, sizeof(lines[0][0]) * (MAXSLANT-MINSLANT)*2 * 600);
|
|
|
|
// Find white pixels
|
|
for (cy = 0; cy < ModeSpec[Mode].NumLines; cy++) {
|
|
for (cx = 0; cx < LineWidth; cx++) {
|
|
if (SyncImg[cx][cy]) {
|
|
|
|
// Slant angles to consider
|
|
for (q = MINSLANT*2; q < MAXSLANT*2; q ++) {
|
|
|
|
// Line accumulator
|
|
d = LineWidth + round( -cx * sin(deg2rad(q/2.0)) + cy * cos(deg2rad(q/2.0)) );
|
|
if (d > 0 && d < LineWidth) {
|
|
lines[d][q-MINSLANT*2] ++;
|
|
if (lines[d][q-MINSLANT*2] > lines[dMost][qMost-MINSLANT*2]) {
|
|
dMost = d;
|
|
qMost = q;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( qMost == 0) {
|
|
printf(" no sync signal; giving up\n");
|
|
break;
|
|
}
|
|
|
|
slantAngle = qMost / 2.0;
|
|
|
|
printf(" %.1f° (d=%d) @ %.1f Hz", slantAngle, dMost, Rate);
|
|
|
|
// Adjust sample rate
|
|
Rate += tan(deg2rad(90 - slantAngle)) / LineWidth * Rate;
|
|
|
|
if (slantAngle > 89 && slantAngle < 91) {
|
|
printf(" slant OK :)\n");
|
|
break;
|
|
} else if (Retries == 3) {
|
|
printf(" still slanted; giving up\n");
|
|
Rate = 44100;
|
|
printf(" -> 44100\n");
|
|
break;
|
|
}
|
|
printf(" -> %.1f recalculating\n", Rate);
|
|
Retries ++;
|
|
}
|
|
|
|
// accumulate a 1-dim array of the position of the sync pulse
|
|
memset(xAcc, 0, sizeof(xAcc[0]) * 700);
|
|
for (y=0; y<ModeSpec[Mode].NumLines; y++) {
|
|
for (x=0; x<700; x++) {
|
|
t = y * ModeSpec[Mode].LineTime + x/700.0 * ModeSpec[Mode].LineTime;
|
|
xAcc[x] += HasSync[ (int)(t / (13.0/44100) * Rate/44100) ];
|
|
}
|
|
}
|
|
|
|
// find falling edge of the sync pulse by 8-point convolution
|
|
for (x=0;x<700-8;x++) {
|
|
convd = 0;
|
|
for (int i=0;i<8;i++) convd += xAcc[x+i] * ConvoFilter[i];
|
|
if (convd > maxconvd) {
|
|
maxconvd = convd;
|
|
xmax = x+4;
|
|
}
|
|
}
|
|
|
|
// If pulse is near the right edge of the image, it just probably slipped
|
|
// out the left edge
|
|
if (xmax > 350) xmax -= 350;
|
|
|
|
// Skip until the start of the line
|
|
s = xmax / 700.0 * ModeSpec[Mode].LineTime - ModeSpec[Mode].SyncTime;
|
|
|
|
// (Scottie modes don't start lines with sync)
|
|
if (Mode == S1 || Mode == S2 || Mode == SDX)
|
|
s = s - ModeSpec[Mode].PixelTime * ModeSpec[Mode].ImgWidth / 2.0
|
|
+ ModeSpec[Mode].PorchTime * 2;
|
|
|
|
*Skip = s * Rate;
|
|
|
|
printf("will return %.2f\n",Rate);
|
|
|
|
return (Rate);
|
|
|
|
}
|