开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
Dl1quant.cpp
资源名称：jpeg_Source_lib.rar　[点击查看]
上传用户：qiutianh
上传日期：2022-08-08
资源大小：939k
文件大小：17k
源码类别：

图形图象

开发平台：

Visual C++

Dl1quant.cpp：源码内容
  1. //
  2. // This has been modified from Dennis Lee's original version
  3. //
  5. /*
  6.  * DL1 Quantization
  7.  * ================
  8.  *
  9.  * File: dl1quant.c
  10.  * Author: Dennis Lee   E-mail: denlee@ecf.utoronto.ca
  11.  *
  12.  * Copyright (C) 1993-1997 Dennis Lee
  13.  *
  14.  * C implementation of DL1 Quantization.
  15.  * DL1 Quantization is a 2-pass color quantizer optimized for speed.
  16.  * The method was designed around the steps required by a 2-pass
  17.  * quantizer and constructing a model that would require the least
  18.  * amount of extra work.  The resulting method is extremely fast --
  19.  * about half the speed of a memcpy.  That should make DL1 Quant the
  20.  * fastest 2-pass color quantizer.
  21.  *
  22.  * This quantizer's quality is also among the best, slightly
  23.  * better than Wan et al's marginal variance based quantizer.  For
  24.  * more on DL1 Quant's performance and other related information,
  25.  * see DLQUANT.TXT included in this distribution.
  26.  *
  27.  *
  28.  * NOTES
  29.  * =====
  30.  *
  31.  * The dithering code is based on code from the IJG's jpeg library.
  32.  *
  33.  * This source code may be freely copied, modified, and redistributed,
  34.  * provided this copyright notice is attached.
  35.  * Compiled versions of this code, modified or not, are free for
  36.  * personal use.  Compiled versions used in distributed software
  37.  * is also free, but a notification must be sent to the author.
  38.  * An e-mail to denlee@ecf.utoronto.ca will do.
  39.  *
  40.  */
  42. #include "stdafx.h"
  44. #ifdef __cplusplus
  45. extern "C" {
  46. #endif
  49. #include <stdlib.h>
  50. #include "dl1quant.h"
  52. //#define FAST        /* improves speed but uses a lot of memory */
  53. #define QUAL1       /* slightly improves quality */
  54. //#define QUAL2       /* slightly improves quality */
  56. /* define *one* of the following dither options */
  57. //#define DITHER1     /* 1-val error diffusion dither */
  58. #define DITHER2     /* 2-val error diffusion dither */
  59. //#define DITHER4     /* 4-val error diffusion dither (Floyd-Steinberg) */
  61. #define DITHER_MAX  20
  63. LOCAL uchar palette[3][256];
  64. LOCAL CUBE *rgb_table[6];
  65. LOCAL ushort r_offset[256], g_offset[256], b_offset[256];
  66. LOCAL CLOSEST_INFO c_info;
  67. LOCAL int tot_colors, pal_index;
  68. LOCAL ulong *squares;
  69. LOCAL FCUBE *heap = NULL;
  70. LOCAL short *dl_image = NULL;
  72. /* returns 1 on success, 0 on failure */
  73. GLOBAL int dl1quant(uchar *inbuf, 
  74. uchar *outbuf, 
  75. int width, 
  76. int height, 
  77. int quant_to,
  78. int dither, 
  79. uchar userpal[3][256]) {
  81. dlq_init();
  83.     if (dlq_start() == 0) {
  84. dlq_finish();
  85. return 0;
  86. }
  88.     if (build_table(inbuf, (ulong)width * (ulong)height) == 0) {
  89. dlq_finish();
  90. return 0;
  91.     }
  92.     
  93. reduce_table(quant_to);
  94.     set_palette(0, 0);
  95.     
  96. if (quantize_image(inbuf, outbuf, width, height, dither) == 0) {
  97. dlq_finish();
  98. return 0;
  99.     }
  101.     dlq_finish();
  102.     copy_pal(userpal);
  104.     return 1;
  105. }
  107. LOCAL void copy_pal(uchar userpal[3][256]) 
  108. {
  109.     int i;
  111.     for (i = 0; i < 256; i++) {
  112. userpal[0][i] = palette[0][i];
  113. userpal[1][i] = palette[1][i];
  114. userpal[2][i] = palette[2][i];
  115.     }
  116. }
  118. LOCAL void dlq_init(void) 
  119. {
  120.     int i;
  122. for (i=0;i<6;i++) {
  123. rgb_table[i]=NULL;
  124. }
  126. tot_colors=0;
  127. pal_index=0;
  129. heap = NULL;
  130. dl_image = NULL;
  132.     for (i = 0; i < 256; i++) {
  133. r_offset[i] = (i & 128) << 7 | (i & 64) << 5 | (i & 32) << 3 |
  134.   (i & 16)  << 1 | (i & 8)  >> 1;
  135. g_offset[i] = (i & 128) << 6 | (i & 64) << 4 | (i & 32) << 2 |
  136.   (i & 16)  << 0 | (i & 8)  >> 2;
  137. b_offset[i] = (i & 128) << 5 | (i & 64) << 3 | (i & 32) << 1 |
  138.   (i & 16)  >> 1 | (i & 8)  >> 3;
  139.     }
  142. c_info.palette_index=0;
  143. c_info.red=0;
  144. c_info.green=0;
  145. c_info.blue=0;
  146.     c_info.distance=0;
  148.     for (i = (-255); i <= 255; i++)
  149. c_info.squares[i+255] = i*i;
  151. for (i=0;i<256;i++) {
  152. palette[0][i]=0;
  153. palette[1][i]=0;
  154. palette[2][i]=0;
  155. }
  157.     squares = c_info.squares + 255;
  158. }
  160. /* returns 1 on success, 0 on failure */
  161. LOCAL int dlq_start(void) 
  162. {
  163.     int i;
  165.     rgb_table[0] = (CUBE *) calloc(sizeof(CUBE), 1);
  166.     rgb_table[1] = (CUBE *) calloc(sizeof(CUBE), 8);
  167.     rgb_table[2] = (CUBE *) calloc(sizeof(CUBE), 64);
  168.     rgb_table[3] = (CUBE *) calloc(sizeof(CUBE), 512);
  169.     rgb_table[4] = (CUBE *) calloc(sizeof(CUBE), 4096);
  170.     rgb_table[5] = (CUBE *) calloc(sizeof(CUBE), 32768);
  172.     for (i = 0; i <= 5; i++)
  173. if (rgb_table[i] == NULL)
  174.     return 0;
  176.     pal_index = 0;
  177.     return 1;
  178. }
  180. LOCAL void dlq_finish(void) 
  181. {
  182. int i;
  184. for (i=0;i<6;i++) {
  185. if (rgb_table[i] != NULL) {
  186. free(rgb_table[i]);
  187. rgb_table[i]=NULL;
  188. }
  189. }
  191.     if (heap != NULL) {
  192. free(heap);
  193. heap=NULL;
  194. }
  195.     
  196. if (dl_image != NULL) {
  197. free(dl_image);
  198. dl_image=NULL;
  199. }
  201. memset(&c_info, 0, sizeof(CLOSEST_INFO));
  203. tot_colors=pal_index=0;
  205. }
  207. /* returns 1 on success, 0 on failure */
  208. LOCAL int build_table(uchar *image, ulong pixels) 
  209. {
  210.     ulong i=0;
  211. ulong index=0;
  212. ulong cur_count=0;
  213. ulong head=0;
  214. ulong tail=0;
  215.     slong j=0;
  217.     heap = (FCUBE *) malloc(sizeof(FCUBE) * 32769);
  218.     if (heap == NULL)
  219. return 0;
  221. #ifdef FAST
  222.     dl_image = malloc(sizeof(short) * pixels);
  223.     if (dl_image == NULL)
  224. return 0;
  225. #endif
  227.     for (i = 0; i < pixels; i++) {
  228. #ifdef FAST
  229. dl_image[i] = index = r_offset[image[0]] + g_offset[image[1]] + b_offset[image[2]];
  230. #else
  231. index = r_offset[image[0]] + g_offset[image[1]] + b_offset[image[2]];
  232. #endif
  233. #ifdef QUAL1
  234. rgb_table[5][index].r += image[0];
  235. rgb_table[5][index].g += image[1];
  236. rgb_table[5][index].b += image[2];
  237. #endif
  238. rgb_table[5][index].pixel_count++;
  239. image += 3;
  240.     }
  242.     tot_colors = 0;
  243. for (i = 0; i < 32768; i++) {
  244. cur_count = rgb_table[5][i].pixel_count;
  245. if (cur_count) {
  246. heap[++tot_colors].level = 5;
  247. heap[tot_colors].index = (ushort)i;
  248. rgb_table[5][i].pixels_in_cube = cur_count;
  249. #ifndef QUAL1
  250. rgb_table[5][i].r = cur_count * (((i & 0x4000) >> 7 |
  251. (i & 0x0800) >> 5 | (i & 0x0100) >> 3 |
  252. (i & 0x0020) >> 1 | (i & 0x0004) << 1) + 4);
  253. rgb_table[5][i].g = cur_count * (((i & 0x2000) >> 6 |
  254. (i & 0x0400) >> 4 | (i & 0x0080) >> 2 |
  255. (i & 0x0010) >> 0 | (i & 0x0002) << 2) + 4);
  256. rgb_table[5][i].b = cur_count * (((i & 0x1000) >> 5 |
  257. (i & 0x0200) >> 3 | (i & 0x0040) >> 1 |
  258. (i & 0x0008) << 1 | (i & 0x0001) << 3) + 4);
  259. #endif
  260. head = i;
  261. for (j = 4; j >= 0; j--) {
  262. tail = head & 0x7;
  263. head >>= 3;
  264. rgb_table[j][head].pixels_in_cube += cur_count;
  265. rgb_table[j][head].children |= 1 << tail;
  266. }
  267. }
  268.     }
  270.     for (i = tot_colors; i > 0; i--)
  271. fixheap(i);
  273.     return 1;
  274. }
  276. LOCAL void fixheap(ulong id) 
  277. {
  278.     uchar thres_level = heap[id].level;
  279.     ulong thres_index = heap[id].index;
  280. ulong index=0;
  281. ulong half_totc = tot_colors >> 1;
  282. ulong thres_val = rgb_table[thres_level][thres_index].pixels_in_cube;
  284.     while (id <= half_totc) {
  285. index = id << 1;
  287. if (index < (ulong)tot_colors)
  288. if (rgb_table[heap[index].level][heap[index].index].pixels_in_cube
  289.   > rgb_table[heap[index+1].level][heap[index+1].index].pixels_in_cube)
  290. index++;
  292. if (thres_val <= rgb_table[heap[index].level][heap[index].index].pixels_in_cube)
  293. break;
  294. else {
  295. heap[id] = heap[index];
  296. id = index;
  297. }
  298.     }
  299.     heap[id].level = thres_level;
  300.     heap[id].index = (ushort)thres_index;
  301. }
  303. LOCAL void reduce_table(int num_colors) 
  304. {
  305. while (tot_colors > num_colors) {
  307. uchar tmp_level = heap[1].level, t_level = max(0,tmp_level - 1);
  308. ulong tmp_index = heap[1].index, t_index = tmp_index >> 3;
  310. if (rgb_table[t_level][t_index].pixel_count)
  311. heap[1] = heap[tot_colors--];
  312. else {
  313. heap[1].level = t_level;
  314. heap[1].index = (ushort)t_index;
  315. }
  317. rgb_table[t_level][t_index].pixel_count += rgb_table[tmp_level][tmp_index].pixel_count;
  318. rgb_table[t_level][t_index].r += rgb_table[tmp_level][tmp_index].r;
  319. rgb_table[t_level][t_index].g += rgb_table[tmp_level][tmp_index].g;
  320. rgb_table[t_level][t_index].b += rgb_table[tmp_level][tmp_index].b;
  321. rgb_table[t_level][t_index].children &= ~(1 << (tmp_index & 0x7));
  323. fixheap(1);
  324.     }
  325. }
  327. LOCAL void set_palette(int index, int level) 
  328. {
  329.     int i;
  331.     if (rgb_table[level][index].children) {
  332. for (i = 7; i >= 0; i--) {
  333. if (rgb_table[level][index].children & (1 << i)) {
  334. set_palette((index << 3) + i, level + 1);
  335. }
  336. }
  337. }
  339.     if (rgb_table[level][index].pixel_count) {
  340. ulong r_sum, g_sum, b_sum, sum;
  342. rgb_table[level][index].palette_index = pal_index;
  344. r_sum = rgb_table[level][index].r;
  345. g_sum = rgb_table[level][index].g;
  346. b_sum = rgb_table[level][index].b;
  348. sum = rgb_table[level][index].pixel_count;
  350. palette[0][pal_index] = (BYTE)((r_sum + (sum >> 1)) / sum);
  351. palette[1][pal_index] = (BYTE)((g_sum + (sum >> 1)) / sum);
  352. palette[2][pal_index] = (BYTE)((b_sum + (sum >> 1)) / sum);
  354. pal_index++;
  355.     }
  356. }
  358. LOCAL void closest_color(int index, int level) 
  359. {
  360.     int i;
  362.     if (rgb_table[level][index].children) {
  363. for (i = 7; i >= 0; i--) {
  364. if (rgb_table[level][index].children & (1 << i)) {
  365. closest_color((index << 3) + i, level + 1);
  366. }
  367. }
  368. }
  370.     if (rgb_table[level][index].pixel_count) {
  371. slong dist, r_dist, g_dist, b_dist;
  372. uchar pal_num = rgb_table[level][index].palette_index;
  374. /* Determine if this color is "closest". */
  375. r_dist = palette[0][pal_num] - c_info.red;
  376. g_dist = palette[1][pal_num] - c_info.green;
  377. b_dist = palette[2][pal_num] - c_info.blue;
  379. dist = squares[r_dist] + squares[g_dist] + squares[b_dist];
  381. if (dist < (slong)c_info.distance) {
  382. c_info.distance = dist;
  383. c_info.palette_index = pal_num;
  384. }
  385.     }
  386. }
  388. /* returns 1 on success, 0 on failure */
  389. LOCAL int quantize_image(uchar *in, uchar *out, int width, int height, int dither) 
  390. {
  391. if (!dither) {
  392. ulong i=0;
  393. ulong pixels = width * height;
  394. ushort level=0;
  395. ushort index=0;
  396. uchar tmp_r=0;
  397. uchar tmp_g=0;
  398. uchar tmp_b=0;
  399. uchar cube=0;
  400. uchar *lookup=NULL;
  402. lookup = (BYTE*)malloc(sizeof(char) * 32768);
  403. if (lookup == NULL)
  404. return 0;
  406. for (i = 0; i < 32768; i++)
  407. if (rgb_table[5][i].pixel_count) {
  408. tmp_r = (BYTE)((i & 0x4000) >> 7 | (i & 0x0800) >> 5 |
  409. (i & 0x0100) >> 3 | (i & 0x0020) >> 1 |
  410. (i & 0x0004) << 1);
  411. tmp_g = (BYTE)((i & 0x2000) >> 6 | (i & 0x0400) >> 4 |
  412. (i & 0x0080) >> 2 | (i & 0x0010) >> 0 |
  413. (i & 0x0002) << 2);
  414. tmp_b = (BYTE)((i & 0x1000) >> 5 | (i & 0x0200) >> 3 |
  415. (i & 0x0040) >> 1 | (i & 0x0008) << 1 |
  416. (i & 0x0001) << 3);
  417. #ifdef QUAL2
  418. lookup[i] = bestcolor(tmp_r, tmp_g, tmp_b);
  419. #else
  420. c_info.red   = tmp_r + 4;
  421. c_info.green = tmp_g + 4;
  422. c_info.blue  = tmp_b + 4;
  423. level = 0;
  424. index = 0;
  425. for (;;) {
  426. cube = (tmp_r&128) >> 5 | (tmp_g&128) >> 6 | (tmp_b&128) >> 7;
  427. if ((rgb_table[level][index].children & (1 << cube)) == 0) {
  428. c_info.distance = (ULONG)~0L;
  429. closest_color(index, level);
  430. lookup[i] = c_info.palette_index;
  431. break;
  432. }
  433. level++;
  434. index = (index << 3) + cube;
  435. tmp_r <<= 1;
  436. tmp_g <<= 1;
  437. tmp_b <<= 1;
  438. }
  439. #endif
  440. }
  442. for (i = 0; i < pixels; i++) {
  443. #ifdef FAST
  444. out[i] = lookup[dl_image[i]];
  445. #else
  446. out[i] = lookup[r_offset[in[0]] + g_offset[in[1]] + b_offset[in[2]]];
  447. in += 3;
  448. #endif
  449. }
  451. free(lookup);
  453. } else { // dither
  455. #if defined(DITHER2) || defined(DITHER4)
  456. slong i=0;
  457. slong j=0;
  458. slong r_pix=0;
  459. slong g_pix=0;
  460. slong b_pix=0;
  461. slong offset=0;
  462. slong dir=0;
  463. slong two_val=0;
  464. slong odd_scanline = 0;
  465. slong err_len = (width + 2) * 3;
  467. uchar *range_tbl = NULL; 
  468. uchar *range = NULL;
  470. sshort *lookup = NULL;
  471. sshort *erowerr = NULL;
  472. sshort *orowerr = NULL;
  473. sshort *thisrowerr = NULL;
  474. sshort *nextrowerr = NULL;
  476. schar *dith_max_tbl = NULL;
  477. schar *dith_max = NULL;
  479. lookup = (sshort *)malloc(sizeof(short) * 32768);
  480. erowerr = (sshort *)malloc(sizeof(short) * err_len);
  481. orowerr = (sshort *)malloc(sizeof(short) * err_len);
  482. range_tbl = (BYTE*)malloc(3 * 256);
  483. range = range_tbl + 256;
  484. dith_max_tbl= (schar *)malloc(512);
  485. dith_max = dith_max_tbl + 256;
  487. if (range_tbl == NULL || lookup == NULL ||
  488. erowerr == NULL || orowerr == NULL || dith_max_tbl == NULL) {
  489. if (range_tbl != NULL) {
  490. free(range_tbl);
  491. range_tbl=NULL;
  492. }
  493. if (lookup != NULL) {
  494. free(lookup);
  495. lookup=NULL;
  496. }
  497. if (erowerr != NULL) {
  498. free(erowerr);
  499. erowerr=NULL;
  500. }
  501. if (orowerr != NULL) {
  502. free(orowerr);
  503. orowerr=NULL;
  504. }
  505. if (dith_max_tbl != NULL) {
  506. free(dith_max_tbl);
  507. dith_max_tbl=NULL;
  508. }
  509. return 0;
  510. }
  512. for (i = 0; i < err_len; i++)
  513. erowerr[i] = 0;
  515. for (i = 0; i < 32768; i++)
  516. lookup[i] = -1;
  518. for (i = 0; i < 256; i++) {
  519. range_tbl[i] = 0;
  520. range_tbl[i + 256] = (uchar) i;
  521. range_tbl[i + 512] = 255;
  522. }
  524. for (i = 0; i < 256; i++) {
  525. dith_max_tbl[i] = -DITHER_MAX;
  526. dith_max_tbl[i + 256] = DITHER_MAX;
  527. }
  528. for (i = -DITHER_MAX; i <= DITHER_MAX; i++)
  529. dith_max_tbl[i + 256] = (schar)i;
  531. for (i = 0 ; i < height; i++) {
  532. if (odd_scanline) {
  533. dir = -1;
  534. in  += (width - 1) * 3;
  535. out += (width - 1);
  536. thisrowerr = orowerr + 3;
  537. nextrowerr = erowerr + width * 3;
  538. } else {
  539. dir = 1;
  540. thisrowerr = erowerr + 3;
  541. nextrowerr = orowerr + width * 3;
  542. }
  544. nextrowerr[0] = nextrowerr[1] = nextrowerr[2] = 0;
  546. for (j = 0; j < width; j++) {
  548. #ifdef DITHER2
  549. r_pix = range[(thisrowerr[0] >> 1) + in[0]];
  550. g_pix = range[(thisrowerr[1] >> 1) + in[1]];
  551. b_pix = range[(thisrowerr[2] >> 1) + in[2]];
  552. #else
  553. r_pix = range[((thisrowerr[0] + 8) >> 4) + in[0]];
  554. g_pix = range[((thisrowerr[1] + 8) >> 4) + in[1]];
  555. b_pix = range[((thisrowerr[2] + 8) >> 4) + in[2]];
  556. #endif
  557. offset = (r_pix&248) << 7 | (g_pix&248) << 2 | b_pix >> 3;
  558. if (lookup[offset] < 0)
  559. lookup[offset] = bestcolor(r_pix, g_pix, b_pix);
  560. *out = (BYTE)lookup[offset];
  561. r_pix = dith_max[r_pix - palette[0][lookup[offset]]];
  562. g_pix = dith_max[g_pix - palette[1][lookup[offset]]];
  563. b_pix = dith_max[b_pix - palette[2][lookup[offset]]];
  565. #ifdef DITHER2
  566. nextrowerr[0  ]  = (short)r_pix;
  567. thisrowerr[0+3] += (short)r_pix;
  568. nextrowerr[1  ]  = (short)g_pix;
  569. thisrowerr[1+3] += (short)g_pix;
  570. nextrowerr[2  ]  = (short)b_pix;
  571. thisrowerr[2+3] += (short)b_pix;
  572. #else
  573. two_val = r_pix * 2;
  574. nextrowerr[0-3]  = r_pix;
  575. r_pix += two_val;
  576. nextrowerr[0+3] += r_pix;
  577. r_pix += two_val;
  578. nextrowerr[0  ] += r_pix;
  579. r_pix += two_val;
  580. thisrowerr[0+3] += r_pix;
  581. two_val = g_pix * 2;
  582. nextrowerr[1-3]  = g_pix;
  583. g_pix += two_val;
  584. nextrowerr[1+3] += g_pix;
  585. g_pix += two_val;
  586. nextrowerr[1  ] += g_pix;
  587. g_pix += two_val;
  588. thisrowerr[1+3] += g_pix;
  589. two_val = b_pix * 2;
  590. nextrowerr[2-3]  = b_pix;
  591. b_pix += two_val;
  592. nextrowerr[2+3] += b_pix;
  593. b_pix += two_val;
  594. nextrowerr[2  ] += b_pix;
  595. b_pix += two_val;
  596. thisrowerr[2+3] += b_pix;
  597. #endif
  598. thisrowerr += 3;
  599. nextrowerr -= 3;
  600. in  += dir * 3;
  601. out += dir;
  602. }
  604. if ((i % 2) == 1) {
  605. in  += (width + 1) * 3;
  606. out += (width + 1);
  607. }
  609. odd_scanline = !odd_scanline;
  610. }
  612. free(range_tbl);
  613. free(lookup);
  614. free(erowerr);
  615. free(orowerr);
  616. free(dith_max_tbl);
  617. #else
  618. slong i =0; 
  619. slong j=0; 
  620. slong r_pix=0;
  621. slong g_pix=0;
  622. slong b_pix=0;
  623. slong r_err=0;
  624. slong g_err=0;
  625. slong b_err=0;
  626. slong offset=0;
  628. uchar *range_tbl = (BYTE*)malloc(3 * 256), *range = range_tbl + 256;
  629. sshort *lookup = (sshort *)malloc(sizeof(short) * 32768);
  631. if (range_tbl == NULL || lookup == NULL) {
  632. if (range_tbl != NULL)
  633. free(range_tbl);
  634. if (lookup != NULL)
  635. free(lookup);
  636. return 0;
  637. }
  639. for (i = 0; i < 32768; i++)
  640. lookup[i] = -1;
  642. for (i = 0; i < 256; i++) {
  643. range_tbl[i] = 0;
  644. range_tbl[i + 256] = (uchar) i;
  645. range_tbl[i + 512] = 255;
  646. }
  648. for (i = 0; i < height; i++) {
  649. r_err = g_err = b_err = 0;
  650. for (j = width - 1; j >= 0; j--) {
  651. r_pix = range[(r_err >> 1) + in[0]];
  652. g_pix = range[(g_err >> 1) + in[1]];
  653. b_pix = range[(b_err >> 1) + in[2]];
  655. offset = (r_pix&248) << 7 | (g_pix&248) << 2 | b_pix >> 3;
  657. if (lookup[offset] < 0)
  658. lookup[offset] = bestcolor(r_pix, g_pix, b_pix);
  660. *out++ = (BYTE)lookup[offset];
  662. r_err = r_pix - palette[0][lookup[offset]];
  663. g_err = g_pix - palette[1][lookup[offset]];
  664. b_err = b_pix - palette[2][lookup[offset]];
  666. in += 3;
  667. }
  668. }
  670. free(range_tbl);
  671. free(lookup);
  672. #endif
  673.     }
  675.     return 1;
  676. }
  678. LOCAL int bestcolor(int r, int g, int b) 
  679. {
  680.     ulong i=0;
  681. ulong bestcolor=0;
  682. ulong curdist=0;
  683. ulong mindist=0;
  684.     slong rdist=0;
  685. slong gdist=0;
  686. slong bdist=0;
  688.     r = (r & 248) + 4;
  689.     g = (g & 248) + 4;
  690.     b = (b & 248) + 4;
  691.     mindist = 200000;
  693. for (i = 0; i < (ulong)tot_colors; i++) {
  694. rdist = palette[0][i] - r;
  695. gdist = palette[1][i] - g;
  696. bdist = palette[2][i] - b;
  697. curdist = squares[rdist] + squares[gdist] + squares[bdist];
  699. if (curdist < mindist) {
  700. mindist = curdist;
  701. bestcolor = i;
  702. }
  703. }
  704.     return bestcolor;
  705. }
  707. #ifdef __cplusplus
  708. }
  709. #endif