185 lines
5.0 KiB
C
185 lines
5.0 KiB
C
/* VCR test image generator
|
|
*
|
|
* (C) 2017 by Andreas Eversberg <jolly@eversberg.eu>
|
|
* All Rights Reserved
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include "../libsample/sample.h"
|
|
#include "vcr.h"
|
|
|
|
/* test ID of calibration part:
|
|
*
|
|
* 1. line: ID of 48 Bits in 52 uS
|
|
* 2. line: 50% Gray
|
|
* 3. line: 50% Gray +- 25% deviation, frequency 0 Hz
|
|
* 4. line: 50% Gray +- 12.5% deviation, frequency 0 Hz
|
|
* 5. and 6. line: as line 3 and 4, but frequnency 0.2 MHz
|
|
* each next two lines as above, but increments frequency by 0.2
|
|
* 63. and 64. line: the incement reaches 6 MHz
|
|
*/
|
|
#define TEST_ID "VHS V1"
|
|
|
|
/* create cosine ramp, so that the bandwidth is not higher than 2 * width of the ramp(0..1) */
|
|
static inline double ramp(double x)
|
|
{
|
|
return 0.5 - 0.5 * cos(x * M_PI);
|
|
}
|
|
|
|
int vcr_gen_line(sample_t *sample, double x, double samplerate, sample_t *color_u, sample_t *color_v, int v_polarity, double line_start, double line_end, int line)
|
|
{
|
|
double step = 1.0 / samplerate;
|
|
int i = 0;
|
|
double Y, Y2, U, V, frequency, colorphase, saturation;
|
|
double render_end, n, width;
|
|
int b;
|
|
|
|
/* skip x to line_start */
|
|
while (x < line_start && x < line_end) {
|
|
i++;
|
|
x += step;
|
|
}
|
|
if (x >= line_end)
|
|
return i;
|
|
|
|
/* select test pattern */
|
|
switch (line / 32) {
|
|
case 0:
|
|
case 1:
|
|
/* frequency test
|
|
*
|
|
* show frequencies from 0.5 MHz to 3.5 MHz */
|
|
frequency = (double)(line & 63) / 63.0 * 3000000.0 + 500000.0;
|
|
while (x < line_end) {
|
|
Y = 1.0 - (line_end - x) / (line_end - line_start);
|
|
sample[i++] = 0.5 + Y * 0.5 * sin(x * frequency * 2 * M_PI);
|
|
x += step;
|
|
}
|
|
break;
|
|
case 2:
|
|
/* level test
|
|
*
|
|
* show levels from 0 to 100% luminance */
|
|
Y = (double)(line & 31) / 31.0;
|
|
while (x < line_end) {
|
|
sample[i++] = Y;
|
|
x += step;
|
|
}
|
|
break;
|
|
case 3:
|
|
/* edge test
|
|
*
|
|
* show edges with 0.5 MHz to 3.5 MHz frequency */
|
|
for (n = 0.0; n < 0.99; n += 0.1) {
|
|
frequency = (double)(line & 31) / 31.0 * 3000000.0 + 500000.0;
|
|
width = 1.0 / frequency / 2.0; /* half wave length */
|
|
/* low level before ramping up */
|
|
Y = 0.5 - (n + 0.1) / 2.0;
|
|
Y2 = 1.0 - Y;
|
|
render_end = line_start + (line_end - line_start) / 40.0 * (40.0 * n + 1) - width / 2.0;
|
|
while (x < render_end) {
|
|
sample[i++] = Y;
|
|
x += step;
|
|
}
|
|
/* ramp up */
|
|
render_end += width;
|
|
while (x < render_end) {
|
|
sample[i++] = ramp((render_end - x) / width) * (Y - Y2) + Y2;
|
|
x += step;
|
|
}
|
|
/* high level before ramping down */
|
|
render_end = line_start + (line_end - line_start) / 40.0 * (40.0 * n + 3) - width / 2.0;
|
|
while (x < render_end) {
|
|
sample[i++] = Y2;
|
|
x += step;
|
|
}
|
|
/* ramp down */
|
|
render_end += width;
|
|
while (x < render_end) {
|
|
sample[i++] = ramp((render_end - x) / width) * (Y2 - Y) + Y;
|
|
x += step;
|
|
}
|
|
/* low level after ramping down */
|
|
render_end = line_start + (line_end - line_start) / 40.0 * (40.0 * n + 4);
|
|
while (x < render_end) {
|
|
sample[i++] = Y;
|
|
x += step;
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
/* color test
|
|
*
|
|
* show color from 0 to 100% saturation */
|
|
Y = (1.0 - 5.0 / 7.0) * 0.75;
|
|
saturation = (double)(line & 63) / 63.0;
|
|
if (v_polarity < 0)
|
|
colorphase = (360.0 - 103.5) / 180.0 * M_PI;
|
|
else
|
|
colorphase = 103.5 / 180.0 * M_PI;
|
|
U = cos(colorphase) * saturation * 0.474 / 2.0;
|
|
V = sin(colorphase) * saturation * 0.474 / 2.0;
|
|
while (x < line_end) {
|
|
sample[i++] = Y;
|
|
color_u[i] = U;
|
|
color_v[i] = V;
|
|
x += step;
|
|
}
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
/* calibration signal
|
|
*
|
|
* this signal is used to calibrate the frequency response of the de-emphasis
|
|
*/
|
|
if ((line & 63) == 0) {
|
|
/* generate identification line to be detected by the decoder */
|
|
for (b = 0; b < 48; b++) {
|
|
render_end = line_start + (line_end - line_start) / 48.0 * (double)(b + 1);
|
|
Y = (TEST_ID[b / 8] >> (b & 7)) & 1;
|
|
while (x < render_end) {
|
|
sample[i++] = Y;
|
|
x += step;
|
|
}
|
|
}
|
|
} else if ((line & 63) == 1) {
|
|
/* generate zero level (50% brightness) */
|
|
while (x < line_end) {
|
|
sample[i++] = 0.5;
|
|
x += step;
|
|
}
|
|
} else {
|
|
/* each pair of lines: upper uses 50% deviation, lower uses 25% deviation */
|
|
if ((line & 1) == 0)
|
|
Y = 0.5;
|
|
else
|
|
Y = 0.25;
|
|
/* frequency from 0 - 6 MHz in 31 steps (each 0.2 MHz) */
|
|
frequency = (double)(((line & 63) - 2) / 2) * 200000.0;
|
|
while (x < line_end) {
|
|
sample[i++] = 0.5 + Y * 0.5 * cos(x * frequency * 2 * M_PI);
|
|
x += step;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return i;
|
|
}
|