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.
 
 
 
 
 

346 lines
9.5 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, "", "", 1.0 };
  67. // Parse arguments
  68. int opt;
  69. while ((opt = getopt(argc, argv, "o:m:d:i:s:e:p:g:r")) != 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. case 'g':
  100. opts.gamma = atof(optarg);
  101. break;
  102. default:
  103. usage();
  104. }
  105. }
  106. // Process the files
  107. for (; optind < argc; optind++) {
  108. processAudio(argv[optind], &opts);
  109. }
  110. exit(0);
  111. }
  112. static int processAudio(char *filename, options_t *opts){
  113. // Image info struct
  114. image_t img;
  115. // Mapping between wedge value and channel ID
  116. static struct {
  117. char *id[7];
  118. char *name[7];
  119. } ch = {
  120. { "?", "1", "2", "3A", "4", "5", "3B" },
  121. { "unknown", "visble", "near-infrared", "mid-infrared", "thermal-infrared", "thermal-infrared", "mid-infrared" }
  122. };
  123. // Buffer for image channel
  124. char desc[60];
  125. // Parse file path
  126. char path[256], extension[32];
  127. strcpy(path, filename);
  128. strcpy(path, dirname(path));
  129. sscanf(basename(filename), "%[^.].%s", img.name, extension);
  130. if(opts->realtime){
  131. // Set output filename to current time when in realtime mode
  132. time_t t;
  133. time(&t);
  134. strncpy(img.name, ctime(&t), 24);
  135. // Init a row writer
  136. initWriter(opts, &img, IMG_WIDTH, MAX_HEIGHT, "Unprocessed realtime image", "r");
  137. }
  138. if(strcmp(extension, "png") == 0){
  139. // Read PNG into image buffer
  140. printf("Reading %s\n", filename);
  141. if(readRawImage(filename, img.prow, &img.nrow) == 0){
  142. fprintf(stderr, "Skipping %s\n", img.name);
  143. return 0;
  144. }
  145. }else{
  146. // Attempt to open the audio file
  147. if (initsnd(filename) == 0)
  148. exit(EPERM);
  149. // Build image
  150. // TODO: multithreading, would require some sort of input buffer
  151. for (img.nrow = 0; img.nrow < MAX_HEIGHT; img.nrow++) {
  152. // Allocate memory for this row
  153. img.prow[img.nrow] = (float *) malloc(sizeof(float) * 2150);
  154. // Write into memory and break the loop when there are no more samples to read
  155. if (getpixelrow(img.prow[img.nrow], img.nrow, &img.zenith, (img.nrow == 0)) == 0)
  156. break;
  157. if(opts->realtime) pushRow(img.prow[img.nrow], IMG_WIDTH);
  158. fprintf(stderr, "Row: %d\r", img.nrow);
  159. fflush(stderr);
  160. }
  161. // Close stream
  162. sf_close(audioFile);
  163. }
  164. if(opts->realtime) closeWriter();
  165. printf("Total rows: %d\n", img.nrow);
  166. // Fallback for detecting the zenith
  167. // TODO: encode metadata in raw images
  168. if(opts->map != NULL && opts->map[0] != '\0' && img.zenith == 0){
  169. fprintf(stderr, "Guessing zenith in image, map will most likely be misaligned.\n");
  170. img.zenith = img.nrow / 2;
  171. }
  172. // Calibrate
  173. img.chA = calibrate(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  174. img.chB = calibrate(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  175. printf("Channel A: %s (%s)\n", ch.id[img.chA], ch.name[img.chA]);
  176. printf("Channel B: %s (%s)\n", ch.id[img.chB], ch.name[img.chB]);
  177. // Denoise
  178. if(CONTAINS(opts->effects, Denoise)){
  179. denoise(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  180. denoise(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  181. }
  182. // Flip, for southbound passes
  183. if(CONTAINS(opts->effects, Flip_Image)){
  184. flipImage(&img, CH_WIDTH, CHA_OFFSET);
  185. flipImage(&img, CH_WIDTH, CHB_OFFSET);
  186. }
  187. // Temperature
  188. if (CONTAINS(opts->type, Temperature) && img.chB >= 4) {
  189. temperature(opts, &img, CHB_OFFSET, CH_WIDTH);
  190. ImageOut(opts, &img, CHB_OFFSET, CH_WIDTH, "Temperature", Temperature, (char *)TempPalette);
  191. }
  192. // MCIR
  193. if (CONTAINS(opts->type, MCIR))
  194. ImageOut(opts, &img, CHA_OFFSET, CH_WIDTH, "MCIR", MCIR, NULL);
  195. // Linear equalise
  196. if(CONTAINS(opts->effects, Linear_Equalise)){
  197. linearEnhance(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  198. linearEnhance(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  199. }
  200. // Histogram equalise
  201. if(CONTAINS(opts->effects, Histogram_Equalise)){
  202. histogramEqualise(img.prow, img.nrow, CHA_OFFSET, CH_WIDTH);
  203. histogramEqualise(img.prow, img.nrow, CHB_OFFSET, CH_WIDTH);
  204. }
  205. // Raw image
  206. if (CONTAINS(opts->type, Raw_Image)) {
  207. sprintf(desc, "%s (%s) & %s (%s)", ch.id[img.chA], ch.name[img.chA], ch.id[img.chB], ch.name[img.chB]);
  208. ImageOut(opts, &img, 0, IMG_WIDTH, desc, Raw_Image, NULL);
  209. }
  210. // Palette image
  211. if (CONTAINS(opts->type, Palleted)) {
  212. img.palette = opts->palette;
  213. strcpy(desc, "Palette composite");
  214. ImageOut(opts, &img, CHA_OFFSET, 909, desc, Palleted, NULL);
  215. }
  216. // Channel A
  217. if (CONTAINS(opts->type, Channel_A)) {
  218. sprintf(desc, "%s (%s)", ch.id[img.chA], ch.name[img.chA]);
  219. ImageOut(opts, &img, CHA_OFFSET, CH_WIDTH, desc, Channel_A, NULL);
  220. }
  221. // Channel B
  222. if (CONTAINS(opts->type, Channel_B)) {
  223. sprintf(desc, "%s (%s)", ch.id[img.chB], ch.name[img.chB]);
  224. ImageOut(opts, &img, CHB_OFFSET, CH_WIDTH, desc, Channel_B, NULL);
  225. }
  226. // Value distribution image
  227. if (CONTAINS(opts->type, Distribution))
  228. distrib(opts, &img, Distribution);
  229. return 1;
  230. }
  231. static int initsnd(char *filename) {
  232. SF_INFO infwav;
  233. int res;
  234. // Open audio file
  235. infwav.format = 0;
  236. audioFile = sf_open(filename, SFM_READ, &infwav);
  237. if (audioFile == NULL) {
  238. fprintf(stderr, "Could not open %s for reading\n", filename);
  239. return 0;
  240. }
  241. res = init_dsp(infwav.samplerate);
  242. printf("Input file: %s\n", filename);
  243. if(res < 0) {
  244. fprintf(stderr, "Input sample rate too low: %d\n", infwav.samplerate);
  245. return 0;
  246. }else if(res > 0) {
  247. fprintf(stderr, "Input sample rate too high: %d\n", infwav.samplerate);
  248. return 0;
  249. }
  250. printf("Input sample rate: %d\n", infwav.samplerate);
  251. channels = infwav.channels;
  252. return 1;
  253. }
  254. // Read samples from the audio file
  255. int getsample(float *sample, int nb) {
  256. if(channels == 1){
  257. return sf_read_float(audioFile, sample, nb);
  258. }else{
  259. /* Multi channel audio is encoded such as:
  260. * Ch1,Ch2,Ch1,Ch2,Ch1,Ch2
  261. */
  262. float buf[nb * channels]; // Something like BLKIN*2 could also be used
  263. int samples = sf_read_float(audioFile, buf, nb * channels);
  264. for(int i = 0; i < nb; i++) sample[i] = buf[i * channels];
  265. return samples / channels;
  266. }
  267. }
  268. static void usage(void) {
  269. fprintf(stderr,
  270. "Aptdec [options] audio files ...\n"
  271. "Options:\n"
  272. " -i [r|a|b|t|m|p] Output image\n"
  273. " r: Raw\n"
  274. " a: Channel A\n"
  275. " b: Channel B\n"
  276. " t: Temperature\n"
  277. " m: MCIR\n"
  278. " p: Paletted image\n"
  279. " -e [t|h|d|p|f|l] Effects\n"
  280. " t: Crop telemetry\n"
  281. " h: Histogram equalise\n"
  282. " d: Denoise\n"
  283. " p: Precipitation\n"
  284. " f: Flip image\n"
  285. " l: Linear equalise\n"
  286. " -o <path> Output filename\n"
  287. " -d <path> Image destination directory.\n"
  288. " -s [15-19] Satellite number\n"
  289. " -m <path> Map file\n"
  290. " -p <path> Path to palette\n"
  291. " -r Realtime decode\n"
  292. " -g Gamma adjustment (1.0 = off)\n"
  293. "\nRefer to the README for more infomation\n");
  294. exit(EINVAL);
  295. }