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.
57 Commits
2 Branches
1.5 MiB
 
 
 
 
 
Tag: 05e9507e14
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 05e9507e14
${ noResults }
aptdec/main.c

424 linhas
11 KiB
Original Anotar Histórico 

  1. /*

  2.  *  Atpdec

  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. 

  27. #ifdef WIN32

  28. #include "w32util.h"

  29. #else

  30. #include <libgen.h>

  31. #endif

  32. 

  33. #include <sndfile.h>

  34. #include <png.h>

  35. 

  36. #include "version.h"

  37. #include "offsets.h"

  38. 

  39. #include "temppalette.h"

  40. #include "gvipalette.h"

  41. 

  42. extern int getpixelrow(float *pixelv);

  43. extern int init_dsp(double F);;

  44. 

  45. static SNDFILE *inwav;

  46. 

  47. static int initsnd(char *filename)

  48. {

  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\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. {

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

  82. }

  83. 

  84. static png_text text_ptr[] = {

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

  86.     ,

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

  88.     ,

  89.     {PNG_TEXT_COMPRESSION_NONE, "Description", "NOAA POES satellite Image",

  90.      25}

  91. };

  92. 

  93. static int

  94. ImageOut(char *filename, char *chid, float **prow, int nrow, 

  95. 	 int width, int offset, png_color *palette)

  96. {

  97.     FILE *pngfile;

  98.     png_infop info_ptr;

  99.     png_structp png_ptr;

  100.     int n;

  101. 

  102. /* init png lib */

  103.     png_ptr =

  104. 	png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  105.     if (!png_ptr) {

  106. 	fprintf(stderr, "could not open create png_ptr\n");

  107. 	return (1);

  108.     }

  109. 

  110.     info_ptr = png_create_info_struct(png_ptr);

  111.     if (!info_ptr) {

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

  113. 	fprintf(stderr, "could not open create info_ptr\n");

  114. 	return (1);

  115.     }

  116. 

  117.     if(palette==NULL)  {

  118. 	/* grey image */

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

  120. 		 8, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE,

  121. 		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  122.     } else {

  123. 	/* palette color mage */

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

  125. 		 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,

  126. 		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

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

  128.     }

  129. 

  130.     text_ptr[1].text = chid;

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

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

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

  134. 

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

  136.     fflush(stdout);

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

  138.     if (pngfile == NULL) {

  139. 	fprintf(stderr, "could not open %s\n", filename);

  140. 	return (1);

  141.     }

  142.     png_init_io(png_ptr, pngfile);

  143.     png_write_info(png_ptr, info_ptr);

  144. 

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

  146. 	float *pixelv;

  147. 	png_byte pixel[2*IMG_WIDTH];

  148. 	int i;

  149. 

  150. 	pixelv = prow[n];

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

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

  153. 	}

  154. 	png_write_row(png_ptr, pixel);

  155.     }

  156.     png_write_end(png_ptr, info_ptr);

  157.     fclose(pngfile);

  158.     printf("Done\n");

  159.     png_destroy_write_struct(&png_ptr, &info_ptr);

  160.     return (0);

  161. }

  162. 

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

  164. {

  165.     FILE *pngfile;

  166.     png_infop info_ptr;

  167.     png_structp png_ptr;

  168.     int n;

  169. 

  170.     extern void falsecolor(double v, double t, float *r, float *g,

  171. 			    float *b);

  172. 

  173. /* init png lib */

  174.     png_ptr =

  175. 	png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

  176.     if (!png_ptr) {

  177. 	fprintf(stderr, "could not open create png_ptr\n");

  178. 	return (1);

  179.     }

  180. 

  181.     info_ptr = png_create_info_struct(png_ptr);

  182.     if (!info_ptr) {

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

  184. 	fprintf(stderr, "could not open create info_ptr\n");

  185. 	return (1);

  186.     }

  187. 

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

  189. 		 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,

  190. 		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

  191. 

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

  193. 

  194.     text_ptr[1].text = "False Colors";

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

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

  197. 

  198.     printf("Computing False colors & writing : %s ...", filename);

  199.     fflush(stdout);

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

  201.     if (pngfile == NULL) {

  202. 	fprintf(stderr, "could not open %s\n", filename);

  203. 	return (1);

  204.     }

  205.     png_init_io(png_ptr, pngfile);

  206.     png_write_info(png_ptr, info_ptr);

  207. 

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

  209. 	png_color pix[CH_WIDTH];

  210.     	float *pixelc;

  211. 	int i;

  212. 

  213. 	pixelc = prow[n];

  214. 

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

  216. 	    float v, t;

  217.   	    float r, g, b;

  218. 

  219. 	    v = pixelc[i+CHA_OFFSET];

  220. 	    t = pixelc[i+CHB_OFFSET];

  221. 

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

  223. 

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

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

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

  227. 	}

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

  229.     }

  230.     png_write_end(png_ptr, info_ptr);

  231.     fclose(pngfile);

  232.     printf("Done\n");

  233.     png_destroy_write_struct(&png_ptr, &info_ptr);

  234.     return (0);

  235. }

  236. 

  237. 

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

  239. {

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

  241. int n;

  242. int x,y;

  243. int max=0;

  244. FILE *df;

  245. 

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

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

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

  249. 

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

  251.         float *pixelv;

  252.         int     i;

  253. 

  254.         pixelv=prow[n];

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

  256. 

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

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

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

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

  261.         }

  262. }

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

  264. 

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

  266. 

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

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

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

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

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

  272. fclose(df);

  273. }

  274. 

  275. 

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

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

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

  279. extern void readfconf(char *file);

  280. extern int optind, opterr;

  281. extern char *optarg;

  282. int satnum = 1;

  283. 

  284. static void usage(void)

  285. {

  286.     fprintf(stderr, "atpdec [options] soundfiles ...\n");

  287.     fprintf(stderr,

  288. 	    "options:\n-d <dir>\tDestination directory\n-i [r|a|b|c|t]\tOutput image type\n\t\t\tr: Raw\n\t\t\ta: A chan.\n\t\t\tb: B chan.\n\t\t\tc: False color\n\t\t\tt: Temperature\n-c <file>\tFalse color config file\n-s [15|16|17|18]\tSatellite number (for temperature and false color generation)\n");

  289.    exit(1);

  290. }

  291. 

  292. int main(int argc, char **argv)

  293. {

  294.     char pngfilename[1024];

  295.     char name[1024];

  296.     char pngdirname[1024] = "";

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

  298.     float *prow[3000];

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

  300.     int nrow;

  301.     int chA,chB;

  302.     int c;

  303. 

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

  305. 

  306.     opterr = 0;

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

  308. 	switch (c) {

  309. 	case 'd':

  310. 	    strcpy(pngdirname, optarg);

  311. 	    break;

  312. 	case 'c':

  313. 	    readfconf(optarg);

  314. 	    break;

  315. 	case 'i':

  316. 	    strcpy(imgopt, optarg);

  317. 	    break;

  318. 	case 's':

  319. 	    satnum = atoi(optarg)-15;

  320. 	    if (satnum < 0 || satnum > 3) {

  321. 		fprintf(stderr, "invalid satellite number  : must be in [15-18]\n");

  322. 		exit(1);

  323. 	    }

  324. 	    break;

  325. 	default:

  326. 	    usage();

  327. 	}

  328.     }

  329. 

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

  331. 	prow[nrow] = NULL;

  332. 

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

  334. 

  335. 	chA=chB=0;

  336. 

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

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

  339. 	strtok(name, ".");

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

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

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

  343. 	}

  344. 

  345. /* open snd input */

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

  347. 	    exit(1);

  348. 

  349. /* main loop */

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

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

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

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

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

  355. 		break;

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

  357. 	    fflush(stdout);

  358. 	}

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

  360. 	sf_close(inwav);

  361. 

  362. 

  363. /* raw image */

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

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

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

  367. 	}

  368. 

  369. /* Channel A */

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

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

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

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

  374. 	    if (chA >= 0) {

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

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

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

  378. 		}

  379. 	    }

  380. 	}

  381. 

  382. /* Channel B */

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

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

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

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

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

  388. 	    if (chB >= 0) {

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

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

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

  392. 		}

  393. 	    }

  394. 	    if (chB > 3) {

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

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

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

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

  399. 		}

  400. 	    }

  401. 	}

  402. 

  403. /* distribution */

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

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

  406. 	    Distrib(pngfilename, prow, nrow);

  407. 	}

  408. 

  409. /* color image */

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

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

  412. 	    ImageRGBOut(pngfilename, prow, nrow);

  413. 	}

  414. 

  415. /* GVI image */

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

  417. 	    Ngvi(prow, nrow);

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

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

  420. 	}

  421.     }

  422.     exit(0);

  423. }