/*
* sstvtx - Martin 1 mode SSTV generator
*
* $Id: sstvtx.c 82 2008-07-30 12:13:59Z dj1yfk $
*
* Copyright (c) 2008 Fabian Kurz, DJ1YFK
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
/*
* Hacked by Steve Randall to speed audio file generation up (and bug fix)
* Compile with: gcc sstvtxx.c -lsndfile -ljpeg -lrt -lm -o sstvtx
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sndfile.h>
#include "jpeglib.h"
#include "jerror.h"
#include <setjmp.h>
#include <unistd.h>
#include <time.h> // timing profile debug
struct timespec tp[8]; // timing profile debug
int clock_gettime(clockid_t clk_id, struct timespec *tp);
#define PIXEL 1
#define SYNC 0
#define SYNC_FREQ 1200.0
#define BLACK_FREQ 1500.0
#define WHITE_FREQ 2300.0
#define OUT_LEVEL 25000.0 // peak sound level
#define TWO_PI 6.28318530717958647693
#define SAMPLE_RATE 48000 // sound file sanples per sec
#define PIX_WIDTH 320
#define PIX_HEIGHT 256
/* JPEG input image will be read into this array; picture size 320x256,
* RGB components in separate rows */
static unsigned char pic[PIX_WIDTH][PIX_HEIGHT * 3];
typedef struct {
int samplerate;
double sync_len; // length of synch impulse in sec
double pix_len; // length of normal pixel in sec
int x_width;
double end_phase; // ending phase of pixel
double next_time; // time (in sec) to next sample
char *infile;
char *outfile;
} SSTV;
void die(char *err);
int read_JPEG_file (char *filename);
int tx_sync(SNDFILE *snd, SSTV *sstv);
int tx_pixel(unsigned char p, SNDFILE *snd, SSTV *sstv, int typ);
void help (void);
long get_ms(int os)
{
long ta;
long tb;
ta = tp[os].tv_sec * 1000l; // convert secs to ms;
ta += (tp[os].tv_nsec) / 1000000l; // add in usec converted to ms
os++;
tb = tp[os].tv_sec * 1000l; // convert secs to ms;
tb += (tp[os].tv_nsec) / 1000000l; // add in usec converted to ms
return(tb - ta);
}
void dump_times(void)
{
fprintf(stderr,"time 0 to 1 %ld ms\n",get_ms(0));
fprintf(stderr,"time 1 to 2 %ld ms\n",get_ms(1));
fprintf(stderr,"time 2 to 3 %ld ms\n",get_ms(2));
}
int main (int argc, char **argv) {
int x,y;
SSTV sstv;
SNDFILE *out;
SF_INFO out_info;
sstv.samplerate = SAMPLE_RATE;
sstv.x_width = PIX_WIDTH;
/* total pixels = 320 * 256 * 3 = 245760
total sync = 256 * 5ms = 1.28 sec
pixel length, in samples, total pixels 245760, 114s - 1.28s sync
results in 0.45865885... ms / pixel */
sstv.pix_len = 0.00045865885416666666;
sstv.sync_len = 0.005; // sync pulse length 5ms
sstv.end_phase = 0.0;
sstv.next_time = 1.0 / (double)SAMPLE_RATE;
sstv.outfile = "out.wav";
sstv.infile = "input.jpg";
clock_gettime(CLOCK_REALTIME, &tp[0]);
while ((x = getopt(argc, argv, "s:i:o:x:h")) != -1) {
switch (x) {
case 's':
sstv.samplerate = atoi(optarg);
break;
case 'i':
sstv.infile = optarg;
break;
case 'o':
sstv.outfile = optarg;
break;
case 'h':
help();
break;
case 'x':
sstv.x_width= atoi(optarg);
break;
}
}
out_info.samplerate = sstv.samplerate;
out_info.channels = 1;
out_info.format = SF_FORMAT_WAV|SF_FORMAT_PCM_16;
if ((out = sf_open(sstv.outfile, SFM_WRITE, &out_info)) == NULL) {
die("Opening soundfile failed.");
}
clock_gettime(CLOCK_REALTIME, &tp[1]);
read_JPEG_file(sstv.infile);
clock_gettime(CLOCK_REALTIME, &tp[2]);
for (y=0; y < (PIX_HEIGHT * 3); y++)
{
for (x = 0; x < sstv.x_width; x++)
{ // generate the wav file
tx_pixel(pic[x][y], out, &sstv, PIXEL);
}
if (!(y % 3))
{ // insert sync pulse after line generated
tx_pixel(0, out, &sstv, SYNC);
}
}
clock_gettime(CLOCK_REALTIME, &tp[3]);
sf_close(out);
dump_times();
return 0;
}
void die(char *err) {
fprintf(stderr, "Error: %s\n", err);
exit(EXIT_FAILURE);
}
int read_JPEG_file (char *filename) {
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE *infile;
JSAMPARRAY buffer;
int row_stride;
int i, row=0;
if ((infile = fopen(filename, "rb")) == NULL) {
die("Can't open input file.");
}
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
jpeg_stdio_src(&cinfo, infile);
(void) jpeg_read_header(&cinfo, TRUE);
(void) jpeg_start_decompress(&cinfo);
if (cinfo.output_width != PIX_WIDTH || cinfo.output_height != PIX_HEIGHT) {
die ("Input file format wrong. Need 320x256.");
}
row_stride = cinfo.output_width * cinfo.output_components;
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
while (cinfo.output_scanline < cinfo.output_height) {
(void) jpeg_read_scanlines(&cinfo, buffer, 1);
/* each line in buffer: R,G,B,R,G,B -> put to array RRR/GGG/BBB */
for (i=0; i < cinfo.output_width; i++) {
pic[i][row] = buffer[0][3*i];
pic[i][row+1] = buffer[0][3*i+1];
pic[i][row+2] = buffer[0][3*i+2];
}
row+=3;
}
(void) jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
fclose(infile);
return 0;
}
// this routines generates the sound samples representing a single pixel
// p contains the pixel intensity
int tx_pixel(unsigned char p, SNDFILE *snd, SSTV *sstv, int typ) {
double freq; // claculated frequency of sample (in rads/sec)
short int buf[500]; // buffer for audio samples
int j; // count of samples created
double len; // duration of sample to be created
double end_phase; // phase at sample end
double ph_inc; // phase increment (between audio samples)
double phase; // current phase
// claculate the frequency associated with the pixel
// normalize char to frequency range of 1500-2300Hz
if (typ == PIXEL) {
freq = TWO_PI * (BLACK_FREQ + (((WHITE_FREQ - BLACK_FREQ) * (double)p)/255.0));
len = sstv->pix_len;
}
else {
freq = TWO_PI * SYNC_FREQ;
len = sstv->sync_len;
}
// calculate the phase at the end of the pixel/sync
end_phase = sstv->end_phase + (freq * len);
// calculate phase increment between audio samples
ph_inc = (freq / sstv->samplerate);
// calculate phase at initial sample in pixel/sync
phase = sstv->end_phase + (freq) * sstv->next_time;
j = 0;
while (phase < end_phase)
{
buf[j++] = (short int) (OUT_LEVEL * sin(phase));
phase += ph_inc;
}
// claculate time next sample is beyond pixel/sync end
sstv->next_time = (phase - end_phase) / (freq);
// loop exits with j containing the number of samples written
while (end_phase > TWO_PI) { // phase can increment several cycles during sync
end_phase -= TWO_PI; // keep in reasonable bounds
}
sstv->end_phase = end_phase; // new end_phase
if (sf_write_short(snd, buf, j) != j) {
die("Writing Pixel failed.");
}
return 0;
}
void help (void) {
printf("sstvtx - generates a SSTV Martin 1 image\n");
printf("\n");
printf("Usage: sstvtx -i input.jpg -o output.wav -x x_width -s samplerate\n");
printf("\n");
printf("Written by Fabian Kurz, DJ1YFK; http://fkurz.net/ham/stuff.html#sstvtx\n\n");
exit(EXIT_SUCCESS);
}
