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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
tif_predict.c
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：15k
源码类别：

打印编程

开发平台：

Visual C++

tif_predict.c：源码内容
  1. /* $Id: tif_predict.c,v 1.11 2006/03/03 14:10:09 dron Exp $ */
  3. /*
  4.  * Copyright (c) 1988-1997 Sam Leffler
  5.  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  27. /*
  28.  * TIFF Library.
  29.  *
  30.  * Predictor Tag Support (used by multiple codecs).
  31.  */
  32. #include "tiffiop.h"
  33. #include "tif_predict.h"
  35. #define PredictorState(tif) ((TIFFPredictorState*) (tif)->tif_data)
  37. static void horAcc8(TIFF*, tidata_t, tsize_t);
  38. static void horAcc16(TIFF*, tidata_t, tsize_t);
  39. static void swabHorAcc16(TIFF*, tidata_t, tsize_t);
  40. static void horDiff8(TIFF*, tidata_t, tsize_t);
  41. static void horDiff16(TIFF*, tidata_t, tsize_t);
  42. static void fpAcc(TIFF*, tidata_t, tsize_t);
  43. static void fpDiff(TIFF*, tidata_t, tsize_t);
  44. static int PredictorDecodeRow(TIFF*, tidata_t, tsize_t, tsample_t);
  45. static int PredictorDecodeTile(TIFF*, tidata_t, tsize_t, tsample_t);
  46. static int PredictorEncodeRow(TIFF*, tidata_t, tsize_t, tsample_t);
  47. static int PredictorEncodeTile(TIFF*, tidata_t, tsize_t, tsample_t);
  49. static int
  50. PredictorSetup(TIFF* tif)
  51. {
  52. static const char module[] = "PredictorSetup";
  54. TIFFPredictorState* sp = PredictorState(tif);
  55. TIFFDirectory* td = &tif->tif_dir;
  57. switch (sp->predictor) /* no differencing */
  58. {
  59. case PREDICTOR_NONE:
  60. return 1;
  61. case PREDICTOR_HORIZONTAL:
  62. if (td->td_bitspersample != 8
  63.     && td->td_bitspersample != 16) {
  64. TIFFErrorExt(tif->tif_clientdata, module,
  65.     "Horizontal differencing "Predictor" not supported with %d-bit samples",
  66.   td->td_bitspersample);
  67. return 0;
  68. }
  69. break;
  70. case PREDICTOR_FLOATINGPOINT:
  71. if (td->td_sampleformat != SAMPLEFORMAT_IEEEFP) {
  72. TIFFErrorExt(tif->tif_clientdata, module,
  73. "Floating point "Predictor" not supported with %d data format",
  74.   td->td_sampleformat);
  75. return 0;
  76. }
  77. break;
  78. default:
  79. TIFFErrorExt(tif->tif_clientdata, module,
  80.   ""Predictor" value %d not supported",
  81.   sp->predictor);
  82. return 0;
  83. }
  84. sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
  85.     td->td_samplesperpixel : 1);
  86. /*
  87.  * Calculate the scanline/tile-width size in bytes.
  88.  */
  89. if (isTiled(tif))
  90. sp->rowsize = TIFFTileRowSize(tif);
  91. else
  92. sp->rowsize = TIFFScanlineSize(tif);
  94. return 1;
  95. }
  97. static int
  98. PredictorSetupDecode(TIFF* tif)
  99. {
  100. TIFFPredictorState* sp = PredictorState(tif);
  101. TIFFDirectory* td = &tif->tif_dir;
  103. if (!(*sp->setupdecode)(tif) || !PredictorSetup(tif))
  104. return 0;
  106. if (sp->predictor == 2) {
  107. switch (td->td_bitspersample) {
  108. case 8:  sp->pfunc = horAcc8; break;
  109. case 16: sp->pfunc = horAcc16; break;
  110. }
  111. /*
  112.  * Override default decoding method with one that does the
  113.  * predictor stuff.
  114.  */
  115. sp->coderow = tif->tif_decoderow;
  116. tif->tif_decoderow = PredictorDecodeRow;
  117. sp->codestrip = tif->tif_decodestrip;
  118. tif->tif_decodestrip = PredictorDecodeTile;
  119. sp->codetile = tif->tif_decodetile;
  120. tif->tif_decodetile = PredictorDecodeTile;
  121. /*
  122.  * If the data is horizontally differenced 16-bit data that
  123.  * requires byte-swapping, then it must be byte swapped before
  124.  * the accumulation step.  We do this with a special-purpose
  125.  * routine and override the normal post decoding logic that
  126.  * the library setup when the directory was read.
  127.  */
  128. if (tif->tif_flags & TIFF_SWAB) {
  129. if (sp->pfunc == horAcc16) {
  130. sp->pfunc = swabHorAcc16;
  131. tif->tif_postdecode = _TIFFNoPostDecode;
  132. } /* else handle 32-bit case... */
  133. }
  134. }
  136. else if (sp->predictor == 3) {
  137. sp->pfunc = fpAcc;
  138. /*
  139.  * Override default decoding method with one that does the
  140.  * predictor stuff.
  141.  */
  142. sp->coderow = tif->tif_decoderow;
  143. tif->tif_decoderow = PredictorDecodeRow;
  144. sp->codestrip = tif->tif_decodestrip;
  145. tif->tif_decodestrip = PredictorDecodeTile;
  146. sp->codetile = tif->tif_decodetile;
  147. tif->tif_decodetile = PredictorDecodeTile;
  148. /*
  149.  * The data should not be swapped outside of the floating
  150.  * point predictor, the accumulation routine should return
  151.  * byres in the native order.
  152.  */
  153. if (tif->tif_flags & TIFF_SWAB) {
  154. tif->tif_postdecode = _TIFFNoPostDecode;
  155. }
  156. /*
  157.  * Allocate buffer to keep the decoded bytes before
  158.  * rearranging in the ight order
  159.  */
  160. }
  162. return 1;
  163. }
  165. static int
  166. PredictorSetupEncode(TIFF* tif)
  167. {
  168. TIFFPredictorState* sp = PredictorState(tif);
  169. TIFFDirectory* td = &tif->tif_dir;
  171. if (!(*sp->setupencode)(tif) || !PredictorSetup(tif))
  172. return 0;
  174. if (sp->predictor == 2) {
  175. switch (td->td_bitspersample) {
  176. case 8:  sp->pfunc = horDiff8; break;
  177. case 16: sp->pfunc = horDiff16; break;
  178. }
  179. /*
  180.  * Override default encoding method with one that does the
  181.  * predictor stuff.
  182.  */
  183. sp->coderow = tif->tif_encoderow;
  184. tif->tif_encoderow = PredictorEncodeRow;
  185. sp->codestrip = tif->tif_encodestrip;
  186. tif->tif_encodestrip = PredictorEncodeTile;
  187. sp->codetile = tif->tif_encodetile;
  188. tif->tif_encodetile = PredictorEncodeTile;
  189. }
  191. else if (sp->predictor == 3) {
  192. sp->pfunc = fpDiff;
  193. /*
  194.  * Override default encoding method with one that does the
  195.  * predictor stuff.
  196.  */
  197. sp->coderow = tif->tif_encoderow;
  198. tif->tif_encoderow = PredictorEncodeRow;
  199. sp->codestrip = tif->tif_encodestrip;
  200. tif->tif_encodestrip = PredictorEncodeTile;
  201. sp->codetile = tif->tif_encodetile;
  202. tif->tif_encodetile = PredictorEncodeTile;
  203. }
  205. return 1;
  206. }
  208. #define REPEAT4(n, op)
  209.     switch (n) {
  210.     default: { int i; for (i = n-4; i > 0; i--) { op; } } 
  211.     case 4:  op;
  212.     case 3:  op;
  213.     case 2:  op;
  214.     case 1:  op;
  215.     case 0:  ;
  216.     }
  218. static void
  219. horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc)
  220. {
  221. tsize_t stride = PredictorState(tif)->stride;
  223. char* cp = (char*) cp0;
  224. if (cc > stride) {
  225. cc -= stride;
  226. /*
  227.  * Pipeline the most common cases.
  228.  */
  229. if (stride == 3)  {
  230. unsigned int cr = cp[0];
  231. unsigned int cg = cp[1];
  232. unsigned int cb = cp[2];
  233. do {
  234. cc -= 3, cp += 3;
  235. cp[0] = (char) (cr += cp[0]);
  236. cp[1] = (char) (cg += cp[1]);
  237. cp[2] = (char) (cb += cp[2]);
  238. } while ((int32) cc > 0);
  239. } else if (stride == 4)  {
  240. unsigned int cr = cp[0];
  241. unsigned int cg = cp[1];
  242. unsigned int cb = cp[2];
  243. unsigned int ca = cp[3];
  244. do {
  245. cc -= 4, cp += 4;
  246. cp[0] = (char) (cr += cp[0]);
  247. cp[1] = (char) (cg += cp[1]);
  248. cp[2] = (char) (cb += cp[2]);
  249. cp[3] = (char) (ca += cp[3]);
  250. } while ((int32) cc > 0);
  251. } else  {
  252. do {
  253. REPEAT4(stride, cp[stride] =
  254. (char) (cp[stride] + *cp); cp++)
  255. cc -= stride;
  256. } while ((int32) cc > 0);
  257. }
  258. }
  259. }
  261. static void
  262. swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
  263. {
  264. tsize_t stride = PredictorState(tif)->stride;
  265. uint16* wp = (uint16*) cp0;
  266. tsize_t wc = cc / 2;
  268. if (wc > stride) {
  269. TIFFSwabArrayOfShort(wp, wc);
  270. wc -= stride;
  271. do {
  272. REPEAT4(stride, wp[stride] += wp[0]; wp++)
  273. wc -= stride;
  274. } while ((int32) wc > 0);
  275. }
  276. }
  278. static void
  279. horAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
  280. {
  281. tsize_t stride = PredictorState(tif)->stride;
  282. uint16* wp = (uint16*) cp0;
  283. tsize_t wc = cc / 2;
  285. if (wc > stride) {
  286. wc -= stride;
  287. do {
  288. REPEAT4(stride, wp[stride] += wp[0]; wp++)
  289. wc -= stride;
  290. } while ((int32) wc > 0);
  291. }
  292. }
  294. /*
  295.  * Floating point predictor accumulation routine.
  296.  */
  297. static void
  298. fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc)
  299. {
  300. tsize_t stride = PredictorState(tif)->stride;
  301. uint32 bps = tif->tif_dir.td_bitspersample / 8;
  302. tsize_t wc = cc / bps;
  303. tsize_t count = cc;
  304. uint8 *cp = (uint8 *) cp0;
  305. uint8 *tmp = (uint8 *)_TIFFmalloc(cc);
  307. if (!tmp)
  308. return;
  310. while (count > stride) {
  311. REPEAT4(stride, cp[stride] += cp[0]; cp++)
  312. count -= stride;
  313. }
  315. _TIFFmemcpy(tmp, cp0, cc);
  316. cp = (uint8 *) cp0;
  317. for (count = 0; count < wc; count++) {
  318. uint32 byte;
  319. for (byte = 0; byte < bps; byte++) {
  320. #if WORDS_BIGENDIAN
  321. cp[bps * count + byte] = tmp[byte * wc + count];
  322. #else
  323. cp[bps * count + byte] =
  324. tmp[(bps - byte - 1) * wc + count];
  325. #endif
  326. }
  327. }
  328. _TIFFfree(tmp);
  329. }
  331. /*
  332.  * Decode a scanline and apply the predictor routine.
  333.  */
  334. static int
  335. PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
  336. {
  337. TIFFPredictorState *sp = PredictorState(tif);
  339. assert(sp != NULL);
  340. assert(sp->coderow != NULL);
  341. assert(sp->pfunc != NULL);
  343. if ((*sp->coderow)(tif, op0, occ0, s)) {
  344. (*sp->pfunc)(tif, op0, occ0);
  345. return 1;
  346. } else
  347. return 0;
  348. }
  350. /*
  351.  * Decode a tile/strip and apply the predictor routine.
  352.  * Note that horizontal differencing must be done on a
  353.  * row-by-row basis.  The width of a "row" has already
  354.  * been calculated at pre-decode time according to the
  355.  * strip/tile dimensions.
  356.  */
  357. static int
  358. PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
  359. {
  360. TIFFPredictorState *sp = PredictorState(tif);
  362. assert(sp != NULL);
  363. assert(sp->codetile != NULL);
  365. if ((*sp->codetile)(tif, op0, occ0, s)) {
  366. tsize_t rowsize = sp->rowsize;
  367. assert(rowsize > 0);
  368. assert(sp->pfunc != NULL);
  369. while ((long)occ0 > 0) {
  370. (*sp->pfunc)(tif, op0, (tsize_t) rowsize);
  371. occ0 -= rowsize;
  372. op0 += rowsize;
  373. }
  374. return 1;
  375. } else
  376. return 0;
  377. }
  379. static void
  380. horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc)
  381. {
  382. TIFFPredictorState* sp = PredictorState(tif);
  383. tsize_t stride = sp->stride;
  384. char* cp = (char*) cp0;
  386. if (cc > stride) {
  387. cc -= stride;
  388. /*
  389.  * Pipeline the most common cases.
  390.  */
  391. if (stride == 3) {
  392. int r1, g1, b1;
  393. int r2 = cp[0];
  394. int g2 = cp[1];
  395. int b2 = cp[2];
  396. do {
  397. r1 = cp[3]; cp[3] = r1-r2; r2 = r1;
  398. g1 = cp[4]; cp[4] = g1-g2; g2 = g1;
  399. b1 = cp[5]; cp[5] = b1-b2; b2 = b1;
  400. cp += 3;
  401. } while ((int32)(cc -= 3) > 0);
  402. } else if (stride == 4) {
  403. int r1, g1, b1, a1;
  404. int r2 = cp[0];
  405. int g2 = cp[1];
  406. int b2 = cp[2];
  407. int a2 = cp[3];
  408. do {
  409. r1 = cp[4]; cp[4] = r1-r2; r2 = r1;
  410. g1 = cp[5]; cp[5] = g1-g2; g2 = g1;
  411. b1 = cp[6]; cp[6] = b1-b2; b2 = b1;
  412. a1 = cp[7]; cp[7] = a1-a2; a2 = a1;
  413. cp += 4;
  414. } while ((int32)(cc -= 4) > 0);
  415. } else {
  416. cp += cc - 1;
  417. do {
  418. REPEAT4(stride, cp[stride] -= cp[0]; cp--)
  419. } while ((int32)(cc -= stride) > 0);
  420. }
  421. }
  422. }
  424. static void
  425. horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc)
  426. {
  427. TIFFPredictorState* sp = PredictorState(tif);
  428. tsize_t stride = sp->stride;
  429. int16 *wp = (int16*) cp0;
  430. tsize_t wc = cc/2;
  432. if (wc > stride) {
  433. wc -= stride;
  434. wp += wc - 1;
  435. do {
  436. REPEAT4(stride, wp[stride] -= wp[0]; wp--)
  437. wc -= stride;
  438. } while ((int32) wc > 0);
  439. }
  440. }
  442. /*
  443.  * Floating point predictor differencing routine.
  444.  */
  445. static void
  446. fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc)
  447. {
  448. tsize_t stride = PredictorState(tif)->stride;
  449. uint32 bps = tif->tif_dir.td_bitspersample / 8;
  450. tsize_t wc = cc / bps;
  451. tsize_t count;
  452. uint8 *cp = (uint8 *) cp0;
  453. uint8 *tmp = (uint8 *)_TIFFmalloc(cc);
  455. if (!tmp)
  456. return;
  458. _TIFFmemcpy(tmp, cp0, cc);
  459. for (count = 0; count < wc; count++) {
  460. uint32 byte;
  461. for (byte = 0; byte < bps; byte++) {
  462. #if WORDS_BIGENDIAN
  463. cp[byte * wc + count] = tmp[bps * count + byte];
  464. #else
  465. cp[(bps - byte - 1) * wc + count] =
  466. tmp[bps * count + byte];
  467. #endif
  468. }
  469. }
  470. _TIFFfree(tmp);
  472. cp = (uint8 *) cp0;
  473. cp += cc - stride - 1;
  474. for (count = cc; count > stride; count -= stride)
  475. REPEAT4(stride, cp[stride] -= cp[0]; cp--)
  476. }
  478. static int
  479. PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
  480. {
  481. TIFFPredictorState *sp = PredictorState(tif);
  483. assert(sp != NULL);
  484. assert(sp->pfunc != NULL);
  485. assert(sp->coderow != NULL);
  487. /* XXX horizontal differencing alters user's data XXX */
  488. (*sp->pfunc)(tif, bp, cc);
  489. return (*sp->coderow)(tif, bp, cc, s);
  490. }
  492. static int
  493. PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s)
  494. {
  495. TIFFPredictorState *sp = PredictorState(tif);
  496. tsize_t cc = cc0, rowsize;
  497. unsigned char* bp = bp0;
  499. assert(sp != NULL);
  500. assert(sp->pfunc != NULL);
  501. assert(sp->codetile != NULL);
  503. rowsize = sp->rowsize;
  504. assert(rowsize > 0);
  505. while ((long)cc > 0) {
  506. (*sp->pfunc)(tif, bp, (tsize_t) rowsize);
  507. cc -= rowsize;
  508. bp += rowsize;
  509. }
  510. return (*sp->codetile)(tif, bp0, cc0, s);
  511. }
  513. #define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */
  515. static const TIFFFieldInfo predictFieldInfo[] = {
  516.     { TIFFTAG_PREDICTOR,  1, 1, TIFF_SHORT, FIELD_PREDICTOR,
  517.       FALSE, FALSE, "Predictor" },
  518. };
  519. #define N(a) (sizeof (a) / sizeof (a[0]))
  521. static int
  522. PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap)
  523. {
  524. TIFFPredictorState *sp = PredictorState(tif);
  526. assert(sp != NULL);
  527. assert(sp->vsetparent != NULL);
  529. switch (tag) {
  530. case TIFFTAG_PREDICTOR:
  531. sp->predictor = (uint16) va_arg(ap, int);
  532. TIFFSetFieldBit(tif, FIELD_PREDICTOR);
  533. break;
  534. default:
  535. return (*sp->vsetparent)(tif, tag, ap);
  536. }
  537. tif->tif_flags |= TIFF_DIRTYDIRECT;
  538. return 1;
  539. }
  541. static int
  542. PredictorVGetField(TIFF* tif, ttag_t tag, va_list ap)
  543. {
  544. TIFFPredictorState *sp = PredictorState(tif);
  546. assert(sp != NULL);
  547. assert(sp->vgetparent != NULL);
  549. switch (tag) {
  550. case TIFFTAG_PREDICTOR:
  551. *va_arg(ap, uint16*) = sp->predictor;
  552. break;
  553. default:
  554. return (*sp->vgetparent)(tif, tag, ap);
  555. }
  556. return 1;
  557. }
  559. static void
  560. PredictorPrintDir(TIFF* tif, FILE* fd, long flags)
  561. {
  562. TIFFPredictorState* sp = PredictorState(tif);
  564. (void) flags;
  565. if (TIFFFieldSet(tif,FIELD_PREDICTOR)) {
  566. fprintf(fd, "  Predictor: ");
  567. switch (sp->predictor) {
  568. case 1: fprintf(fd, "none "); break;
  569. case 2: fprintf(fd, "horizontal differencing "); break;
  570. case 3: fprintf(fd, "floating point predictor "); break;
  571. }
  572. fprintf(fd, "%u (0x%x)n", sp->predictor, sp->predictor);
  573. }
  574. if (sp->printdir)
  575. (*sp->printdir)(tif, fd, flags);
  576. }
  578. int
  579. TIFFPredictorInit(TIFF* tif)
  580. {
  581. TIFFPredictorState* sp = PredictorState(tif);
  583. assert(sp != 0);
  585. /*
  586.  * Merge codec-specific tag information and
  587.  * override parent get/set field methods.
  588.  */
  589. _TIFFMergeFieldInfo(tif, predictFieldInfo, N(predictFieldInfo));
  590. sp->vgetparent = tif->tif_tagmethods.vgetfield;
  591. tif->tif_tagmethods.vgetfield =
  592.             PredictorVGetField;/* hook for predictor tag */
  593. sp->vsetparent = tif->tif_tagmethods.vsetfield;
  594. tif->tif_tagmethods.vsetfield =
  595.             PredictorVSetField;/* hook for predictor tag */
  596. sp->printdir = tif->tif_tagmethods.printdir;
  597. tif->tif_tagmethods.printdir =
  598.             PredictorPrintDir; /* hook for predictor tag */
  600. sp->setupdecode = tif->tif_setupdecode;
  601. tif->tif_setupdecode = PredictorSetupDecode;
  602. sp->setupencode = tif->tif_setupencode;
  603. tif->tif_setupencode = PredictorSetupEncode;
  605. sp->predictor = 1; /* default value */
  606. sp->pfunc = NULL; /* no predictor routine */
  607. return 1;
  608. }
  610. int
  611. TIFFPredictorCleanup(TIFF* tif)
  612. {
  613. TIFFPredictorState* sp = PredictorState(tif);
  615. assert(sp != 0);
  617. tif->tif_tagmethods.vgetfield = sp->vgetparent;
  618. tif->tif_tagmethods.vsetfield = sp->vsetparent;
  619. tif->tif_tagmethods.printdir = sp->printdir;
  620. tif->tif_setupdecode = sp->setupdecode;
  621. tif->tif_setupencode = sp->setupencode;
  623. return 1;
  624. }
  626. /* vim: set ts=8 sts=8 sw=8 noet: */