rdswitch.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424
  1. /*
  2. * rdswitch.c
  3. *
  4. * This file was part of the Independent JPEG Group's software:
  5. * Copyright (C) 1991-1996, Thomas G. Lane.
  6. * libjpeg-turbo Modifications:
  7. * Copyright (C) 2010, 2018, D. R. Commander.
  8. * For conditions of distribution and use, see the accompanying README.ijg
  9. * file.
  10. *
  11. * This file contains routines to process some of cjpeg's more complicated
  12. * command-line switches. Switches processed here are:
  13. * -qtables file Read quantization tables from text file
  14. * -scans file Read scan script from text file
  15. * -quality N[,N,...] Set quality ratings
  16. * -qslots N[,N,...] Set component quantization table selectors
  17. * -sample HxV[,HxV,...] Set component sampling factors
  18. */
  19. #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
  20. #include <ctype.h> /* to declare isdigit(), isspace() */
  21. LOCAL(int)
  22. text_getc(FILE *file)
  23. /* Read next char, skipping over any comments (# to end of line) */
  24. /* A comment/newline sequence is returned as a newline */
  25. {
  26. register int ch;
  27. ch = getc(file);
  28. if (ch == '#') {
  29. do {
  30. ch = getc(file);
  31. } while (ch != '\n' && ch != EOF);
  32. }
  33. return ch;
  34. }
  35. LOCAL(boolean)
  36. read_text_integer(FILE *file, long *result, int *termchar)
  37. /* Read an unsigned decimal integer from a file, store it in result */
  38. /* Reads one trailing character after the integer; returns it in termchar */
  39. {
  40. register int ch;
  41. register long val;
  42. /* Skip any leading whitespace, detect EOF */
  43. do {
  44. ch = text_getc(file);
  45. if (ch == EOF) {
  46. *termchar = ch;
  47. return FALSE;
  48. }
  49. } while (isspace(ch));
  50. if (!isdigit(ch)) {
  51. *termchar = ch;
  52. return FALSE;
  53. }
  54. val = ch - '0';
  55. while ((ch = text_getc(file)) != EOF) {
  56. if (!isdigit(ch))
  57. break;
  58. val *= 10;
  59. val += ch - '0';
  60. }
  61. *result = val;
  62. *termchar = ch;
  63. return TRUE;
  64. }
  65. #if JPEG_LIB_VERSION < 70
  66. static int q_scale_factor[NUM_QUANT_TBLS] = { 100, 100, 100, 100 };
  67. #endif
  68. GLOBAL(boolean)
  69. read_quant_tables(j_compress_ptr cinfo, char *filename, boolean force_baseline)
  70. /* Read a set of quantization tables from the specified file.
  71. * The file is plain ASCII text: decimal numbers with whitespace between.
  72. * Comments preceded by '#' may be included in the file.
  73. * There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values.
  74. * The tables are implicitly numbered 0,1,etc.
  75. * NOTE: does not affect the qslots mapping, which will default to selecting
  76. * table 0 for luminance (or primary) components, 1 for chrominance components.
  77. * You must use -qslots if you want a different component->table mapping.
  78. */
  79. {
  80. FILE *fp;
  81. int tblno, i, termchar;
  82. long val;
  83. unsigned int table[DCTSIZE2];
  84. if ((fp = fopen(filename, "r")) == NULL) {
  85. fprintf(stderr, "Can't open table file %s\n", filename);
  86. return FALSE;
  87. }
  88. tblno = 0;
  89. while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */
  90. if (tblno >= NUM_QUANT_TBLS) {
  91. fprintf(stderr, "Too many tables in file %s\n", filename);
  92. fclose(fp);
  93. return FALSE;
  94. }
  95. table[0] = (unsigned int)val;
  96. for (i = 1; i < DCTSIZE2; i++) {
  97. if (!read_text_integer(fp, &val, &termchar)) {
  98. fprintf(stderr, "Invalid table data in file %s\n", filename);
  99. fclose(fp);
  100. return FALSE;
  101. }
  102. table[i] = (unsigned int)val;
  103. }
  104. #if JPEG_LIB_VERSION >= 70
  105. jpeg_add_quant_table(cinfo, tblno, table, cinfo->q_scale_factor[tblno],
  106. force_baseline);
  107. #else
  108. jpeg_add_quant_table(cinfo, tblno, table, q_scale_factor[tblno],
  109. force_baseline);
  110. #endif
  111. tblno++;
  112. }
  113. if (termchar != EOF) {
  114. fprintf(stderr, "Non-numeric data in file %s\n", filename);
  115. fclose(fp);
  116. return FALSE;
  117. }
  118. fclose(fp);
  119. return TRUE;
  120. }
  121. #ifdef C_MULTISCAN_FILES_SUPPORTED
  122. LOCAL(boolean)
  123. read_scan_integer(FILE *file, long *result, int *termchar)
  124. /* Variant of read_text_integer that always looks for a non-space termchar;
  125. * this simplifies parsing of punctuation in scan scripts.
  126. */
  127. {
  128. register int ch;
  129. if (!read_text_integer(file, result, termchar))
  130. return FALSE;
  131. ch = *termchar;
  132. while (ch != EOF && isspace(ch))
  133. ch = text_getc(file);
  134. if (isdigit(ch)) { /* oops, put it back */
  135. if (ungetc(ch, file) == EOF)
  136. return FALSE;
  137. ch = ' ';
  138. } else {
  139. /* Any separators other than ';' and ':' are ignored;
  140. * this allows user to insert commas, etc, if desired.
  141. */
  142. if (ch != EOF && ch != ';' && ch != ':')
  143. ch = ' ';
  144. }
  145. *termchar = ch;
  146. return TRUE;
  147. }
  148. GLOBAL(boolean)
  149. read_scan_script(j_compress_ptr cinfo, char *filename)
  150. /* Read a scan script from the specified text file.
  151. * Each entry in the file defines one scan to be emitted.
  152. * Entries are separated by semicolons ';'.
  153. * An entry contains one to four component indexes,
  154. * optionally followed by a colon ':' and four progressive-JPEG parameters.
  155. * The component indexes denote which component(s) are to be transmitted
  156. * in the current scan. The first component has index 0.
  157. * Sequential JPEG is used if the progressive-JPEG parameters are omitted.
  158. * The file is free format text: any whitespace may appear between numbers
  159. * and the ':' and ';' punctuation marks. Also, other punctuation (such
  160. * as commas or dashes) can be placed between numbers if desired.
  161. * Comments preceded by '#' may be included in the file.
  162. * Note: we do very little validity checking here;
  163. * jcmaster.c will validate the script parameters.
  164. */
  165. {
  166. FILE *fp;
  167. int scanno, ncomps, termchar;
  168. long val;
  169. jpeg_scan_info *scanptr;
  170. #define MAX_SCANS 100 /* quite arbitrary limit */
  171. jpeg_scan_info scans[MAX_SCANS];
  172. if ((fp = fopen(filename, "r")) == NULL) {
  173. fprintf(stderr, "Can't open scan definition file %s\n", filename);
  174. return FALSE;
  175. }
  176. scanptr = scans;
  177. scanno = 0;
  178. while (read_scan_integer(fp, &val, &termchar)) {
  179. if (scanno >= MAX_SCANS) {
  180. fprintf(stderr, "Too many scans defined in file %s\n", filename);
  181. fclose(fp);
  182. return FALSE;
  183. }
  184. scanptr->component_index[0] = (int)val;
  185. ncomps = 1;
  186. while (termchar == ' ') {
  187. if (ncomps >= MAX_COMPS_IN_SCAN) {
  188. fprintf(stderr, "Too many components in one scan in file %s\n",
  189. filename);
  190. fclose(fp);
  191. return FALSE;
  192. }
  193. if (!read_scan_integer(fp, &val, &termchar))
  194. goto bogus;
  195. scanptr->component_index[ncomps] = (int)val;
  196. ncomps++;
  197. }
  198. scanptr->comps_in_scan = ncomps;
  199. if (termchar == ':') {
  200. if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
  201. goto bogus;
  202. scanptr->Ss = (int)val;
  203. if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
  204. goto bogus;
  205. scanptr->Se = (int)val;
  206. if (!read_scan_integer(fp, &val, &termchar) || termchar != ' ')
  207. goto bogus;
  208. scanptr->Ah = (int)val;
  209. if (!read_scan_integer(fp, &val, &termchar))
  210. goto bogus;
  211. scanptr->Al = (int)val;
  212. } else {
  213. /* set non-progressive parameters */
  214. scanptr->Ss = 0;
  215. scanptr->Se = DCTSIZE2 - 1;
  216. scanptr->Ah = 0;
  217. scanptr->Al = 0;
  218. }
  219. if (termchar != ';' && termchar != EOF) {
  220. bogus:
  221. fprintf(stderr, "Invalid scan entry format in file %s\n", filename);
  222. fclose(fp);
  223. return FALSE;
  224. }
  225. scanptr++, scanno++;
  226. }
  227. if (termchar != EOF) {
  228. fprintf(stderr, "Non-numeric data in file %s\n", filename);
  229. fclose(fp);
  230. return FALSE;
  231. }
  232. if (scanno > 0) {
  233. /* Stash completed scan list in cinfo structure.
  234. * NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data,
  235. * but if you want to compress multiple images you'd want JPOOL_PERMANENT.
  236. */
  237. scanptr = (jpeg_scan_info *)
  238. (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
  239. scanno * sizeof(jpeg_scan_info));
  240. MEMCOPY(scanptr, scans, scanno * sizeof(jpeg_scan_info));
  241. cinfo->scan_info = scanptr;
  242. cinfo->num_scans = scanno;
  243. }
  244. fclose(fp);
  245. return TRUE;
  246. }
  247. #endif /* C_MULTISCAN_FILES_SUPPORTED */
  248. #if JPEG_LIB_VERSION < 70
  249. /* These are the sample quantization tables given in Annex K (Clause K.1) of
  250. * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
  251. * The spec says that the values given produce "good" quality, and
  252. * when divided by 2, "very good" quality.
  253. */
  254. static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
  255. 16, 11, 10, 16, 24, 40, 51, 61,
  256. 12, 12, 14, 19, 26, 58, 60, 55,
  257. 14, 13, 16, 24, 40, 57, 69, 56,
  258. 14, 17, 22, 29, 51, 87, 80, 62,
  259. 18, 22, 37, 56, 68, 109, 103, 77,
  260. 24, 35, 55, 64, 81, 104, 113, 92,
  261. 49, 64, 78, 87, 103, 121, 120, 101,
  262. 72, 92, 95, 98, 112, 100, 103, 99
  263. };
  264. static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
  265. 17, 18, 24, 47, 99, 99, 99, 99,
  266. 18, 21, 26, 66, 99, 99, 99, 99,
  267. 24, 26, 56, 99, 99, 99, 99, 99,
  268. 47, 66, 99, 99, 99, 99, 99, 99,
  269. 99, 99, 99, 99, 99, 99, 99, 99,
  270. 99, 99, 99, 99, 99, 99, 99, 99,
  271. 99, 99, 99, 99, 99, 99, 99, 99,
  272. 99, 99, 99, 99, 99, 99, 99, 99
  273. };
  274. LOCAL(void)
  275. jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
  276. {
  277. jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, q_scale_factor[0],
  278. force_baseline);
  279. jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, q_scale_factor[1],
  280. force_baseline);
  281. }
  282. #endif
  283. GLOBAL(boolean)
  284. set_quality_ratings(j_compress_ptr cinfo, char *arg, boolean force_baseline)
  285. /* Process a quality-ratings parameter string, of the form
  286. * N[,N,...]
  287. * If there are more q-table slots than parameters, the last value is replicated.
  288. */
  289. {
  290. int val = 75; /* default value */
  291. int tblno;
  292. char ch;
  293. for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
  294. if (*arg) {
  295. ch = ','; /* if not set by sscanf, will be ',' */
  296. if (sscanf(arg, "%d%c", &val, &ch) < 1)
  297. return FALSE;
  298. if (ch != ',') /* syntax check */
  299. return FALSE;
  300. /* Convert user 0-100 rating to percentage scaling */
  301. #if JPEG_LIB_VERSION >= 70
  302. cinfo->q_scale_factor[tblno] = jpeg_quality_scaling(val);
  303. #else
  304. q_scale_factor[tblno] = jpeg_quality_scaling(val);
  305. #endif
  306. while (*arg && *arg++ != ',') /* advance to next segment of arg string */
  307. ;
  308. } else {
  309. /* reached end of parameter, set remaining factors to last value */
  310. #if JPEG_LIB_VERSION >= 70
  311. cinfo->q_scale_factor[tblno] = jpeg_quality_scaling(val);
  312. #else
  313. q_scale_factor[tblno] = jpeg_quality_scaling(val);
  314. #endif
  315. }
  316. }
  317. jpeg_default_qtables(cinfo, force_baseline);
  318. return TRUE;
  319. }
  320. GLOBAL(boolean)
  321. set_quant_slots(j_compress_ptr cinfo, char *arg)
  322. /* Process a quantization-table-selectors parameter string, of the form
  323. * N[,N,...]
  324. * If there are more components than parameters, the last value is replicated.
  325. */
  326. {
  327. int val = 0; /* default table # */
  328. int ci;
  329. char ch;
  330. for (ci = 0; ci < MAX_COMPONENTS; ci++) {
  331. if (*arg) {
  332. ch = ','; /* if not set by sscanf, will be ',' */
  333. if (sscanf(arg, "%d%c", &val, &ch) < 1)
  334. return FALSE;
  335. if (ch != ',') /* syntax check */
  336. return FALSE;
  337. if (val < 0 || val >= NUM_QUANT_TBLS) {
  338. fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",
  339. NUM_QUANT_TBLS - 1);
  340. return FALSE;
  341. }
  342. cinfo->comp_info[ci].quant_tbl_no = val;
  343. while (*arg && *arg++ != ',') /* advance to next segment of arg string */
  344. ;
  345. } else {
  346. /* reached end of parameter, set remaining components to last table */
  347. cinfo->comp_info[ci].quant_tbl_no = val;
  348. }
  349. }
  350. return TRUE;
  351. }
  352. GLOBAL(boolean)
  353. set_sample_factors(j_compress_ptr cinfo, char *arg)
  354. /* Process a sample-factors parameter string, of the form
  355. * HxV[,HxV,...]
  356. * If there are more components than parameters, "1x1" is assumed for the rest.
  357. */
  358. {
  359. int ci, val1, val2;
  360. char ch1, ch2;
  361. for (ci = 0; ci < MAX_COMPONENTS; ci++) {
  362. if (*arg) {
  363. ch2 = ','; /* if not set by sscanf, will be ',' */
  364. if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)
  365. return FALSE;
  366. if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */
  367. return FALSE;
  368. if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {
  369. fprintf(stderr, "JPEG sampling factors must be 1..4\n");
  370. return FALSE;
  371. }
  372. cinfo->comp_info[ci].h_samp_factor = val1;
  373. cinfo->comp_info[ci].v_samp_factor = val2;
  374. while (*arg && *arg++ != ',') /* advance to next segment of arg string */
  375. ;
  376. } else {
  377. /* reached end of parameter, set remaining components to 1x1 sampling */
  378. cinfo->comp_info[ci].h_samp_factor = 1;
  379. cinfo->comp_info[ci].v_samp_factor = 1;
  380. }
  381. }
  382. return TRUE;
  383. }