You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

342 regels
9.4 KiB

  1. /*
  2. * This file is part of Aptdec.
  3. * Copyright (c) 2004-2009 Thierry Leconte (F4DWV), Xerbo (xerbo@protonmail.com) 2019-2020
  4. *
  5. * Aptdec is free software: you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation, either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program. If not, see <https://www.gnu.org/licenses/>.
  17. *
  18. */
  19. #include <stdlib.h>
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <getopt.h>
  23. #include <libgen.h>
  24. #include <math.h>
  25. #include <sndfile.h>
  26. #include <errno.h>
  27. #include <time.h>
  28. #include "common.h"
  29. #include "offsets.h"
  30. // DSP
  31. extern int init_dsp(double F);
  32. extern int getpixelrow(float *pixelv, int nrow, int *zenith, int reset);
  33. // I/O
  34. extern int readRawImage(char *filename, float **prow, int *nrow);
  35. extern int ImageOut(options_t *opts, image_t *img, int offset, int width, char *desc, char *chid, char *palette);
  36. extern int initWriter(options_t *opts, image_t *img, int width, int height, char *desc, char *chid);
  37. extern void pushRow(float *row, int width);
  38. extern void closeWriter();
  39. // Image functions
  40. extern int calibrate(float **prow, int nrow, int offset, int width);
  41. extern void histogramEqualise(float **prow, int nrow, int offset, int width);
  42. extern void linearEnhance(float **prow, int nrow, int offset, int width);
  43. extern void temperature(options_t *opts, image_t *img, int offset, int width);
  44. extern void denoise(float **prow, int nrow, int offset, int width);
  45. extern void distrib(options_t *opts, image_t *img, char *chid);
  46. extern void flipImage(image_t *img, int width, int offset);
  47. // Palettes
  48. extern char GviPalette[256*3];
  49. extern char TempPalette[256*3];
  50. // Audio file
  51. static SNDFILE *audioFile;
  52. // Number of channels in audio file
  53. int channels = 1;
  54. // Function declarations
  55. static int initsnd(char *filename);
  56. int getsample(float *sample, int nb);
  57. static int processAudio(char *filename, options_t *opts);
  58. static void usage(void);
  59. int main(int argc, char **argv) {
  60. fprintf(stderr, VERSION"\n");
  61. // Check if there are actually any input files
  62. if(argc == optind || argc == 1){
  63. fprintf(stderr, "No input files provided.\n");
  64. usage();
  65. }
  66. options_t opts = { "r", "", 19, "", ".", 0, "" };
  67. // Parse arguments
  68. int opt;
  69. while ((opt = getopt(argc, argv, "o:m:d:i:s:e:rp:")) != EOF) {
  70. switch (opt) {
  71. case 'd':
  72. opts.path = optarg;
  73. break;
  74. case 'm':
  75. opts.map = optarg;
  76. break;
  77. case 'i':
  78. opts.type = optarg;
  79. break;
  80. case 's':
  81. opts.satnum = atoi(optarg);
  82. if(opts.satnum < 15 || opts.satnum > 19){
  83. fprintf(stderr, "Invalid satellite number, it must be the range 15-19\n");
  84. exit(EPERM);
  85. }
  86. break;
  87. case 'e':
  88. opts.effects = optarg;
  89. break;
  90. case 'r':
  91. opts.realtime = 1;
  92. break;
  93. case 'o':
  94. opts.filename = optarg;
  95. break;
  96. case 'p':
  97. opts.palette = optarg;
  98. break;
  99. default:
  100. usage();
  101. }
  102. }
  103. // Process the files
  104. for (; optind < argc; optind++) {
  105. processAudio(argv[optind], &opts);
  106. }
  107. exit(0);
  108. }
  109. static int processAudio(char *filename, options_t *opts){
  110. // Image info struct
  111. image_t img;
  112. // Mapping between wedge value and channel ID
  113. static struct {
  114. char *id[7];
  115. char *name[7];
  116. } ch = {
  117. { "?", "1", "2", "3A", "4", "5", "3B" },
  118. { "unknown", "visble", "near-infrared", "mid-infrared", "thermal-infrared", "thermal-infrared", "mid-infrared" }
  119. };
  120. // Buffer for image channel
  121. char desc[60];
  122. // Parse file path
  123. char path[256], extension[32];
  124. strcpy(path, filename);
  125. strcpy(path, dirname(path));
  126. sscanf(basename(filename), "%[^.].%s", img.name, extension);
  127. if(opts->realtime){
  128. // Set output filename to current time when in realtime mode
  129. time_t t;
  130. time(&t);
  131. strncpy(img.name, ctime(&t), 24);
  132. // Init a row writer
  133. initWriter(opts, &img, IMG_WIDTH, MAX_HEIGHT, "Unprocessed realtime image", "r");
  134. }
  135. if(strcmp(extension, "png") == 0){
  136. // Read PNG into image buffer
  137. printf("Reading %s\n", filename);
  138. if(readRawImage(filename, img.prow, &img.nrow) == 0){
  139. fprintf(stderr, "Skipping %s\n", img.name);
  140. return 0;
  141. }
  142. }else{
  143. // Attempt to open the audio file
  144. if (initsnd(filename) == 0)
  145. exit(EPERM);
  146. // Build image
  147. // TODO: multithreading, would require some sort of input buffer
  148. for (img.nrow = 0; img.nrow < MAX_HEIGHT; img.nrow++) {
  149. // Allocate memory for this row
  150. img.prow[img.nrow] = (float *) malloc(sizeof(float) * 2150);
  151. // Write into memory and break the loop when there are no more samples to read
  152. if (getpixelrow(img.prow[img.nrow], img.nrow, &img.zenith, (img.nrow == 0)) == 0)
  153. break;
  154. if(opts->realtime) pushRow(img.prow[img.nrow], IMG_WIDTH);
  155. fprintf(stderr, "Row: %d\r", img.nrow);
  156. fflush(stderr);
  157. }
  158. // Close stream
  159. sf_close(audioFile);
  160. }
  161. if(opts->realtime) closeWriter();
  162. printf("Total rows: %d\n", img.nrow);
  163. // Fallback for detecting the zenith
  164. // TODO: encode metadata in raw images
  165. if(opts->map != NULL && opts->map[0] != '\0' && img.zenith == 0){
  166. fprintf(stderr, "Guessing zenith in image, map will most likely be misaligned.\n");
  167. img.zenith = img.nrow / 2;
  168. }
  169. // Calibrate
  170. img.chA = calibrate(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  171. img.chB = calibrate(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  172. printf("Channel A: %s (%s)\n", ch.id[img.chA], ch.name[img.chA]);
  173. printf("Channel B: %s (%s)\n", ch.id[img.chB], ch.name[img.chB]);
  174. // Denoise
  175. if(CONTAINS(opts->effects, Denoise)){
  176. denoise(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  177. denoise(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  178. }
  179. // Flip, for southbound passes
  180. if(CONTAINS(opts->effects, Flip_Image)){
  181. flipImage(&img, CH_WIDTH, CHA_OFFSET);
  182. flipImage(&img, CH_WIDTH, CHB_OFFSET);
  183. }
  184. // Temperature
  185. if (CONTAINS(opts->type, Temperature) && img.chB >= 4) {
  186. temperature(opts, &img, CHB_OFFSET, CH_WIDTH);
  187. ImageOut(opts, &img, CHB_OFFSET, CH_WIDTH, "Temperature", Temperature, (char *)TempPalette);
  188. }
  189. // MCIR
  190. if (CONTAINS(opts->type, MCIR))
  191. ImageOut(opts, &img, CHA_OFFSET, CH_WIDTH, "MCIR", MCIR, NULL);
  192. // Linear equalise
  193. if(CONTAINS(opts->effects, Linear_Equalise)){
  194. linearEnhance(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  195. linearEnhance(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  196. }
  197. // Histogram equalise
  198. if(CONTAINS(opts->effects, Histogram_Equalise)){
  199. histogramEqualise(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  200. histogramEqualise(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  201. }
  202. // Raw image
  203. if (CONTAINS(opts->type, Raw_Image)) {
  204. sprintf(desc, "%s (%s) & %s (%s)", ch.id[img.chA], ch.name[img.chA], ch.id[img.chB], ch.name[img.chB]);
  205. ImageOut(opts, &img, 0, IMG_WIDTH, desc, Raw_Image, NULL);
  206. }
  207. // Palette image
  208. if (CONTAINS(opts->type, Palleted)) {
  209. img.palette = opts->palette;
  210. strcpy(desc, "Palette composite");
  211. ImageOut(opts, &img, CHA_OFFSET, 909, desc, Palleted, NULL);
  212. }
  213. // Channel A
  214. if (CONTAINS(opts->type, Channel_A)) {
  215. sprintf(desc, "%s (%s)", ch.id[img.chA], ch.name[img.chA]);
  216. ImageOut(opts, &img, CHA_OFFSET, CH_WIDTH, desc, Channel_A, NULL);
  217. }
  218. // Channel B
  219. if (CONTAINS(opts->type, Channel_B)) {
  220. sprintf(desc, "%s (%s)", ch.id[img.chB], ch.name[img.chB]);
  221. ImageOut(opts, &img, CHB_OFFSET, CH_WIDTH, desc, Channel_B, NULL);
  222. }
  223. // Value distribution image
  224. if (CONTAINS(opts->type, Distribution))
  225. distrib(opts, &img, Distribution);
  226. return 1;
  227. }
  228. static int initsnd(char *filename) {
  229. SF_INFO infwav;
  230. int res;
  231. // Open audio file
  232. infwav.format = 0;
  233. audioFile = sf_open(filename, SFM_READ, &infwav);
  234. if (audioFile == NULL) {
  235. fprintf(stderr, "Could not open %s for reading\n", filename);
  236. return 0;
  237. }
  238. res = init_dsp(infwav.samplerate);
  239. printf("Input file: %s\n", filename);
  240. if(res < 0) {
  241. fprintf(stderr, "Input sample rate too low: %d\n", infwav.samplerate);
  242. return 0;
  243. }else if(res > 0) {
  244. fprintf(stderr, "Input sample rate too high: %d\n", infwav.samplerate);
  245. return 0;
  246. }
  247. printf("Input sample rate: %d\n", infwav.samplerate);
  248. channels = infwav.channels;
  249. return 1;
  250. }
  251. // Read samples from the wave file
  252. int getsample(float *sample, int nb) {
  253. if(channels == 1){
  254. return sf_read_float(audioFile, sample, nb);
  255. }else{
  256. /* Multi channel audio is encoded such as:
  257. * Ch1,Ch2,Ch1,Ch2,Ch1,Ch2
  258. */
  259. float buf[nb * channels]; // Something like BLKIN*2 could also be used
  260. int samples = sf_read_float(audioFile, buf, nb * channels);
  261. for(int i = 0; i < nb; i++) sample[i] = buf[i * channels];
  262. return samples / channels;
  263. }
  264. }
  265. static void usage(void) {
  266. fprintf(stderr,
  267. "Aptdec [options] audio files ...\n"
  268. "Options:\n"
  269. " -e [t|h|d|p|f|l] Effects\n"
  270. " t: Crop telemetry\n"
  271. " h: Histogram equalise\n"
  272. " d: Denoise\n"
  273. " p: Precipitation\n"
  274. " f: Flip image\n"
  275. " l: Linear equalise\n"
  276. " -i [r|a|b|c|t|m|p] Output image\n"
  277. " r: Raw\n"
  278. " a: Channel A\n"
  279. " b: Channel B\n"
  280. " t: Temperature\n"
  281. " m: MCIR\n"
  282. " p: Paletted image\n"
  283. " -d <dir> Image destination directory.\n"
  284. " -o <name> Output filename\n"
  285. " -s [15-19] Satellite number\n"
  286. " -m <file> Map file\n"
  287. " -r Realtime decode\n"
  288. " -p Path to palette\n"
  289. "\nRefer to the README for more infomation\n");
  290. exit(EINVAL);
  291. }