hms
/
aptdec
espelhamento de https://github.com/Xerbo/aptdec
1
0
Fork 0
Código Issues 0 Versões 7 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
65 Commits
2 Branches
36 MiB
 
 
 
 
 
Tag: 2a34f8879b
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 2a34f8879b
${ noResults }
aptdec/main.c

405 linhas
11 KiB
Original Anotar Histórico 

  1. /*

  2.  *  Aptdec

  3.  *  Copyright (c) 2004-2005 by Thierry Leconte (F4DWV)

  4.  *

  5.  *      $Id$

  6.  *

  7.  *   This library is free software; you can redistribute it and/or modify

  8.  *   it under the terms of the GNU Library General Public License as

  9.  *   published by the Free Software Foundation; either version 2 of

  10.  *   the License, or (at your option) any later version.

  11.  *

  12.  *   This program is distributed in the hope that it will be useful,

  13.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  15.  *   GNU Library General Public License for more details.

  16.  *

  17.  *   You should have received a copy of the GNU Library General Public

  18.  *   License along with this library; if not, write to the Free Software

  19.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  20.  *

  21.  */

  22. 

  23. #include <stdlib.h>

  24. #include <stdio.h>

  25. #include <string.h>

  26. #include <getopt.h>

  27. 

  28. #ifdef WIN32

  29. #include "w32util.h"

  30. #else

  31. #include <libgen.h>

  32. #endif

  33. 

  34. #include <sndfile.h>

  35. #include <png.h>

  36. 

  37. #include "version.h"

  38. #include "offsets.h"

  39. 

  40. #include "temppalette.h"

  41. #include "gvipalette.h"

  42. 

  43. extern int getpixelrow(float *pixelv);

  44. extern int init_dsp(double F);;

  45. 

  46. static SNDFILE *inwav;

  47. 

  48. static int initsnd(char *filename) {

  49.     SF_INFO infwav;

  50.     int	res;

  51. 

  52. 	/* open wav input file */

  53.     infwav.format = 0;

  54.     inwav = sf_open(filename, SFM_READ, &infwav);

  55.     if (inwav == NULL) {

  56. 		fprintf(stderr, "Could not open %s for reading\n", filename);

  57. 		return (1);

  58.     }

  59. 

  60.     res = init_dsp(infwav.samplerate);

  61.     if(res < 0) {

  62. 		fprintf(stderr, "Sample rate too low: %d\n", infwav.samplerate);

  63. 		return (1);

  64.     }

  65.     if(res > 0) {

  66. 		fprintf(stderr, "Sample rate too hight: %d\n", infwav.samplerate);

  67. 		return (1);

  68.     }

  69.     fprintf(stderr, "Sample rate: %d\n", infwav.samplerate);

  70. 

  71.     if (infwav.channels != 1) {

  72. 		fprintf(stderr, "Too many channels in input file: %d\n", infwav.channels);

  73. 		return (1);

  74.     }

  75. 

  76.     return (0);

  77. }

  78. 

  79. int getsample(float *sample, int nb) {

  80.     return (sf_read_float(inwav, sample, nb));

  81. }

  82. 

  83. static png_text text_ptr[] = {

  84.     {PNG_TEXT_COMPRESSION_NONE, "Software", version, sizeof(version)},

  85.     {PNG_TEXT_COMPRESSION_NONE, "Channel", NULL, 0},

  86.     {PNG_TEXT_COMPRESSION_NONE, "Description", "NOAA POES satellite image", 25}

  87. };

  88. 

  89. static int ImageOut(char *filename, char *chid, float **prow, int nrow, int width, int offset, png_color *palette) {

  90.     FILE *pngfile;

  91.     png_infop info_ptr;

  92.     png_structp png_ptr;

  93.     int n;

  94. 

  95. 	/* init png lib */

  96.     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  97.     if (!png_ptr) {

  98. 		fprintf(stderr, "Could not create a PNG write struct\n");

  99. 		return (1);

  100.     }

  101. 

  102.     info_ptr = png_create_info_struct(png_ptr);

  103.     if (!info_ptr) {

  104. 		png_destroy_write_struct(&png_ptr, (png_infopp) NULL);

  105. 		fprintf(stderr, "Could not create a PNG info struct\n");

  106. 		return (1);

  107.     }

  108. 

  109.     if(palette == NULL) {

  110. 		/* greyscale */

  111.     	png_set_IHDR(png_ptr, info_ptr, width, nrow,

  112. 					 8, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE,

  113. 				 	 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  114.     } else {

  115. 		/* palette color mage */

  116.     	png_set_IHDR(png_ptr, info_ptr, width, nrow,

  117. 		 			 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,

  118. 		 			 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  119. 		png_set_PLTE(png_ptr, info_ptr, palette, 256);

  120.     }

  121. 

  122.     text_ptr[1].text = chid;

  123.     text_ptr[1].text_length = strlen(chid);

  124.     png_set_text(png_ptr, info_ptr, text_ptr, 3);

  125.     png_set_pHYs(png_ptr, info_ptr, 4000, 4000, PNG_RESOLUTION_METER);

  126. 

  127.     printf("Writing %s... ", filename);

  128.     fflush(stdout);

  129.     pngfile = fopen(filename, "wb");

  130.     if (pngfile == NULL) {

  131. 		fprintf(stderr, "Could not open %s for writing\n", filename);

  132. 		return (1);

  133.     }

  134.     png_init_io(png_ptr, pngfile);

  135.     png_write_info(png_ptr, info_ptr);

  136. 

  137.     for (n = 0; n < nrow; n++) {

  138. 		float *pixelv;

  139. 		png_byte pixel[2*IMG_WIDTH];

  140. 		int i;

  141. 

  142. 		pixelv = prow[n];

  143. 		for (i = 0; i < width; i++) {

  144. 			pixel[i] = pixelv[i + offset];

  145. 		}

  146. 		png_write_row(png_ptr, pixel);

  147.     }

  148.     png_write_end(png_ptr, info_ptr);

  149.     fclose(pngfile);

  150.     printf("Done\n");

  151.     png_destroy_write_struct(&png_ptr, &info_ptr);

  152.     return (0);

  153. }

  154. 

  155. static int ImageRGBOut(char *filename, float **prow, int nrow) {

  156.     FILE *pngfile;

  157.     png_infop info_ptr;

  158.     png_structp png_ptr;

  159.     int n;

  160. 

  161.     extern void falsecolor(double v, double t, float *r, float *g, float *b);

  162. 

  163. 	/* init png lib */

  164.     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  165.     if (!png_ptr) {

  166. 		fprintf(stderr, "Could not create a PNG write struct\n");

  167. 		return (1);

  168.     }

  169. 

  170.     info_ptr = png_create_info_struct(png_ptr);

  171.     if (!info_ptr) {

  172. 		png_destroy_write_struct(&png_ptr, (png_infopp) NULL);

  173. 		fprintf(stderr, "Could not create a PNG info struct\n");

  174. 		return (1);

  175.     }

  176. 

  177.     png_set_IHDR(png_ptr, info_ptr, CH_WIDTH , nrow ,

  178. 		 		 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,

  179. 		 		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  180. 

  181.     png_set_pHYs(png_ptr, info_ptr, 4000, 4000, PNG_RESOLUTION_METER);

  182. 

  183.     text_ptr[1].text = "False Color";

  184.     text_ptr[1].text_length = strlen(text_ptr[1].text);

  185.     png_set_text(png_ptr, info_ptr, text_ptr, 3);

  186. 

  187.     printf("Computing false color & writing: %s... ", filename);

  188.     fflush(stdout);

  189.     pngfile = fopen(filename, "wb");

  190.     if (pngfile == NULL) {

  191. 		fprintf(stderr, "Could not open %s for writing\n", filename);

  192. 		return (1);

  193.     }

  194.     png_init_io(png_ptr, pngfile);

  195.     png_write_info(png_ptr, info_ptr);

  196. 

  197.     for (n = 0; n < nrow ; n++) {

  198. 		png_color pix[CH_WIDTH];

  199. 			float *pixelc;

  200. 		int i;

  201. 

  202. 		pixelc = prow[n];

  203. 

  204. 		for (i = 0; i < CH_WIDTH - 1; i++) {

  205. 			float v, t;

  206. 			float r, g, b;

  207. 

  208. 			v = pixelc[i+CHA_OFFSET];

  209. 			t = pixelc[i+CHB_OFFSET];

  210. 

  211. 			falsecolor(v, t, &r, &g, &b);

  212. 

  213. 			pix[i].red = 255.0 * r; 

  214. 			pix[i].green = 255.0 * g;

  215. 			pix[i].blue = 255.0 * b;

  216. 		}

  217. 		png_write_row(png_ptr, (png_bytep) pix);

  218.     }

  219.     png_write_end(png_ptr, info_ptr);

  220.     fclose(pngfile);

  221.     printf("Done\n");

  222.     png_destroy_write_struct(&png_ptr, &info_ptr);

  223.     return (0);

  224. }

  225. 

  226. 

  227. static void Distrib(char *filename,float **prow,int nrow) {

  228. 	unsigned int distrib[256][256];

  229. 	int n;

  230. 	int x, y;

  231. 	int max = 0;

  232. 	FILE *df;

  233. 

  234. 	for(y = 0; y < 256; y++)

  235. 		for(x = 0; x < 256; x++)

  236. 			distrib[y][x] = 0;

  237. 

  238. 	for(n = 0; n < nrow; n++) {

  239. 		float *pixelv;

  240. 		int i;

  241. 

  242. 		pixelv = prow[n];

  243. 		for(i = 0; i < CH_WIDTH; i++) {

  244. 			y = (int)(pixelv[i + CHA_OFFSET]);

  245. 			x = (int)(pixelv[i + CHB_OFFSET]);

  246. 			distrib[y][x] += 1;

  247. 			if(distrib[y][x] > max) max=distrib[y][x];

  248. 		}

  249. 	}

  250. 	df = fopen(filename,"w");

  251. 

  252. 	printf("Writing %s\n",filename);

  253. 

  254. 	fprintf(df,"P2\n#max %d\n",max);

  255. 	fprintf(df,"256 256\n255\n");

  256. 	for(y=0;y<256;y++)

  257. 		for(x=0;x<256;x++)

  258. 			fprintf(df, "%d\n", (int)((255.0 * (double)(distrib[y][x])) / (double)max));

  259. 	fclose(df);

  260. }

  261. 

  262. extern int Calibrate(float **prow, int nrow, int offset);

  263. extern void Temperature(float **prow, int nrow, int ch, int offset);

  264. extern int Ngvi(float **prow, int nrow);

  265. extern void readfconf(char *file);

  266. extern int optind, opterr;

  267. extern char *optarg;

  268. int satnum = 4;

  269. 

  270. static void usage(void) {

  271.     fprintf(stderr, "Aptdec [options] recordings ...\n");

  272.     fprintf(stderr, "Options:\n -i [r|a|b|c|t]      Output image type\n     r: Raw\n     a: A channel\n     b: B channel\n     c: False color\n     t: Temperature\n -d <dir>            Image destination directory.\n -s [15|16|17|18|19] Satellite number\n -c <file>           False color config file\n");

  273.    	exit(1);

  274. }

  275. 

  276. int main(int argc, char **argv) {

  277.     char pngfilename[1024];

  278.     char name[1024];

  279.     char pngdirname[1024] = "";

  280.     char imgopt[20] = "ac";

  281.     float *prow[3000];

  282.     char *chid[] = { "?", "1", "2", "3A", "4", "5", "3B" };

  283.     int nrow;

  284.     int chA, chB;

  285.     int c;

  286. 

  287.     printf("%s\n", version);

  288. 

  289.     opterr = 0;

  290. 	if(argc == 1){

  291. 		usage();

  292. 	}

  293.     while ((c = getopt(argc, argv, "c:d:i:s:")) != EOF) {

  294. 		switch (c) {

  295. 			case 'd':

  296. 				strcpy(pngdirname, optarg);

  297. 				break;

  298. 			case 'c':

  299. 				readfconf(optarg);

  300. 				break;

  301. 			case 'i':

  302. 				strcpy(imgopt, optarg);

  303. 				break;

  304. 			case 's':

  305. 				satnum = atoi(optarg)-15;

  306. 				if (satnum < 0 || satnum > 4) {

  307. 					fprintf(stderr, "Invalid satellite number, must be in the range [15-19]\n");

  308. 					exit(1);

  309. 				}

  310. 				break;

  311. 			default:

  312. 				usage();

  313. 		}

  314.     }

  315. 

  316.     for (nrow = 0; nrow < 3000; nrow++)

  317. 		prow[nrow] = NULL;

  318. 

  319. 	for (; optind < argc; optind++) {

  320. 		chA = chB = 0;

  321. 

  322. 		strcpy(pngfilename, argv[optind]);

  323. 		strcpy(name, basename(pngfilename));

  324. 		strtok(name, ".");

  325. 		if (pngdirname[0] == '\0') {

  326. 			strcpy(pngfilename, argv[optind]);

  327. 			strcpy(pngdirname, dirname(pngfilename));

  328. 		}

  329. 

  330. 		/* open snd input */

  331. 		if (initsnd(argv[optind]))

  332. 			exit(1);

  333. 

  334. 		/* main loop */

  335. 		printf("Decoding: %s \n", argv[optind]);

  336. 		for (nrow = 0; nrow < 3000; nrow++) {

  337. 			if (prow[nrow] == NULL)

  338. 			prow[nrow] = (float *) malloc(sizeof(float) * 2150);

  339. 			if (getpixelrow(prow[nrow]) == 0)

  340. 				break;

  341. 			

  342. 			printf("%d\r", nrow);

  343. 			fflush(stdout);

  344. 		}

  345. 		printf("\nDone\n");

  346. 		sf_close(inwav);

  347. 

  348. 		/* raw image */

  349. 		if (strchr(imgopt, (int) 'r') != NULL) {

  350. 			sprintf(pngfilename, "%s/%s-r.png", pngdirname, name);

  351. 			ImageOut(pngfilename, "raw", prow, nrow, IMG_WIDTH, 0, NULL);

  352. 		}

  353. 

  354. 		/* Channel A */

  355. 		if (((strchr(imgopt, (int) 'a') != NULL)

  356. 		  || (strchr(imgopt, (int) 'c') != NULL)

  357. 	      || (strchr(imgopt, (int) 'd') != NULL))) {

  358. 			chA = Calibrate(prow, nrow, CHA_OFFSET);

  359. 			if (chA >= 0 && strchr(imgopt, (int) 'a') != NULL) {

  360. 				sprintf(pngfilename, "%s/%s-%s.png", pngdirname, name, chid[chA]);

  361. 				ImageOut(pngfilename, chid[chA], prow, nrow, CH_WIDTH , CHA_OFFSET, NULL);

  362. 			}

  363. 		}

  364. 

  365. 		/* Channel B */

  366. 		if ((strchr(imgopt, (int) 'b') != NULL)

  367. 		 || (strchr(imgopt, (int) 'c') != NULL)

  368. 	     || (strchr(imgopt, (int) 't') != NULL)

  369. 		 || (strchr(imgopt, (int) 'd') != NULL)) {

  370. 			chB = Calibrate(prow, nrow, CHB_OFFSET);

  371. 			if (chB >= 0 && strchr(imgopt, (int) 'b') != NULL) {

  372. 				sprintf(pngfilename, "%s/%s-%s.png", pngdirname, name, chid[chB]);

  373. 				ImageOut(pngfilename, chid[chB], prow, nrow, CH_WIDTH , CHB_OFFSET ,NULL);

  374. 			}

  375. 			if (chB > 3) {

  376. 				Temperature(prow, nrow, chB, CHB_OFFSET);

  377. 				if (strchr(imgopt, (int) 't') != NULL) {

  378. 					sprintf(pngfilename, "%s/%s-t.png", pngdirname, name);

  379. 					ImageOut(pngfilename, "Temperature", prow, nrow, CH_WIDTH, CHB_OFFSET, (png_color*)TempPalette);

  380. 				}

  381. 			}

  382. 		}

  383. 

  384. 		/* distribution */

  385. 		if (chA && chB && strchr(imgopt, (int) 'd') != NULL) {

  386. 			sprintf(pngfilename, "%s/%s-d.pnm", pngdirname, name);

  387. 			Distrib(pngfilename, prow, nrow);

  388. 		}

  389. 

  390. 		/* color image */

  391. 		if (chA == 2 && chB == 4 && strchr(imgopt, (int) 'c') != NULL) {

  392. 			sprintf(pngfilename, "%s/%s-c.png", pngdirname, name);

  393. 			ImageRGBOut(pngfilename, prow, nrow);

  394. 		}

  395. 

  396. 		/* GVI image */

  397. 		if (chA == 1 && chB == 2 && strchr(imgopt, (int) 'c') != NULL) {

  398. 			Ngvi(prow, nrow);

  399. 			sprintf(pngfilename, "%s/%s-c.png", pngdirname, name);

  400. 			ImageOut(pngfilename, "GVI", prow, nrow, CH_WIDTH, CHB_OFFSET, (png_color*)GviPalette);

  401. 		}

  402.     }

  403.     exit(0);

  404. }