kopia lustrzana https://github.com/fsphil/ssdv
264 wiersze
6.3 KiB
C
264 wiersze
6.3 KiB
C
|
|
/* SSDV - Slow Scan Digital Video */
|
|
/*=======================================================================*/
|
|
/* Copyright 2011-2016 Philip Heron <phil@sanslogic.co.uk> */
|
|
/* */
|
|
/* 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 <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include "ssdv.h"
|
|
|
|
void exit_usage()
|
|
{
|
|
fprintf(stderr,
|
|
"\n"
|
|
"Usage: ssdv [-e|-d] [-n] [-t <percentage>] [-c <callsign>] [-i <id>] [-q <level>] [-l <length>] [<in file>] [<out file>]\n"
|
|
"\n"
|
|
" -e Encode JPEG to SSDV packets.\n"
|
|
" -d Decode SSDV packets to JPEG.\n"
|
|
"\n"
|
|
" -n Encode packets with no FEC.\n"
|
|
" -t For testing, drops the specified percentage of packets while decoding.\n"
|
|
" -c Set the callign. Accepts A-Z 0-9 and space, up to 6 characters.\n"
|
|
" -i Set the image ID (0-255).\n"
|
|
" -q Set the JPEG quality level (0 to 7, defaults to 4).\n"
|
|
" -l Set packet length in bytes (max: 256, default 256).\n"
|
|
" -v Print data for each packet decoded.\n"
|
|
"\n"
|
|
"Packet Length\n"
|
|
"\n"
|
|
"The packet length must be specified for both encoding and decoding if not\n"
|
|
"the default 256 bytes. Smaller packets will increase overhead.\n"
|
|
"\n");
|
|
exit(-1);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int c, i;
|
|
FILE *fin = stdin;
|
|
FILE *fout = stdout;
|
|
char encode = -1;
|
|
char type = SSDV_TYPE_NORMAL;
|
|
int droptest = 0;
|
|
int verbose = 0;
|
|
int errors;
|
|
char callsign[7];
|
|
uint8_t image_id = 0;
|
|
int8_t quality = 4;
|
|
int pkt_length = SSDV_PKT_SIZE;
|
|
ssdv_t ssdv;
|
|
int skipped;
|
|
|
|
uint8_t pkt[SSDV_PKT_SIZE], b[128], *jpeg;
|
|
size_t jpeg_length;
|
|
|
|
callsign[0] = '\0';
|
|
|
|
opterr = 0;
|
|
while((c = getopt(argc, argv, "ednc:i:q:l:t:v")) != -1)
|
|
{
|
|
switch(c)
|
|
{
|
|
case 'e': encode = 1; break;
|
|
case 'd': encode = 0; break;
|
|
case 'n': type = SSDV_TYPE_NOFEC; break;
|
|
case 'c':
|
|
if(strlen(optarg) > 6)
|
|
{
|
|
fprintf(stderr, "Warning: callsign cropped to 6 characters.\n");
|
|
}
|
|
strncpy(callsign, optarg, 6);
|
|
callsign[6] = '\0';
|
|
break;
|
|
case 'i': image_id = atoi(optarg); break;
|
|
case 'q': quality = atoi(optarg); break;
|
|
case 'l': pkt_length = atoi(optarg); break;
|
|
case 't': droptest = atoi(optarg); break;
|
|
case 'v': verbose = 1; break;
|
|
case '?': exit_usage();
|
|
}
|
|
}
|
|
|
|
c = argc - optind;
|
|
if(c > 2) exit_usage();
|
|
|
|
for(i = 0; i < c; i++)
|
|
{
|
|
if(!strcmp(argv[optind + i], "-")) continue;
|
|
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
fin = fopen(argv[optind + i], "rb");
|
|
if(!fin)
|
|
{
|
|
fprintf(stderr, "Error opening '%s' for input:\n", argv[optind + i]);
|
|
perror("fopen");
|
|
return(-1);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
fout = fopen(argv[optind + i], "wb");
|
|
if(!fout)
|
|
{
|
|
fprintf(stderr, "Error opening '%s' for output:\n", argv[optind + i]);
|
|
perror("fopen");
|
|
return(-1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch(encode)
|
|
{
|
|
case 0: /* Decode */
|
|
|
|
if(droptest > 0) fprintf(stderr, "*** NOTE: Drop test enabled: %i ***\n", droptest);
|
|
|
|
if(ssdv_dec_init(&ssdv, pkt_length) != SSDV_OK)
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
jpeg_length = 1024 * 1024 * 4;
|
|
jpeg = malloc(jpeg_length);
|
|
ssdv_dec_set_buffer(&ssdv, jpeg, jpeg_length);
|
|
|
|
i = 0;
|
|
while(fread(pkt, pkt_length, 1, fin) > 0)
|
|
{
|
|
/* Drop % of packets */
|
|
if(droptest && (rand() / (RAND_MAX / 100) < droptest)) continue;
|
|
|
|
/* Test the packet is valid */
|
|
skipped = 0;
|
|
while((c = ssdv_dec_is_packet(pkt, pkt_length, &errors)) != 0)
|
|
{
|
|
/* Read 1 byte at a time until a new packet is found */
|
|
memmove(&pkt[0], &pkt[1], pkt_length - 1);
|
|
|
|
if(fread(&pkt[pkt_length - 1], 1, 1, fin) <= 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
skipped++;
|
|
}
|
|
|
|
/* No valid packet was found before EOF */
|
|
if(c != 0) break;
|
|
|
|
if(verbose)
|
|
{
|
|
ssdv_packet_info_t p;
|
|
|
|
if(skipped > 0)
|
|
{
|
|
fprintf(stderr, "Skipped %d bytes.\n", skipped);
|
|
}
|
|
|
|
ssdv_dec_header(&p, pkt);
|
|
fprintf(stderr, "Decoded image packet. Callsign: \"%s\", Image ID: %d, Resolution: %dx%d, Packet ID: %d (%d errors corrected)\n"
|
|
">> Type: %d, Quality: %d, EOI: %d, MCU Mode: %d, MCU Offset: %d, MCU ID: %d/%d\n",
|
|
p.callsign_s,
|
|
p.image_id,
|
|
p.width,
|
|
p.height,
|
|
p.packet_id,
|
|
errors,
|
|
p.type,
|
|
p.quality,
|
|
p.eoi,
|
|
p.mcu_mode,
|
|
p.mcu_offset,
|
|
p.mcu_id,
|
|
p.mcu_count
|
|
);
|
|
}
|
|
|
|
/* Feed it to the decoder */
|
|
ssdv_dec_feed(&ssdv, pkt);
|
|
i++;
|
|
}
|
|
|
|
ssdv_dec_get_jpeg(&ssdv, &jpeg, &jpeg_length);
|
|
fwrite(jpeg, 1, jpeg_length, fout);
|
|
free(jpeg);
|
|
|
|
fprintf(stderr, "Read %i packets\n", i);
|
|
|
|
break;
|
|
|
|
case 1: /* Encode */
|
|
|
|
if(ssdv_enc_init(&ssdv, type, callsign, image_id, quality, pkt_length) != SSDV_OK)
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
ssdv_enc_set_buffer(&ssdv, pkt);
|
|
|
|
i = 0;
|
|
|
|
while(1)
|
|
{
|
|
while((c = ssdv_enc_get_packet(&ssdv)) == SSDV_FEED_ME)
|
|
{
|
|
size_t r = fread(b, 1, 128, fin);
|
|
|
|
if(r <= 0)
|
|
{
|
|
fprintf(stderr, "Premature end of file\n");
|
|
break;
|
|
}
|
|
ssdv_enc_feed(&ssdv, b, r);
|
|
}
|
|
|
|
if(c == SSDV_EOI)
|
|
{
|
|
fprintf(stderr, "ssdv_enc_get_packet said EOI\n");
|
|
break;
|
|
}
|
|
else if(c != SSDV_OK)
|
|
{
|
|
fprintf(stderr, "ssdv_enc_get_packet failed: %i\n", c);
|
|
return(-1);
|
|
}
|
|
|
|
fwrite(pkt, 1, pkt_length, fout);
|
|
i++;
|
|
}
|
|
|
|
fprintf(stderr, "Wrote %i packets\n", i);
|
|
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "No mode specified.\n");
|
|
break;
|
|
}
|
|
|
|
if(fin != stdin) fclose(fin);
|
|
if(fout != stdout) fclose(fout);
|
|
|
|
return(0);
|
|
}
|
|
|