PageRenderTime 90ms CodeModel.GetById 28ms RepoModel.GetById 1ms app.codeStats 2ms

/Source/LibRawLite/internal/dcraw_common.cpp

https://bitbucket.org/tiran/freeimageturbo
C++ | 9243 lines | 8712 code | 382 blank | 149 comment | 2768 complexity | 5e99ac5ef38224ec4d56240b56b1ab94 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-3.0, BSD-2-Clause, LGPL-2.1, MPL-2.0-no-copyleft-exception, GPL-2.0, GPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. /* 
    2. 

  2.   Copyright 2008-2010 LibRaw LLC (info@libraw.org)
    3. 

    4. 

  4. LibRaw is free software; you can redistribute it and/or modify
    5. 

  5. it under the terms of the one of three licenses as you choose:
    6. 

    7. 

  7. 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
    8. 

  8.    (See file LICENSE.LGPL provided in LibRaw distribution archive for details).
    9. 

    10. 

  10. 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
    11. 

  11.    (See file LICENSE.CDDL provided in LibRaw distribution archive for details).
    12. 

    13. 

  13. 3. LibRaw Software License 27032010
    14. 

  14.    (See file LICENSE.LibRaw.pdf provided in LibRaw distribution archive for details).
    15. 

    16. 

  16.    This file is generated from Dave Coffin's dcraw.c
    17. 

  17.    dcraw.c -- Dave Coffin's raw photo decoder
    18. 

  18.    Copyright 1997-2010 by Dave Coffin, dcoffin a cybercom o net
    19. 

    20. 

  20.    Look into dcraw homepage (probably http://cybercom.net/~dcoffin/dcraw/)
    21. 

  21.    for more information
    22. 

  22. */
    23. 

  23. 

  24. #include <math.h>
    25. 

  25. #define CLASS LibRaw::
    26. 

  26. #include "libraw/libraw_types.h"
    27. 

  27. #define LIBRAW_LIBRARY_BUILD
    28. 

  28. #define LIBRAW_IO_REDEFINED
    29. 

  29. #include "libraw/libraw.h"
    30. 

  30. #include "internal/defines.h"
    31. 

  31. #include "internal/var_defines.h"
    32. 

  32. #include "internal/libraw_bytebuffer.h"
    33. 

  33. 

  34. #ifndef __GLIBC__
    35. 

  35. char *my_memmem (char *haystack, size_t haystacklen,
    36. 

  36. 	      char *needle, size_t needlelen)
    37. 

  37. {
    38. 

  38.   char *c;
    39. 

  39.   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
    40. 

  40.     if (!memcmp (c, needle, needlelen))
    41. 

  41.       return c;
    42. 

  42.   return 0;
    43. 

  43. }
    44. 

  44. #define memmem my_memmem
    45. 

  45. #endif
    46. 

  46. 

  47. 

  48. ushort CLASS sget2 (uchar *s)
    49. 

  49. {
    50. 

  50.   if (order == 0x4949)		/* "II" means little-endian */
    51. 

  51.     return s[0] | s[1] << 8;
    52. 

  52.   else				/* "MM" means big-endian */
    53. 

  53.     return s[0] << 8 | s[1];
    54. 

  54. }
    55. 

  55. 

  56. ushort CLASS get2()
    57. 

  57. {
    58. 

  58.   uchar str[2] = { 0xff,0xff };
    59. 

  59.   fread (str, 1, 2, ifp);
    60. 

  60.   return sget2(str);
    61. 

  61. }
    62. 

  62. 

  63. unsigned CLASS sget4 (uchar *s)
    64. 

  64. {
    65. 

  65.   if (order == 0x4949)
    66. 

  66.     return s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
    67. 

  67.   else
    68. 

  68.     return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
    69. 

  69. }
    70. 

  70. #define sget4(s) sget4((uchar *)s)
    71. 

  71. 

  72. unsigned CLASS get4()
    73. 

  73. {
    74. 

  74.   uchar str[4] = { 0xff,0xff,0xff,0xff };
    75. 

  75.   fread (str, 1, 4, ifp);
    76. 

  76.   return sget4(str);
    77. 

  77. }
    78. 

  78. 

  79. unsigned CLASS getint (int type)
    80. 

  80. {
    81. 

  81.   return type == 3 ? get2() : get4();
    82. 

  82. }
    83. 

  83. 

  84. float CLASS int_to_float (int i)
    85. 

  85. {
    86. 

  86.   union { int i; float f; } u;
    87. 

  87.   u.i = i;
    88. 

  88.   return u.f;
    89. 

  89. }
    90. 

  90. 

  91. double CLASS getreal (int type)
    92. 

  92. {
    93. 

  93.   union { char c[8]; double d; } u;
    94. 

  94.   int i, rev;
    95. 

  95. 

  96.   switch (type) {
    97. 

  97.     case 3: return (unsigned short) get2();
    98. 

  98.     case 4: return (unsigned int) get4();
    99. 

  99.     case 5:  u.d = (unsigned int) get4();
    100. 

  100.       return u.d / (unsigned int) get4();
    101. 

  101.     case 8: return (signed short) get2();
    102. 

  102.     case 9: return (signed int) get4();
    103. 

  103.     case 10: u.d = (signed int) get4();
    104. 

  104.       return u.d / (signed int) get4();
    105. 

  105.     case 11: return int_to_float (get4());
    106. 

  106.     case 12:
    107. 

  107.       rev = 7 * ((order == 0x4949) == (ntohs(0x1234) == 0x1234));
    108. 

  108.       for (i=0; i < 8; i++)
    109. 

  109. 	u.c[i ^ rev] = fgetc(ifp);
    110. 

  110.       return u.d;
    111. 

  111.     default: return fgetc(ifp);
    112. 

  112.   }
    113. 

  113. }
    114. 

  114. 

  115. void CLASS read_shorts (ushort *pixel, int count)
    116. 

  116. {
    117. 

  117.   if (fread (pixel, 2, count, ifp) < count) derror();
    118. 

  118.   if ((order == 0x4949) == (ntohs(0x1234) == 0x1234))
    119. 

  119.       swab ((char*)pixel, (char*)pixel, count*2);
    120. 

  120. }
    121. 

  121. 

  122. #ifdef LIBRAW_LIBRARY_BUILD
    123. 

  123. #define RBAYER(x,y) raw_image[(x)*raw_width+(y)]
    124. 

  124. #define RRBAYER(x,y) raw_image[((x)+top_margin)*raw_width+(y)+left_margin]
    125. 

  125. #define CBAYER(x,y) color_image[((x)+top_margin)*raw_width+(y)+left_margin][FC((x),(y))]
    126. 

  126. #else
    127. 

  127. #define CBAYER(x,y) BAYER((x),(y))
    128. 

  128. #define RBAYER(x,y) BAYER((x),(y))
    129. 

  129. #define RRBAYER(x,y) BAYER((x),(y))
    130. 

  130. #endif
    131. 

  131. 

  132. void CLASS canon_600_fixed_wb (int temp)
    133. 

  133. {
    134. 

  134.   static const short mul[4][5] = {
    135. 

  135.     {  667, 358,397,565,452 },
    136. 

  136.     {  731, 390,367,499,517 },
    137. 

  137.     { 1119, 396,348,448,537 },
    138. 

  138.     { 1399, 485,431,508,688 } };
    139. 

  139.   int lo, hi, i;
    140. 

  140.   float frac=0;
    141. 

  141. 

  142.   for (lo=4; --lo; )
    143. 

  143.     if (*mul[lo] <= temp) break;
    144. 

  144.   for (hi=0; hi < 3; hi++)
    145. 

  145.     if (*mul[hi] >= temp) break;
    146. 

  146.   if (lo != hi)
    147. 

  147.     frac = (float) (temp - *mul[lo]) / (*mul[hi] - *mul[lo]);
    148. 

  148.   for (i=1; i < 5; i++)
    149. 

  149.     pre_mul[i-1] = 1 / (frac * mul[hi][i] + (1-frac) * mul[lo][i]);
    150. 

  150. #ifdef LIBRAW_LIBRARY_BUILD
    151. 

  151.   color_flags.pre_mul_state = LIBRAW_COLORSTATE_CONST;
    152. 

  152. #endif
    153. 

  153. }
    154. 

  154. 

  155. /* Return values:  0 = white  1 = near white  2 = not white */
    156. 

  156. int CLASS canon_600_color (int ratio[2], int mar)
    157. 

  157. {
    158. 

  158.   int clipped=0, target, miss;
    159. 

  159. 

  160.   if (flash_used) {
    161. 

  161.     if (ratio[1] < -104)
    162. 

  162.       { ratio[1] = -104; clipped = 1; }
    163. 

  163.     if (ratio[1] >   12)
    164. 

  164.       { ratio[1] =   12; clipped = 1; }
    165. 

  165.   } else {
    166. 

  166.     if (ratio[1] < -264 || ratio[1] > 461) return 2;
    167. 

  167.     if (ratio[1] < -50)
    168. 

  168.       { ratio[1] = -50; clipped = 1; }
    169. 

  169.     if (ratio[1] > 307)
    170. 

  170.       { ratio[1] = 307; clipped = 1; }
    171. 

  171.   }
    172. 

  172.   target = flash_used || ratio[1] < 197
    173. 

  173. 	? -38 - (398 * ratio[1] >> 10)
    174. 

  174. 	: -123 + (48 * ratio[1] >> 10);
    175. 

  175.   if (target - mar <= ratio[0] &&
    176. 

  176.       target + 20  >= ratio[0] && !clipped) return 0;
    177. 

  177.   miss = target - ratio[0];
    178. 

  178.   if (abs(miss) >= mar*4) return 2;
    179. 

  179.   if (miss < -20) miss = -20;
    180. 

  180.   if (miss > mar) miss = mar;
    181. 

  181.   ratio[0] = target - miss;
    182. 

  182.   return 1;
    183. 

  183. }
    184. 

  184. 

  185. void CLASS canon_600_auto_wb()
    186. 

  186. {
    187. 

  187.   int mar, row, col, i, j, st, count[] = { 0,0 };
    188. 

  188.   int test[8], total[2][8], ratio[2][2], stat[2];
    189. 

  189. 

  190.   memset (&total, 0, sizeof total);
    191. 

  191.   i = canon_ev + 0.5;
    192. 

  192.   if      (i < 10) mar = 150;
    193. 

  193.   else if (i > 12) mar = 20;
    194. 

  194.   else mar = 280 - 20 * i;
    195. 

  195.   if (flash_used) mar = 80;
    196. 

  196.   for (row=14; row < height-14; row+=4)
    197. 

  197.     for (col=10; col < width; col+=2) {
    198. 

  198.       for (i=0; i < 8; i++)
    199. 

  199. 	test[(i & 4) + FC(row+(i >> 1),col+(i & 1))] =
    200. 

  200. 		    BAYER(row+(i >> 1),col+(i & 1));
    201. 

  201.       for (i=0; i < 8; i++)
    202. 

  202. 	if (test[i] < 150 || test[i] > 1500) goto next;
    203. 

  203.       for (i=0; i < 4; i++)
    204. 

  204. 	if (abs(test[i] - test[i+4]) > 50) goto next;
    205. 

  205.       for (i=0; i < 2; i++) {
    206. 

  206. 	for (j=0; j < 4; j+=2)
    207. 

  207. 	  ratio[i][j >> 1] = ((test[i*4+j+1]-test[i*4+j]) << 10) / test[i*4+j];
    208. 

  208. 	stat[i] = canon_600_color (ratio[i], mar);
    209. 

  209.       }
    210. 

  210.       if ((st = stat[0] | stat[1]) > 1) goto next;
    211. 

  211.       for (i=0; i < 2; i++)
    212. 

  212. 	if (stat[i])
    213. 

  213. 	  for (j=0; j < 2; j++)
    214. 

  214. 	    test[i*4+j*2+1] = test[i*4+j*2] * (0x400 + ratio[i][j]) >> 10;
    215. 

  215.       for (i=0; i < 8; i++)
    216. 

  216. 	total[st][i] += test[i];
    217. 

  217.       count[st]++;
    218. 

  218. next: ;
    219. 

  219.     }
    220. 

  220.   if (count[0] | count[1]) {
    221. 

  221.     st = count[0]*200 < count[1];
    222. 

  222.     for (i=0; i < 4; i++)
    223. 

  223.       pre_mul[i] = 1.0 / (total[st][i] + total[st][i+4]);
    224. 

  224. #ifdef LIBRAW_LIBRARY_BUILD
    225. 

  225.     color_flags.pre_mul_state = LIBRAW_COLORSTATE_CALCULATED;
    226. 

  226. #endif
    227. 

  227.   }
    228. 

  228. }
    229. 

  229. 

  230. void CLASS canon_600_coeff()
    231. 

  231. {
    232. 

  232.   static const short table[6][12] = {
    233. 

  233.     { -190,702,-1878,2390,   1861,-1349,905,-393, -432,944,2617,-2105  },
    234. 

  234.     { -1203,1715,-1136,1648, 1388,-876,267,245,  -1641,2153,3921,-3409 },
    235. 

  235.     { -615,1127,-1563,2075,  1437,-925,509,3,     -756,1268,2519,-2007 },
    236. 

  236.     { -190,702,-1886,2398,   2153,-1641,763,-251, -452,964,3040,-2528  },
    237. 

  237.     { -190,702,-1878,2390,   1861,-1349,905,-393, -432,944,2617,-2105  },
    238. 

  238.     { -807,1319,-1785,2297,  1388,-876,769,-257,  -230,742,2067,-1555  } };
    239. 

  239.   int t=0, i, c;
    240. 

  240.   float mc, yc;
    241. 

  241. 

  242.   mc = pre_mul[1] / pre_mul[2];
    243. 

  243.   yc = pre_mul[3] / pre_mul[2];
    244. 

  244.   if (mc > 1 && mc <= 1.28 && yc < 0.8789) t=1;
    245. 

  245.   if (mc > 1.28 && mc <= 2) {
    246. 

  246.     if  (yc < 0.8789) t=3;
    247. 

  247.     else if (yc <= 2) t=4;
    248. 

  248.   }
    249. 

  249.   if (flash_used) t=5;
    250. 

  250.   for (raw_color = i=0; i < 3; i++)
    251. 

  251.     FORCC rgb_cam[i][c] = table[t][i*4 + c] / 1024.0;
    252. 

  252. #ifdef LIBRAW_LIBRARY_BUILD
    253. 

  253.   color_flags.rgb_cam_state = LIBRAW_COLORSTATE_CALCULATED;
    254. 

  254. #endif
    255. 

  255. }
    256. 

  256. 

  257. void CLASS canon_600_load_raw()
    258. 

  258. {
    259. 

  259.   uchar  data[1120], *dp;
    260. 

  260.   ushort pixel[896], *pix;
    261. 

  261.   int irow, row, col, val;
    262. 

  262.   static const short mul[4][2] =
    263. 

  263.   { { 1141,1145 }, { 1128,1109 }, { 1178,1149 }, { 1128,1109 } };
    264. 

  264. 

  265.   for (irow=row=0; irow < height; irow++) {
    266. 

  266.     if (fread (data, 1, raw_width*5/4, ifp) < raw_width*5/4) derror();
    267. 

  267.     for (dp=data, pix=pixel; dp < data+1120; dp+=10, pix+=8) {
    268. 

  268.       pix[0] = (dp[0] << 2) + (dp[1] >> 6    );
    269. 

  269.       pix[1] = (dp[2] << 2) + (dp[1] >> 4 & 3);
    270. 

  270.       pix[2] = (dp[3] << 2) + (dp[1] >> 2 & 3);
    271. 

  271.       pix[3] = (dp[4] << 2) + (dp[1]      & 3);
    272. 

  272.       pix[4] = (dp[5] << 2) + (dp[9]      & 3);
    273. 

  273.       pix[5] = (dp[6] << 2) + (dp[9] >> 2 & 3);
    274. 

  274.       pix[6] = (dp[7] << 2) + (dp[9] >> 4 & 3);
    275. 

  275.       pix[7] = (dp[8] << 2) + (dp[9] >> 6    );
    276. 

  276.     }
    277. 

  277. #ifndef LIBRAW_LIBRARY_BUILD
    278. 

  278.     for (col=0; col < width; col++)
    279. 

  279.         {
    280. 

  280.             BAYER(row,col) = pixel[col];
    281. 

  281.         }
    282. 

  282. #else
    283. 

  283.     for (col=0; col < raw_width; col++)
    284. 

  284.             RBAYER(row,col) = pixel[col];
    285. 

  285. #endif
    286. 

  286. 

  287.     for (col=width; col < raw_width; col++)
    288. 

  288.         {
    289. 

  289.             black += pixel[col];
    290. 

  290.         }
    291. 

  291.     if ((row+=2) > height) row = 1;
    292. 

  292.   }
    293. 

  293.   if (raw_width > width)
    294. 

  294.     black = black / ((raw_width - width) * height) - 4;
    295. 

  295. #ifndef LIBRAW_LIBRARY_BUILD
    296. 

  296.   for (row=0; row < height; row++)
    297. 

  297.     for (col=0; col < width; col++) {
    298. 

  298.       if ((val = BAYER(row,col) - black) < 0) val = 0;
    299. 

  299.       val = val * mul[row & 3][col & 1] >> 9;
    300. 

  300.       BAYER(row,col) = val;
    301. 

  301.     }
    302. 

  302. #else
    303. 

  303.   for (row=0; row < height; row++)
    304. 

  304.     for (col=0; col < raw_width; col++) {
    305. 

  305.       if ((val = RBAYER(row,col) - black) < 0) val = 0;
    306. 

  306.       val = val * mul[row & 3][col & 1] >> 9;
    307. 

  307.       RBAYER(row,col) = val;
    308. 

  308.     }
    309. 

  309. 

  310. #endif
    311. 

  311.   canon_600_fixed_wb(1311);
    312. 

  312.   canon_600_auto_wb();
    313. 

  313.   canon_600_coeff();
    314. 

  314.   maximum = (0x3ff - black) * 1109 >> 9;
    315. 

  315.   black = 0;
    316. 

  316. }
    317. 

  317. 

  318. void CLASS remove_zeroes()
    319. 

  319. {
    320. 

  320.   unsigned row, col, tot, n, r, c;
    321. 

  321. 

  322. #ifdef LIBRAW_LIBRARY_BUILD
    323. 

  323.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,0,2);
    324. 

  324. #endif
    325. 

  325.   for (row=0; row < height; row++)
    326. 

  326.     for (col=0; col < width; col++)
    327. 

  327.       if (BAYER(row,col) == 0) {
    328. 

  328. 	tot = n = 0;
    329. 

  329. 	for (r = row-2; r <= row+2; r++)
    330. 

  330. 	  for (c = col-2; c <= col+2; c++)
    331. 

  331. 	    if (r < height && c < width &&
    332. 

  332. 		FC(r,c) == FC(row,col) && BAYER(r,c))
    333. 

  333. 	      tot += (n++,BAYER(r,c));
    334. 

  334. 	if (n) BAYER(row,col) = tot/n;
    335. 

  335.       }
    336. 

  336. #ifdef LIBRAW_LIBRARY_BUILD
    337. 

  337.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,1,2);
    338. 

  338. #endif
    339. 

  339. }
    340. 

  340. 

  341. int CLASS canon_s2is()
    342. 

  342. {
    343. 

  343.   unsigned row;
    344. 

  344. 

  345.   for (row=0; row < 100; row++) {
    346. 

  346.     fseek (ifp, row*3340 + 3284, SEEK_SET);
    347. 

  347.     if (getc(ifp) > 15) return 1;
    348. 

  348.   }
    349. 

  349.   return 0;
    350. 

  350. }
    351. 

  351. 

  352. /*
    353. 

  353.    getbits(-1) initializes the buffer
    354. 

  354.    getbits(n) where 0 <= n <= 25 returns an n-bit integer
    355. 

  355.  */
    356. 

  356. 

  357. unsigned CLASS getbithuff (int nbits, ushort *huff)
    358. 

  358. {
    359. 

  359. #ifdef LIBRAW_NOTHREADS
    360. 

  360.   static unsigned bitbuf=0;
    361. 

  361.   static int vbits=0, reset=0;
    362. 

  362. #else
    363. 

  363. #define bitbuf tls->getbits.bitbuf
    364. 

  364. #define vbits  tls->getbits.vbits
    365. 

  365. #define reset  tls->getbits.reset
    366. 

  366. #endif
    367. 

  367.   unsigned c;
    368. 

  368. 

  369.   if (nbits == -1)
    370. 

  370.     return bitbuf = vbits = reset = 0;
    371. 

  371.   if (nbits == 0 || vbits < 0) return 0;
    372. 

  372.   while (!reset && vbits < nbits && (c = fgetc(ifp)) != EOF &&
    373. 

  373.     !(reset = zero_after_ff && c == 0xff && fgetc(ifp))) {
    374. 

  374.     bitbuf = (bitbuf << 8) + (uchar) c;
    375. 

  375.     vbits += 8;
    376. 

  376.   }
    377. 

  377.   c = bitbuf << (32-vbits) >> (32-nbits);
    378. 

  378.   if (huff) {
    379. 

  379.     vbits -= huff[c] >> 8;
    380. 

  380.     c = (uchar) huff[c];
    381. 

  381.   } else
    382. 

  382.     vbits -= nbits;
    383. 

  383.   if (vbits < 0) derror();
    384. 

  384.   return c;
    385. 

  385. #ifndef LIBRAW_NOTHREADS
    386. 

  386. #undef bitbuf
    387. 

  387. #undef vbits
    388. 

  388. #undef reset
    389. 

  389. #endif
    390. 

  390. }
    391. 

  391. 

  392. #define getbits(n) getbithuff(n,0)
    393. 

  393. #define gethuff(h) getbithuff(*h,h+1)
    394. 

  394. 

  395. /*
    396. 

  396.    Construct a decode tree according to the specification in *source.
    397. 

  397.    The first 16 bytes specify how many codes should be 1-bit, 2-bit
    398. 

  398.    3-bit, etc.  Bytes after that are the leaf values.
    399. 

    400. 

  400.    For example, if the source is
    401. 

    402. 

  402.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    403. 

  403.       0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff  },
    404. 

    405. 

  405.    then the code is
    406. 

    407. 

  407. 	00		0x04
    408. 

  408. 	010		0x03
    409. 

  409. 	011		0x05
    410. 

  410. 	100		0x06
    411. 

  411. 	101		0x02
    412. 

  412. 	1100		0x07
    413. 

  413. 	1101		0x01
    414. 

  414. 	11100		0x08
    415. 

  415. 	11101		0x09
    416. 

  416. 	11110		0x00
    417. 

  417. 	111110		0x0a
    418. 

  418. 	1111110		0x0b
    419. 

  419. 	1111111		0xff
    420. 

  420.  */
    421. 

  421. ushort * CLASS make_decoder_ref (const uchar **source)
    422. 

  422. {
    423. 

  423.   int max, len, h, i, j;
    424. 

  424.   const uchar *count;
    425. 

  425.   ushort *huff;
    426. 

  426. 

  427.   count = (*source += 16) - 17;
    428. 

  428.   for (max=16; max && !count[max]; max--);
    429. 

  429.   huff = (ushort *) calloc (1 + (1 << max), sizeof *huff);
    430. 

  430.   merror (huff, "make_decoder()");
    431. 

  431.   huff[0] = max;
    432. 

  432.   for (h=len=1; len <= max; len++)
    433. 

  433.     for (i=0; i < count[len]; i++, ++*source)
    434. 

  434.       for (j=0; j < 1 << (max-len); j++)
    435. 

  435. 	if (h <= 1 << max)
    436. 

  436. 	  huff[h++] = len << 8 | **source;
    437. 

  437.   return huff;
    438. 

  438. }
    439. 

  439. 

  440. ushort * CLASS make_decoder (const uchar *source)
    441. 

  441. {
    442. 

  442.   return make_decoder_ref (&source);
    443. 

  443. }
    444. 

  444. 

  445. void CLASS crw_init_tables (unsigned table, ushort *huff[2])
    446. 

  446. {
    447. 

  447.   static const uchar first_tree[3][29] = {
    448. 

  448.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    449. 

  449.       0x04,0x03,0x05,0x06,0x02,0x07,0x01,0x08,0x09,0x00,0x0a,0x0b,0xff  },
    450. 

  450.     { 0,2,2,3,1,1,1,1,2,0,0,0,0,0,0,0,
    451. 

  451.       0x03,0x02,0x04,0x01,0x05,0x00,0x06,0x07,0x09,0x08,0x0a,0x0b,0xff  },
    452. 

  452.     { 0,0,6,3,1,1,2,0,0,0,0,0,0,0,0,0,
    453. 

  453. 

  454.       0x06,0x05,0x07,0x04,0x08,0x03,0x09,0x02,0x00,0x0a,0x01,0x0b,0xff  },
    455. 

  455.   };
    456. 

  456.   static const uchar second_tree[3][180] = {
    457. 

  457.     { 0,2,2,2,1,4,2,1,2,5,1,1,0,0,0,139,
    458. 

  458.       0x03,0x04,0x02,0x05,0x01,0x06,0x07,0x08,
    459. 

  459.       0x12,0x13,0x11,0x14,0x09,0x15,0x22,0x00,0x21,0x16,0x0a,0xf0,
    460. 

  460.       0x23,0x17,0x24,0x31,0x32,0x18,0x19,0x33,0x25,0x41,0x34,0x42,
    461. 

  461.       0x35,0x51,0x36,0x37,0x38,0x29,0x79,0x26,0x1a,0x39,0x56,0x57,
    462. 

  462.       0x28,0x27,0x52,0x55,0x58,0x43,0x76,0x59,0x77,0x54,0x61,0xf9,
    463. 

  463.       0x71,0x78,0x75,0x96,0x97,0x49,0xb7,0x53,0xd7,0x74,0xb6,0x98,
    464. 

  464.       0x47,0x48,0x95,0x69,0x99,0x91,0xfa,0xb8,0x68,0xb5,0xb9,0xd6,
    465. 

  465.       0xf7,0xd8,0x67,0x46,0x45,0x94,0x89,0xf8,0x81,0xd5,0xf6,0xb4,
    466. 

  466.       0x88,0xb1,0x2a,0x44,0x72,0xd9,0x87,0x66,0xd4,0xf5,0x3a,0xa7,
    467. 

  467.       0x73,0xa9,0xa8,0x86,0x62,0xc7,0x65,0xc8,0xc9,0xa1,0xf4,0xd1,
    468. 

  468.       0xe9,0x5a,0x92,0x85,0xa6,0xe7,0x93,0xe8,0xc1,0xc6,0x7a,0x64,
    469. 

  469.       0xe1,0x4a,0x6a,0xe6,0xb3,0xf1,0xd3,0xa5,0x8a,0xb2,0x9a,0xba,
    470. 

  470.       0x84,0xa4,0x63,0xe5,0xc5,0xf3,0xd2,0xc4,0x82,0xaa,0xda,0xe4,
    471. 

  471.       0xf2,0xca,0x83,0xa3,0xa2,0xc3,0xea,0xc2,0xe2,0xe3,0xff,0xff  },
    472. 

  472.     { 0,2,2,1,4,1,4,1,3,3,1,0,0,0,0,140,
    473. 

  473.       0x02,0x03,0x01,0x04,0x05,0x12,0x11,0x06,
    474. 

  474.       0x13,0x07,0x08,0x14,0x22,0x09,0x21,0x00,0x23,0x15,0x31,0x32,
    475. 

  475.       0x0a,0x16,0xf0,0x24,0x33,0x41,0x42,0x19,0x17,0x25,0x18,0x51,
    476. 

  476.       0x34,0x43,0x52,0x29,0x35,0x61,0x39,0x71,0x62,0x36,0x53,0x26,
    477. 

  477.       0x38,0x1a,0x37,0x81,0x27,0x91,0x79,0x55,0x45,0x28,0x72,0x59,
    478. 

  478.       0xa1,0xb1,0x44,0x69,0x54,0x58,0xd1,0xfa,0x57,0xe1,0xf1,0xb9,
    479. 

  479.       0x49,0x47,0x63,0x6a,0xf9,0x56,0x46,0xa8,0x2a,0x4a,0x78,0x99,
    480. 

  480.       0x3a,0x75,0x74,0x86,0x65,0xc1,0x76,0xb6,0x96,0xd6,0x89,0x85,
    481. 

  481.       0xc9,0xf5,0x95,0xb4,0xc7,0xf7,0x8a,0x97,0xb8,0x73,0xb7,0xd8,
    482. 

  482.       0xd9,0x87,0xa7,0x7a,0x48,0x82,0x84,0xea,0xf4,0xa6,0xc5,0x5a,
    483. 

  483.       0x94,0xa4,0xc6,0x92,0xc3,0x68,0xb5,0xc8,0xe4,0xe5,0xe6,0xe9,
    484. 

  484.       0xa2,0xa3,0xe3,0xc2,0x66,0x67,0x93,0xaa,0xd4,0xd5,0xe7,0xf8,
    485. 

  485.       0x88,0x9a,0xd7,0x77,0xc4,0x64,0xe2,0x98,0xa5,0xca,0xda,0xe8,
    486. 

  486.       0xf3,0xf6,0xa9,0xb2,0xb3,0xf2,0xd2,0x83,0xba,0xd3,0xff,0xff  },
    487. 

  487.     { 0,0,6,2,1,3,3,2,5,1,2,2,8,10,0,117,
    488. 

  488.       0x04,0x05,0x03,0x06,0x02,0x07,0x01,0x08,
    489. 

  489.       0x09,0x12,0x13,0x14,0x11,0x15,0x0a,0x16,0x17,0xf0,0x00,0x22,
    490. 

  490.       0x21,0x18,0x23,0x19,0x24,0x32,0x31,0x25,0x33,0x38,0x37,0x34,
    491. 

  491.       0x35,0x36,0x39,0x79,0x57,0x58,0x59,0x28,0x56,0x78,0x27,0x41,
    492. 

  492.       0x29,0x77,0x26,0x42,0x76,0x99,0x1a,0x55,0x98,0x97,0xf9,0x48,
    493. 

  493.       0x54,0x96,0x89,0x47,0xb7,0x49,0xfa,0x75,0x68,0xb6,0x67,0x69,
    494. 

  494.       0xb9,0xb8,0xd8,0x52,0xd7,0x88,0xb5,0x74,0x51,0x46,0xd9,0xf8,
    495. 

  495.       0x3a,0xd6,0x87,0x45,0x7a,0x95,0xd5,0xf6,0x86,0xb4,0xa9,0x94,
    496. 

  496.       0x53,0x2a,0xa8,0x43,0xf5,0xf7,0xd4,0x66,0xa7,0x5a,0x44,0x8a,
    497. 

  497.       0xc9,0xe8,0xc8,0xe7,0x9a,0x6a,0x73,0x4a,0x61,0xc7,0xf4,0xc6,
    498. 

  498.       0x65,0xe9,0x72,0xe6,0x71,0x91,0x93,0xa6,0xda,0x92,0x85,0x62,
    499. 

  499.       0xf3,0xc5,0xb2,0xa4,0x84,0xba,0x64,0xa5,0xb3,0xd2,0x81,0xe5,
    500. 

  500.       0xd3,0xaa,0xc4,0xca,0xf2,0xb1,0xe4,0xd1,0x83,0x63,0xea,0xc3,
    501. 

  501.       0xe2,0x82,0xf1,0xa3,0xc2,0xa1,0xc1,0xe3,0xa2,0xe1,0xff,0xff  }
    502. 

  502.   };
    503. 

  503.   if (table > 2) table = 2;
    504. 

  504.   huff[0] = make_decoder ( first_tree[table]);
    505. 

  505.   huff[1] = make_decoder (second_tree[table]);
    506. 

  506. }
    507. 

  507. 

  508. /*
    509. 

  509.    Return 0 if the image starts with compressed data,
    510. 

  510.    1 if it starts with uncompressed low-order bits.
    511. 

    512. 

  512.    In Canon compressed data, 0xff is always followed by 0x00.
    513. 

  513.  */
    514. 

  514. int CLASS canon_has_lowbits()
    515. 

  515. {
    516. 

  516.   uchar test[0x4000];
    517. 

  517.   int ret=1;
    518. 

  518.   unsigned i;
    519. 

  519. 

  520.   fseek (ifp, 0, SEEK_SET);
    521. 

  521.   fread (test, 1, sizeof test, ifp);
    522. 

  522.   for (i=540; i < sizeof test - 1; i++)
    523. 

  523.     if (test[i] == 0xff) {
    524. 

  524.       if (test[i+1]) return 1;
    525. 

  525.       ret=0;
    526. 

  526.     }
    527. 

  527.   return ret;
    528. 

  528. }
    529. 

  529. 

  530. void CLASS canon_compressed_load_raw()
    531. 

  531. {
    532. 

  532.   ushort *pixel, *prow, *huff[2];
    533. 

  533.   int nblocks, lowbits, i, c, row, r, col, save, val;
    534. 

  534.   unsigned irow, icol;
    535. 

  535.   int block, diffbuf[64], leaf, len, diff, carry=0, pnum=0, base[2];
    536. 

  536. 

  537.   crw_init_tables (tiff_compress, huff);
    538. 

  538.   pixel = (ushort *) calloc (raw_width*8, sizeof *pixel);
    539. 

  539.   merror (pixel, "canon_compressed_load_raw()");
    540. 

  540.   lowbits = canon_has_lowbits();
    541. 

  541.   if (!lowbits) maximum = 0x3ff;
    542. 

  542.   fseek (ifp, 540 + lowbits*raw_height*raw_width/4, SEEK_SET);
    543. 

  543.   zero_after_ff = 1;
    544. 

  544.   getbits(-1);
    545. 

  545.   for (row=0; row < raw_height; row+=8) {
    546. 

  546.     nblocks = MIN (8, raw_height-row) * raw_width >> 6;
    547. 

  547.     for (block=0; block < nblocks; block++) {
    548. 

  548.       memset (diffbuf, 0, sizeof diffbuf);
    549. 

  549.       for (i=0; i < 64; i++ ) {
    550. 

  550. 	leaf = gethuff(huff[i > 0]);
    551. 

  551. 	if (leaf == 0 && i) break;
    552. 

  552. 	if (leaf == 0xff) continue;
    553. 

  553. 	i  += leaf >> 4;
    554. 

  554. 	len = leaf & 15;
    555. 

  555. 	if (len == 0) continue;
    556. 

  556. 	diff = getbits(len);
    557. 

  557. 	if ((diff & (1 << (len-1))) == 0)
    558. 

  558. 	  diff -= (1 << len) - 1;
    559. 

  559. 	if (i < 64) diffbuf[i] = diff;
    560. 

  560.       }
    561. 

  561.       diffbuf[0] += carry;
    562. 

  562.       carry = diffbuf[0];
    563. 

  563.       for (i=0; i < 64; i++ ) {
    564. 

  564. 	if (pnum++ % raw_width == 0)
    565. 

  565. 	  base[0] = base[1] = 512;
    566. 

  566. 	if ((pixel[(block << 6) + i] = base[i & 1] += diffbuf[i]) >> 10)
    567. 

  567. 	  derror();
    568. 

  568.       }
    569. 

  569.     }
    570. 

  570.     if (lowbits) {
    571. 

  571.       save = ftell(ifp);
    572. 

  572.       fseek (ifp, 26 + row*raw_width/4, SEEK_SET);
    573. 

  573.       for (prow=pixel, i=0; i < raw_width*2; i++) {
    574. 

  574. 	c = fgetc(ifp);
    575. 

  575. 	for (r=0; r < 8; r+=2, prow++) {
    576. 

  576. 	  val = (*prow << 2) + ((c >> r) & 3);
    577. 

  577. 	  if (raw_width == 2672 && val < 512) val += 2;
    578. 

  578. 	  *prow = val;
    579. 

  579. 	}
    580. 

  580.       }
    581. 

  581.       fseek (ifp, save, SEEK_SET);
    582. 

  582.     }
    583. 

  583. 

  584. #ifdef LIBRAW_LIBRARY_BUILD
    585. 

  585.     for (r=0; r < 8; r++) {
    586. 

  586.         if(row+r>=raw_height) break; // Not sure that raw_height is always N*8
    587. 

  587.         // MOVE entire row into place
    588. 

  588.         memmove(&raw_image[(row+r)*raw_width],&pixel[r*raw_width],raw_width*sizeof(pixel[0]));
    589. 

  589. 

  590.         irow = row - top_margin + r;
    591. 

  591.         if (irow >= height) continue; // if row above image area than irow is VERY positive :)
    592. 

  592. 

  593.         // only margins!
    594. 

  594.         for (col=0; col < left_margin; col++) 
    595. 

  595.             {
    596. 

  596.                 icol = col - left_margin;
    597. 

  597.                 c = FC(irow,icol);
    598. 

  598.                 if (icol >= width && col > 1 && (unsigned) (col-left_margin+2) > width+3)
    599. 

  599.                     cblack[c] += (cblack[4+c]++,pixel[r*raw_width+col]);
    600. 

  600.             }
    601. 

  601.         for (col=width+left_margin; col < raw_width; col++) 
    602. 

  602.             {
    603. 

  603.                 icol = col - left_margin;
    604. 

  604.                 c = FC(irow,icol);
    605. 

  605.                 if (icol >= width && col > 1 && (unsigned) (col-left_margin+2) > width+3)
    606. 

  606.                     cblack[c] += (cblack[4+c]++,pixel[r*raw_width+col]);
    607. 

  607.             }
    608. 

  608. 

  609.     }
    610. 

  610. #else
    611. 

  611.     // dcraw original code
    612. 

  612.     for (r=0; r < 8; r++) {
    613. 

  613.       irow = row - top_margin + r;
    614. 

  614.       if (irow >= height) continue;
    615. 

  615.       for (col=0; col < raw_width; col++) {
    616. 

  616. 	icol = col - left_margin;
    617. 

  617. 	c = FC(irow,icol);
    618. 

  618. 	if (icol < width)
    619. 

  619. 	  BAYER(irow,icol) = pixel[r*raw_width+col];
    620. 

  620. 	else if (col > 1 && (unsigned) (col-left_margin+2) > width+3)
    621. 

  621. 	  cblack[c] += (cblack[4+c]++,pixel[r*raw_width+col]);
    622. 

  622.       }
    623. 

  623.     }
    624. 

  624. #endif
    625. 

  625.   }
    626. 

  626.   free (pixel);
    627. 

  627.   FORC(2) free (huff[c]);
    628. 

  628.   FORC4 if (cblack[4+c]) cblack[c] /= cblack[4+c];
    629. 

  629. }
    630. 

  630. 

  631. int CLASS ljpeg_start (struct jhead *jh, int info_only)
    632. 

  632. {
    633. 

  633.   int c, tag, len;
    634. 

  634.   uchar data[0x10000];
    635. 

  635.   const uchar *dp;
    636. 

  636. 

  637.   memset (jh, 0, sizeof *jh);
    638. 

  638.   jh->restart = INT_MAX;
    639. 

  639.   fread (data, 2, 1, ifp);
    640. 

  640.   if (data[1] != 0xd8) return 0;
    641. 

  641.   do {
    642. 

  642.     fread (data, 2, 2, ifp);
    643. 

  643.     tag =  data[0] << 8 | data[1];
    644. 

  644.     len = (data[2] << 8 | data[3]) - 2;
    645. 

  645.     if (tag <= 0xff00) return 0;
    646. 

  646.     fread (data, 1, len, ifp);
    647. 

  647.     switch (tag) {
    648. 

  648.       case 0xffc3:
    649. 

  649. 	jh->sraw = ((data[7] >> 4) * (data[7] & 15) - 1) & 3;
    650. 

  650.       case 0xffc0:
    651. 

  651. 	jh->bits = data[0];
    652. 

  652. 	jh->high = data[1] << 8 | data[2];
    653. 

  653. 	jh->wide = data[3] << 8 | data[4];
    654. 

  654. 	jh->clrs = data[5] + jh->sraw;
    655. 

  655. 	if (len == 9 && !dng_version) getc(ifp);
    656. 

  656. 	break;
    657. 

  657.       case 0xffc4:
    658. 

  658. 	if (info_only) break;
    659. 

  659. 	for (dp = data; dp < data+len && (c = *dp++) < 4; )
    660. 

  660. 	  jh->free[c] = jh->huff[c] = make_decoder_ref (&dp);
    661. 

  661. 	break;
    662. 

  662.       case 0xffda:
    663. 

  663. 	jh->psv = data[1+data[0]*2];
    664. 

  664. 	jh->bits -= data[3+data[0]*2] & 15;
    665. 

  665. 	break;
    666. 

  666.       case 0xffdd:
    667. 

  667. 	jh->restart = data[0] << 8 | data[1];
    668. 

  668.     }
    669. 

  669.   } while (tag != 0xffda);
    670. 

  670.   if (info_only) return 1;
    671. 

  671.   FORC(5) if (!jh->huff[c+1]) jh->huff[c+1] = jh->huff[c];
    672. 

  672.   if (jh->sraw) {
    673. 

  673.     FORC(4)        jh->huff[2+c] = jh->huff[1];
    674. 

  674.     FORC(jh->sraw) jh->huff[1+c] = jh->huff[0];
    675. 

  675.   }
    676. 

  676.   jh->row = (ushort *) calloc (jh->wide*jh->clrs, 4);
    677. 

  677.   merror (jh->row, "ljpeg_start()");
    678. 

  678.   return zero_after_ff = 1;
    679. 

  679. }
    680. 

  680. 

  681. void CLASS ljpeg_end (struct jhead *jh)
    682. 

  682. {
    683. 

  683.   int c;
    684. 

  684.   FORC4 if (jh->free[c]) free (jh->free[c]);
    685. 

  685.   free (jh->row);
    686. 

  686. }
    687. 

  687. 

  688. // used for kodak-262 decoder
    689. 

  689. int CLASS ljpeg_diff (ushort *huff)
    690. 

  690. {
    691. 

  691.   int len, diff;
    692. 

  692. 

  693.   len = gethuff(huff);
    694. 

  694.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    695. 

  695.     return -32768;
    696. 

  696.   diff = getbits(len);
    697. 

  697.   if ((diff & (1 << (len-1))) == 0)
    698. 

  698.     diff -= (1 << len) - 1;
    699. 

  699.   return diff;
    700. 

  700. }
    701. 

  701. 

  702. #ifdef LIBRAW_LIBRARY_BUILD
    703. 

  703. int CLASS ljpeg_diff_new (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    704. 

  704. {
    705. 

  705.   int len, diff;
    706. 

  706. 

  707.   len = bits._gethuff_lj(buf,*huff,huff+1);
    708. 

  708.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    709. 

  709.     return -32768;
    710. 

  710.   diff = bits._getbits_lj(buf,len);
    711. 

  711.   if ((diff & (1 << (len-1))) == 0)
    712. 

  712.     diff -= (1 << len) - 1;
    713. 

  713.   return diff;
    714. 

  714. }
    715. 

  715. 

  716. int CLASS ljpeg_diff_pef (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    717. 

  717. {
    718. 

  718.   int len, diff;
    719. 

  719. 

  720.   len = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    721. 

  721.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    722. 

  722.     return -32768;
    723. 

  723.   diff = bits._getbits(buf,len,zero_after_ff);
    724. 

  724.   if ((diff & (1 << (len-1))) == 0)
    725. 

  725.     diff -= (1 << len) - 1;
    726. 

  726.   return diff;
    727. 

  727. }
    728. 

  728. 

  729. 

  730. #endif
    731. 

  731. 

  732. 

  733. ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
    734. 

  734. {
    735. 

  735.   int col, c, diff, pred, spred=0;
    736. 

  736.   ushort mark=0, *row[3];
    737. 

  737. 

  738.   if (jrow * jh->wide % jh->restart == 0) {
    739. 

  739.     FORC(6) jh->vpred[c] = 1 << (jh->bits-1);
    740. 

  740.     if (jrow) {
    741. 

  741.       fseek (ifp, -2, SEEK_CUR);
    742. 

  742.       do mark = (mark << 8) + (c = fgetc(ifp));
    743. 

  743.       while (c != EOF && mark >> 4 != 0xffd);
    744. 

  744.     }
    745. 

  745.     getbits(-1);
    746. 

  746.   }
    747. 

  747.   FORC3 row[c] = jh->row + jh->wide*jh->clrs*((jrow+c) & 1);
    748. 

  748.   for (col=0; col < jh->wide; col++)
    749. 

  749.     FORC(jh->clrs) {
    750. 

  750.       diff = ljpeg_diff (jh->huff[c]);
    751. 

  751.       if (jh->sraw && c <= jh->sraw && (col | c))
    752. 

  752. 		    pred = spred;
    753. 

  753.       else if (col) pred = row[0][-jh->clrs];
    754. 

  754.       else	    pred = (jh->vpred[c] += diff) - diff;
    755. 

  755.       if (jrow && col) switch (jh->psv) {
    756. 

  756. 	case 1:	break;
    757. 

  757. 	case 2: pred = row[1][0];					break;
    758. 

  758. 	case 3: pred = row[1][-jh->clrs];				break;
    759. 

  759. 	case 4: pred = pred +   row[1][0] - row[1][-jh->clrs];		break;
    760. 

  760. 	case 5: pred = pred + ((row[1][0] - row[1][-jh->clrs]) >> 1);	break;
    761. 

  761. 	case 6: pred = row[1][0] + ((pred - row[1][-jh->clrs]) >> 1);	break;
    762. 

  762. 	case 7: pred = (pred + row[1][0]) >> 1;				break;
    763. 

  763. 	default: pred = 0;
    764. 

  764.       }
    765. 

  765.       if ((**row = pred + diff) >> jh->bits) derror();
    766. 

  766.       if (c <= jh->sraw) spred = **row;
    767. 

  767.       row[0]++; row[1]++;
    768. 

  768.     }
    769. 

  769.   return row[2];
    770. 

  770. }
    771. 

  771. 

  772. #ifdef LIBRAW_LIBRARY_BUILD
    773. 

  773. ushort * CLASS ljpeg_row_new (int jrow, struct jhead *jh, LibRaw_bit_buffer& bits,LibRaw_byte_buffer* bytes)
    774. 

  774. {
    775. 

  775.   int col, c, diff, pred, spred=0;
    776. 

  776.   ushort mark=0, *row[3];
    777. 

  777. 

  778.   if (jrow * jh->wide % jh->restart == 0) {
    779. 

  779.     FORC(6) jh->vpred[c] = 1 << (jh->bits-1);
    780. 

  780.     if (jrow) {
    781. 

  781.         bytes->unseek2();
    782. 

  782.         do mark = (mark << 8) + (c = bytes->get_byte());
    783. 

  783.         while (c != EOF && mark >> 4 != 0xffd);
    784. 

  784.     }
    785. 

  785.     bits.reset();
    786. 

  786.   }
    787. 

  787.   FORC3 row[c] = jh->row + jh->wide*jh->clrs*((jrow+c) & 1);
    788. 

  788.   for (col=0; col < jh->wide; col++)
    789. 

  789.     FORC(jh->clrs) {
    790. 

  790.         diff = ljpeg_diff_new (bits,bytes,jh->huff[c]);
    791. 

  791.       if (jh->sraw && c <= jh->sraw && (col | c))
    792. 

  792. 		    pred = spred;
    793. 

  793.       else if (col) pred = row[0][-jh->clrs];
    794. 

  794.       else	    pred = (jh->vpred[c] += diff) - diff;
    795. 

  795.       if (jrow && col) switch (jh->psv) {
    796. 

  796. 	case 1:	break;
    797. 

  797. 	case 2: pred = row[1][0];					break;
    798. 

  798. 	case 3: pred = row[1][-jh->clrs];				break;
    799. 

  799. 	case 4: pred = pred +   row[1][0] - row[1][-jh->clrs];		break;
    800. 

  800. 	case 5: pred = pred + ((row[1][0] - row[1][-jh->clrs]) >> 1);	break;
    801. 

  801. 	case 6: pred = row[1][0] + ((pred - row[1][-jh->clrs]) >> 1);	break;
    802. 

  802. 	case 7: pred = (pred + row[1][0]) >> 1;				break;
    803. 

  803. 	default: pred = 0;
    804. 

  804.       }
    805. 

  805.       if ((**row = pred + diff) >> jh->bits) derror();
    806. 

  806.       if (c <= jh->sraw) spred = **row;
    807. 

  807.       row[0]++; row[1]++;
    808. 

  808.     }
    809. 

  809.   return row[2];
    810. 

  810. }
    811. 

  811. 

  812. #endif
    813. 

  813. 

  814. void CLASS lossless_jpeg_load_raw()
    815. 

  815. {
    816. 

  816.   int jwide, jrow, jcol, val, c, i, row=0, col=0;
    817. 

  817. #ifndef LIBRAW_LIBRARY_BUILD
    818. 

  818.   int jidx,j;
    819. 

  819. #endif
    820. 

  820.   struct jhead jh;
    821. 

  821.   int min=INT_MAX;
    822. 

  822.   ushort *rp;
    823. 

  823. #ifdef LIBRAW_LIBRARY_BUILD
    824. 

  824.   int save_min = 0;
    825. 

  825.   unsigned slicesW[16],slicesWcnt=0,slices;
    826. 

  826.   unsigned *offset;
    827. 

  827.   unsigned t_y=0,t_x=0,t_s=0,slice=0,pixelsInSlice,pixno;
    828. 

  828.   if (!strcasecmp(make,"KODAK"))
    829. 

  829.       save_min = 1;
    830. 

  830. #endif
    831. 

  831. 

  832. #ifdef LIBRAW_LIBRARY_BUILD
    833. 

  833.   if (cr2_slice[0]>15)
    834. 

  834.       throw LIBRAW_EXCEPTION_IO_EOF; // change many slices
    835. 

  835. #else
    836. 

  836.   fprintf(stderr,"Too many CR2 slices: %d\n",cr2_slice[0]+1);
    837. 

  837.   return;
    838. 

  838. #endif
    839. 

  839. 

  840. 

  841.   if (!ljpeg_start (&jh, 0)) return;
    842. 

  842.   jwide = jh.wide * jh.clrs;
    843. 

  843. 

  844. #ifdef LIBRAW_LIBRARY_BUILD
    845. 

  845.   if(cr2_slice[0])
    846. 

  846.       {
    847. 

  847.           for(i=0;i<cr2_slice[0];i++)
    848. 

  848.               slicesW[slicesWcnt++] = cr2_slice[1];
    849. 

  849.           slicesW[slicesWcnt++] = cr2_slice[2];
    850. 

  850.       }
    851. 

  851.   else
    852. 

  852.       {
    853. 

  853.           // not sliced
    854. 

  854.           slicesW[slicesWcnt++] = raw_width; // safe fallback
    855. 

  855.       }
    856. 

  856.        
    857. 

  857.   slices = slicesWcnt * jh.high;
    858. 

  858.   offset = (unsigned*)calloc(slices+1,sizeof(offset[0]));
    859. 

  859.   
    860. 

  860.   for(slice=0;slice<slices;slice++)
    861. 

  861.       {
    862. 

  862.           offset[slice] = (t_x + t_y * raw_width)| (t_s<<28);
    863. 

  863.           if(offset[slice] & 0x0fffffff >= raw_width * raw_height)
    864. 

  864.               throw LIBRAW_EXCEPTION_IO_BADFILE; 
    865. 

  865.           t_y++;
    866. 

  866.           if(t_y == jh.high)
    867. 

  867.               {
    868. 

  868.                   t_y = 0;
    869. 

  869.                   t_x += slicesW[t_s++];
    870. 

  870.               }
    871. 

  871.       }
    872. 

  872.   offset[slices] = offset[slices-1];
    873. 

  873.   slice = 1; // next slice
    874. 

  874.   pixno = offset[0];
    875. 

  875.   pixelsInSlice = slicesW[0];
    876. 

  876. #endif
    877. 

  877. 

  878. #ifdef LIBRAW_LIBRARY_BUILD
    879. 

  879.   LibRaw_byte_buffer *buf=NULL;
    880. 

  880.   if(data_size)
    881. 

  881.       buf = ifp->make_byte_buffer(data_size);
    882. 

  882.   LibRaw_bit_buffer bits;
    883. 

  883. #endif
    884. 

  884.   for (jrow=0; jrow < jh.high; jrow++) {
    885. 

  885. #ifdef LIBRAW_LIBRARY_BUILD
    886. 

  886.       if (data_size)
    887. 

  887.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    888. 

  888.       else
    889. 

  889. #endif
    890. 

  890.     rp = ljpeg_row (jrow, &jh);
    891. 

  891. 

  892.     if (load_flags & 1)
    893. 

  893.       row = jrow & 1 ? height-1-jrow/2 : jrow/2;
    894. 

  894.     for (jcol=0; jcol < jwide; jcol++) {
    895. 

  895.       val = *rp++;
    896. 

  896.       if (jh.bits <= 12)
    897. 

  897. 	val = curve[val & 0xfff];
    898. 

  898. #ifndef LIBRAW_LIBRARY_BUILD
    899. 

  899.       // slow dcraw way to calculate row/col
    900. 

  900.       if (cr2_slice[0]) {
    901. 

  901. 	jidx = jrow*jwide + jcol;
    902. 

  902. 	i = jidx / (cr2_slice[1]*jh.high);
    903. 

  903. 	if ((j = i >= cr2_slice[0]))
    904. 

  904. 		 i  = cr2_slice[0];
    905. 

  905. 	jidx -= i * (cr2_slice[1]*jh.high);
    906. 

  906. 	row = jidx / cr2_slice[1+j];
    907. 

  907. 	col = jidx % cr2_slice[1+j] + i*cr2_slice[1];
    908. 

  908.       }
    909. 

  909. #else
    910. 

  910.       // new fast one, but for data_size defined only (i.e. new CR2 format, not 1D/1Ds)
    911. 

  911.       if(data_size) 
    912. 

  912.           {
    913. 

  913.               row = pixno/raw_width;
    914. 

  914.               col = pixno % raw_width;
    915. 

  915.               pixno++;
    916. 

  916.               if (0 == --pixelsInSlice)
    917. 

  917.                   {
    918. 

  918.                       unsigned o = offset[slice++];
    919. 

  919.                       pixno = o & 0x0fffffff;
    920. 

  920.                       pixelsInSlice = slicesW[o>>28];
    921. 

  921.                   }
    922. 

  922.           }
    923. 

  923. #endif
    924. 

  924. #ifndef LIBRAW_LIBRARY_BUILD
    925. 

  925. 

  926.       if (raw_width == 3984 && (col -= 2) < 0)
    927. 

  927.               col += (row--,raw_width);
    928. 

  928. 

  929.       if ((unsigned) (row-top_margin) < height) {
    930. 

  930. 	c = FC(row-top_margin,col-left_margin);
    931. 

  931. 	if ((unsigned) (col-left_margin) < width) {
    932. 

  932. 	  BAYER(row-top_margin,col-left_margin) = val;
    933. 

  933. 	  if (min > val) min = val;
    934. 

  934. 	} else if (col > 1 && (unsigned) (col-left_margin+2) > width+3)
    935. 

  935. 	  cblack[c] += (cblack[4+c]++,val);
    936. 

  936.       }
    937. 

  937. #else
    938. 

  938.       if (raw_width == 3984)
    939. 

  939.           {
    940. 

  940.               if ( (col -= 2) < 0)
    941. 

  941.                   col += (row--,raw_width);
    942. 

  942.               if(row >= 0 && row < raw_height && col >= 0 && col < raw_width)
    943. 

  943.                   RBAYER(row,col) = val;
    944. 

  944.           }
    945. 

  945.       else 
    946. 

  946.           RBAYER(row,col) = val;
    947. 

  947. 

  948.       if ((unsigned) (row-top_margin) < height) 
    949. 

  949.           {
    950. 

  950.               // within image height
    951. 

  951.               if ((unsigned) (col-left_margin) < width) 
    952. 

  952.                   {
    953. 

  953.                       // within image area, save min
    954. 

  954.                       if(save_min)
    955. 

  955.                           if (min > val) min = val;
    956. 

  956.                   } 
    957. 

  957.               else if (col > 1 && (unsigned) (col-left_margin+2) > width+3) 
    958. 

  958.                   {
    959. 

  959.                       c = FC(row-top_margin,col-left_margin);
    960. 

  960.                       cblack[c] += (cblack[4+c]++,val);
    961. 

  961.                   }
    962. 

  962.           }
    963. 

  963. #endif
    964. 

  964. 

  965. #ifndef LIBRAW_LIBRARY_BUILD
    966. 

  966.       if (++col >= raw_width)
    967. 

  967. 	col = (row++,0);
    968. 

  968. #else
    969. 

  969.       if(!data_size) // 1D or 1Ds case
    970. 

  970.           if (++col >= raw_width)
    971. 

  971.               col = (row++,0);
    972. 

  972. #endif
    973. 

  973.     }
    974. 

  974.   }
    975. 

  975.   ljpeg_end (&jh);
    976. 

  976.   FORC4 if (cblack[4+c]) cblack[c] /= cblack[4+c];
    977. 

  977.   if (!strcasecmp(make,"KODAK"))
    978. 

  978.     black = min;
    979. 

  979. #ifdef LIBRAW_LIBRARY_BUILD
    980. 

  980.   if(buf)
    981. 

  981.       delete buf;
    982. 

  982.   free(offset);
    983. 

  983. #endif
    984. 

  984. }
    985. 

  985. 

  986. void CLASS canon_sraw_load_raw()
    987. 

  987. {
    988. 

  988.   struct jhead jh;
    989. 

  989.   short *rp=0, (*ip)[4];
    990. 

  990.   int jwide, slice, scol, ecol, row, col, jrow=0, jcol=0, pix[3], c;
    991. 

  991.   int v[3]={0,0,0}, ver, hue;
    992. 

  992.   char *cp;
    993. 

  993. 

  994.   if (!ljpeg_start (&jh, 0)) return;
    995. 

  995.   jwide = (jh.wide >>= 1) * jh.clrs;
    996. 

  996. 

  997. #ifdef LIBRAW_LIBRARY_BUILD
    998. 

  998.   if(!data_size)
    999. 

  999.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1000. 

  1000.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1001. 

  1001.   LibRaw_bit_buffer bits;
    1002. 

  1002. #endif
    1003. 

  1003. 

  1004. 

  1005.   for (ecol=slice=0; slice <= cr2_slice[0]; slice++) {
    1006. 

  1006.     scol = ecol;
    1007. 

  1007.     ecol += cr2_slice[1] * 2 / jh.clrs;
    1008. 

  1008.     if (!cr2_slice[0] || ecol > raw_width-1) ecol = raw_width & -2;
    1009. 

  1009.     for (row=0; row < height; row += (jh.clrs >> 1) - 1) {
    1010. 

  1010.       ip = (short (*)[4]) image + row*width;
    1011. 

  1011.       for (col=scol; col < ecol; col+=2, jcol+=jh.clrs) {
    1012. 

  1012. 	if ((jcol %= jwide) == 0)
    1013. 

  1013. #ifdef LIBRAW_LIBRARY_BUILD
    1014. 

  1014.             rp = (short*) ljpeg_row_new (jrow++, &jh,bits,buf);
    1015. 

  1015. #else
    1016. 

  1016.             rp = (short *) ljpeg_row (jrow++, &jh);
    1017. 

  1017. #endif
    1018. 

  1018. 	if (col >= width) continue;
    1019. 

  1019. 	FORC (jh.clrs-2)
    1020. 

  1020. 	  ip[col + (c >> 1)*width + (c & 1)][0] = rp[jcol+c];
    1021. 

  1021. 	ip[col][1] = rp[jcol+jh.clrs-2] - 16384;
    1022. 

  1022. 	ip[col][2] = rp[jcol+jh.clrs-1] - 16384;
    1023. 

  1023.       }
    1024. 

  1024.     }
    1025. 

  1025.   }
    1026. 

  1026.   for (cp=model2; *cp && !isdigit(*cp); cp++);
    1027. 

  1027.   sscanf (cp, "%d.%d.%d", v, v+1, v+2);
    1028. 

  1028.   ver = (v[0]*1000 + v[1])*1000 + v[2];
    1029. 

  1029.   hue = (jh.sraw+1) << 2;
    1030. 

  1030.   if (unique_id >= 0x80000281 || (unique_id == 0x80000218 && ver > 1000006))
    1031. 

  1031.     hue = jh.sraw << 1;
    1032. 

  1032.   ip = (short (*)[4]) image;
    1033. 

  1033.   rp = ip[0];
    1034. 

  1034.   for (row=0; row < height; row++, ip+=width) {
    1035. 

  1035.     if (row & (jh.sraw >> 1))
    1036. 

  1036.       for (col=0; col < width; col+=2)
    1037. 

  1037. 	for (c=1; c < 3; c++)
    1038. 

  1038. 	  if (row == height-1)
    1039. 

  1039. 	       ip[col][c] =  ip[col-width][c];
    1040. 

  1040. 	  else ip[col][c] = (ip[col-width][c] + ip[col+width][c] + 1) >> 1;
    1041. 

  1041.     for (col=1; col < width; col+=2)
    1042. 

  1042.       for (c=1; c < 3; c++)
    1043. 

  1043. 	if (col == width-1)
    1044. 

  1044. 	     ip[col][c] =  ip[col-1][c];
    1045. 

  1045. 	else ip[col][c] = (ip[col-1][c] + ip[col+1][c] + 1) >> 1;
    1046. 

  1046.   }
    1047. 

  1047.   for ( ; rp < ip[0]; rp+=4) {
    1048. 

  1048.     if (unique_id < 0x80000218) {
    1049. 

  1049.       pix[0] = rp[0] + rp[2] - 512;
    1050. 

  1050.       pix[2] = rp[0] + rp[1] - 512;
    1051. 

  1051.       pix[1] = rp[0] + ((-778*rp[1] - (rp[2] << 11)) >> 12) - 512;
    1052. 

  1052.     } else {
    1053. 

  1053.       rp[1] = (rp[1] << 2) + hue;
    1054. 

  1054.       rp[2] = (rp[2] << 2) + hue;
    1055. 

  1055.       pix[0] = rp[0] + ((   50*rp[1] + 22929*rp[2]) >> 14);
    1056. 

  1056.       pix[1] = rp[0] + ((-5640*rp[1] - 11751*rp[2]) >> 14);
    1057. 

  1057.       pix[2] = rp[0] + ((29040*rp[1] -   101*rp[2]) >> 14);
    1058. 

  1058.     }
    1059. 

  1059.     FORC3 
    1060. 

  1060.         rp[c] = CLIP(pix[c] * sraw_mul[c] >> 10);
    1061. 

  1061.   }
    1062. 

  1062. #ifdef LIBRAW_LIBRARY_BUILD
    1063. 

  1063.   delete buf;
    1064. 

  1064. #endif
    1065. 

  1065.   ljpeg_end (&jh);
    1066. 

  1066.   maximum = 0x3fff;
    1067. 

  1067. }
    1068. 

  1068. 

  1069. void CLASS adobe_copy_pixel (int row, int col, ushort **rp)
    1070. 

  1070. {
    1071. 

  1071.   unsigned r, c;
    1072. 

  1072. 

  1073. #ifndef LIBRAW_LIBRARY_BUILD
    1074. 

  1074.   r = row -= top_margin;
    1075. 

  1075.   c = col -= left_margin;
    1076. 

  1076.   if (is_raw == 2 && shot_select) (*rp)++;
    1077. 

  1077.   if (filters) {
    1078. 

  1078.     if (fuji_width) {
    1079. 

  1079.       r = row + fuji_width - 1 - (col >> 1);
    1080. 

  1080.       c = row + ((col+1) >> 1);
    1081. 

  1081.     }
    1082. 

  1082.     if (r < height && c < width)
    1083. 

  1083.       BAYER(r,c) = **rp < 0x1000 ? curve[**rp] : **rp;
    1084. 

  1084.     *rp += is_raw;
    1085. 

  1085.   } else {
    1086. 

  1086.     if (r < height && c < width)
    1087. 

  1087.       FORC(tiff_samples)
    1088. 

  1088. 	image[row*width+col][c] = (*rp)[c] < 0x1000 ? curve[(*rp)[c]]:(*rp)[c];
    1089. 

  1089.     *rp += tiff_samples;
    1090. 

  1090.   }
    1091. 

  1091. #else
    1092. 

  1092.   if (is_raw == 2 && shot_select) (*rp)++;
    1093. 

  1093.   if (filters) {
    1094. 

  1094.       if(row < raw_height && col < raw_width)
    1095. 

  1095.           RBAYER(row,col) = **rp < 0x1000 ? curve[**rp] : **rp;
    1096. 

  1096.     *rp += is_raw;
    1097. 

  1097.   } else {
    1098. 

  1098.       if (row < raw_height && col < raw_width)
    1099. 

  1099.           FORC(tiff_samples)
    1100. 

  1100.               color_image[row*raw_width+col][c] = (*rp)[c]<0x1000 ? curve[(*rp)[c]]:(*rp)[c];
    1101. 

  1101.       *rp += tiff_samples;
    1102. 

  1102.   }
    1103. 

  1103. 

  1104. #endif
    1105. 

  1105.   if (is_raw == 2 && shot_select) (*rp)--;
    1106. 

  1106. 

  1107. }
    1108. 

  1108. 

  1109. void CLASS adobe_dng_load_raw_lj()
    1110. 

  1110. {
    1111. 

  1111.   unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col;
    1112. 

  1112.   struct jhead jh;
    1113. 

  1113.   ushort *rp;
    1114. 

  1114.   while (trow < raw_height) {
    1115. 

  1115.     save = ftell(ifp);
    1116. 

  1116.     if (tile_length < INT_MAX)
    1117. 

  1117.       fseek (ifp, get4(), SEEK_SET);
    1118. 

  1118.     if (!ljpeg_start (&jh, 0)) break;
    1119. 

  1119.     jwide = jh.wide;
    1120. 

  1120.     if (filters) jwide *= jh.clrs;
    1121. 

  1121.     jwide /= is_raw;
    1122. 

  1122. #ifdef LIBRAW_LIBRARY_BUILD
    1123. 

  1123.     if(!data_size)
    1124. 

  1124.         throw LIBRAW_EXCEPTION_IO_BADFILE;
    1125. 

  1125.     LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1126. 

  1126.     LibRaw_bit_buffer bits;
    1127. 

  1127. #endif
    1128. 

  1128.     for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1129. 

  1129. #ifdef LIBRAW_LIBRARY_BUILD
    1130. 

  1130.         rp = ljpeg_row_new (jrow, &jh,bits,buf);
    1131. 

  1131. #else
    1132. 

  1132.         rp = ljpeg_row (jrow, &jh);
    1133. 

  1133. #endif
    1134. 

  1134.       for (jcol=0; jcol < jwide; jcol++) {
    1135. 

  1135. 	adobe_copy_pixel (trow+row, tcol+col, &rp);
    1136. 

  1136. 	if (++col >= tile_width || col >= raw_width)
    1137. 

  1137. 	  row += 1 + (col = 0);
    1138. 

  1138.       }
    1139. 

  1139.     }
    1140. 

  1140.     fseek (ifp, save+4, SEEK_SET);
    1141. 

  1141.     if ((tcol += tile_width) >= raw_width)
    1142. 

  1142.       trow += tile_length + (tcol = 0);
    1143. 

  1143.     ljpeg_end (&jh);
    1144. 

  1144. #ifdef LIBRAW_LIBRARY_BUILD
    1145. 

  1145.     delete buf;
    1146. 

  1146. #endif
    1147. 

  1147.   }
    1148. 

  1148. }
    1149. 

  1149. 

  1150. void CLASS adobe_dng_load_raw_nc()
    1151. 

  1151. {
    1152. 

  1152.   ushort *pixel, *rp;
    1153. 

  1153.   int row, col;
    1154. 

  1154. 

  1155.   pixel = (ushort *) calloc (raw_width * tiff_samples, sizeof *pixel);
    1156. 

  1156.   merror (pixel, "adobe_dng_load_raw_nc()");
    1157. 

  1157. 

  1158. 

  1159. #ifdef LIBRAW_LIBRARY_BUILD
    1160. 

  1160.   int dsz= raw_height*raw_width * tiff_samples * tiff_bps/8;
    1161. 

  1161.   LibRaw_byte_buffer *buf = NULL;
    1162. 

  1162.   if (tiff_bps != 16)
    1163. 

  1163.       {
    1164. 

  1164.           buf = ifp->make_byte_buffer(dsz);
    1165. 

  1165.       }
    1166. 

  1166.   LibRaw_bit_buffer bits;
    1167. 

  1167. #endif
    1168. 

  1168. 

  1169.   for (row=0; row < raw_height; row++) {
    1170. 

  1170.     if (tiff_bps == 16)
    1171. 

  1171.       read_shorts (pixel, raw_width * tiff_samples);
    1172. 

  1172.     else {
    1173. 

  1173. #ifdef LIBRAW_LIBRARY_BUILD
    1174. 

  1174.         bits.reset();
    1175. 

  1175.         for (col=0; col < raw_width * tiff_samples; col++)
    1176. 

  1176.             pixel[col] = bits._getbits(buf,tiff_bps,zero_after_ff);
    1177. 

  1177. 

  1178. #else
    1179. 

  1179.       getbits(-1);
    1180. 

  1180.       for (col=0; col < raw_width * tiff_samples; col++)
    1181. 

  1181. 	pixel[col] = getbits(tiff_bps);
    1182. 

  1182. #endif
    1183. 

  1183.     }
    1184. 

  1184.     for (rp=pixel, col=0; col < raw_width; col++)
    1185. 

  1185.       adobe_copy_pixel (row, col, &rp);
    1186. 

  1186.   }
    1187. 

  1187.   free (pixel);
    1188. 

  1188. #ifdef LIBRAW_LIBRARY_BUILD
    1189. 

  1189.     if(buf)
    1190. 

  1190.         delete buf;
    1191. 

  1191. #endif
    1192. 

  1192. }
    1193. 

  1193. 

  1194. void CLASS pentax_load_raw()
    1195. 

  1195. {
    1196. 

  1196.   ushort bit[2][15], huff[4097];
    1197. 

  1197.   int dep, row, col, diff, c, i;
    1198. 

  1198.   ushort vpred[2][2] = {{0,0},{0,0}}, hpred[2];
    1199. 

  1199. 

  1200.   fseek (ifp, meta_offset, SEEK_SET);
    1201. 

  1201.   dep = (get2() + 12) & 15;
    1202. 

  1202.   fseek (ifp, 12, SEEK_CUR);
    1203. 

  1203.   FORC(dep) bit[0][c] = get2();
    1204. 

  1204.   FORC(dep) bit[1][c] = fgetc(ifp);
    1205. 

  1205.   FORC(dep)
    1206. 

  1206.     for (i=bit[0][c]; i <= ((bit[0][c]+(4096 >> bit[1][c])-1) & 4095); )
    1207. 

  1207.       huff[++i] = bit[1][c] << 8 | c;
    1208. 

  1208.   huff[0] = 12;
    1209. 

  1209.   fseek (ifp, data_offset, SEEK_SET);
    1210. 

  1210. #ifdef LIBRAW_LIBRARY_BUILD
    1211. 

  1211.   if(!data_size)
    1212. 

  1212.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1213. 

  1213.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1214. 

  1214.   LibRaw_bit_buffer bits;
    1215. 

  1215.   bits.reset();
    1216. 

  1216. #else
    1217. 

  1217.   getbits(-1);
    1218. 

  1218. #endif
    1219. 

  1219.   for (row=0; row < raw_height; row++)
    1220. 

  1220.       {
    1221. 

  1221.           for (col=0; col < raw_width; col++) {
    1222. 

  1222. #ifdef LIBRAW_LIBRARY_BUILD
    1223. 

  1223.               diff = ljpeg_diff_pef(bits,buf,huff);
    1224. 

  1224. #else
    1225. 

  1225.               diff = ljpeg_diff (huff);
    1226. 

  1226. #endif
    1227. 

  1227.               if (col < 2) hpred[col] = vpred[row & 1][col] += diff;
    1228. 

  1228.               else	   hpred[col & 1] += diff;
    1229. 

  1229. 

  1230.               unsigned val = hpred[col & 1];
    1231. 

  1231. 

  1232. #ifndef LIBRAW_LIBRARY_BUILD
    1233. 

  1233.               if ((unsigned) (row-top_margin) < height && 
    1234. 

  1234.                   (unsigned)(col-left_margin) < width)
    1235. 

  1235.                   BAYER(row-top_margin,col-left_margin) = val;
    1236. 

  1236. #else
    1237. 

  1237.               RBAYER(row,col) = val;
    1238. 

  1238. #endif
    1239. 

  1239.               if (val >> tiff_bps) derror();
    1240. 

  1240.           }
    1241. 

  1241.       }
    1242. 

  1242. #ifdef LIBRAW_LIBRARY_BUILD
    1243. 

  1243.   delete buf;
    1244. 

  1244. #endif
    1245. 

  1245. }
    1246. 

  1246. 

  1247. void CLASS nikon_compressed_load_raw()
    1248. 

  1248. {
    1249. 

  1249.   static const uchar nikon_tree[][32] = {
    1250. 

  1250.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy */
    1251. 

  1251.       5,4,3,6,2,7,1,0,8,9,11,10,12 },
    1252. 

  1252.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy after split */
    1253. 

  1253.       0x39,0x5a,0x38,0x27,0x16,5,4,3,2,1,0,11,12,12 },
    1254. 

  1254.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,  /* 12-bit lossless */
    1255. 

  1255.       5,4,6,3,7,2,8,1,9,0,10,11,12 },
    1256. 

  1256.     { 0,1,4,3,1,1,1,1,1,2,0,0,0,0,0,0,	/* 14-bit lossy */
    1257. 

  1257.       5,6,4,7,8,3,9,2,1,0,10,11,12,13,14 },
    1258. 

  1258.     { 0,1,5,1,1,1,1,1,1,1,2,0,0,0,0,0,	/* 14-bit lossy after split */
    1259. 

  1259.       8,0x5c,0x4b,0x3a,0x29,7,6,5,4,3,2,1,0,13,14 },
    1260. 

  1260.     { 0,1,4,2,2,3,1,2,0,0,0,0,0,0,0,0,	/* 14-bit lossless */
    1261. 

  1261.       7,6,8,5,9,4,10,3,11,12,2,0,1,13,14 } };
    1262. 

  1262.   ushort *huff, ver0, ver1, vpred[2][2], hpred[2], csize;
    1263. 

  1263.   int i, min, max, step=0, tree=0, split=0, row, col, len, shl, diff;
    1264. 

  1264. 

  1265.   fseek (ifp, meta_offset, SEEK_SET);
    1266. 

  1266.   ver0 = fgetc(ifp);
    1267. 

  1267.   ver1 = fgetc(ifp);
    1268. 

  1268.   if (ver0 == 0x49 || ver1 == 0x58)
    1269. 

  1269.     fseek (ifp, 2110, SEEK_CUR);
    1270. 

  1270.   if (ver0 == 0x46) tree = 2;
    1271. 

  1271.   if (tiff_bps == 14) tree += 3;
    1272. 

  1272.   read_shorts (vpred[0], 4);
    1273. 

  1273.   max = 1 << tiff_bps & 0x7fff;
    1274. 

  1274.   if ((csize = get2()) > 1)
    1275. 

  1275.     step = max / (csize-1);
    1276. 

  1276.   if (ver0 == 0x44 && ver1 == 0x20 && step > 0) {
    1277. 

  1277.     for (i=0; i < csize; i++)
    1278. 

  1278.       curve[i*step] = get2();
    1279. 

  1279.     for (i=0; i < max; i++)
    1280. 

  1280.       curve[i] = ( curve[i-i%step]*(step-i%step) +
    1281. 

  1281. 		   curve[i-i%step+step]*(i%step) ) / step;
    1282. 

  1282. #ifdef LIBRAW_LIBRARY_BUILD
    1283. 

  1283.     color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    1284. 

  1284. #endif
    1285. 

  1285.     fseek (ifp, meta_offset+562, SEEK_SET);
    1286. 

  1286.     split = get2();
    1287. 

  1287.   } else if (ver0 != 0x46 && csize <= 0x4001)
    1288. 

  1288.       {
    1289. 

  1289.     read_shorts (curve, max=csize);
    1290. 

  1290. #ifdef LIBRAW_LIBRARY_BUILD
    1291. 

  1291.     color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    1292. 

  1292. #endif
    1293. 

  1293.       }
    1294. 

  1294.   while (curve[max-2] == curve[max-1]) max--;
    1295. 

  1295.   huff = make_decoder (nikon_tree[tree]);
    1296. 

  1296.   fseek (ifp, data_offset, SEEK_SET);
    1297. 

  1297. #ifdef LIBRAW_LIBRARY_BUILD
    1298. 

  1298.   if(!data_size)
    1299. 

  1299.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1300. 

  1300.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1301. 

  1301.   LibRaw_bit_buffer bits;
    1302. 

  1302.   bits.reset();
    1303. 

  1303. #else
    1304. 

  1304.   getbits(-1);
    1305. 

  1305. #endif
    1306. 

  1306.   for (min=row=0; row < height; row++) {
    1307. 

  1307.     if (split && row == split) {
    1308. 

  1308.       free (huff);
    1309. 

  1309.       huff = make_decoder (nikon_tree[tree+1]);
    1310. 

  1310.       max += (min = 16) << 1;
    1311. 

  1311.     }
    1312. 

  1312.     for (col=0; col < raw_width; col++) {
    1313. 

  1313. #ifdef LIBRAW_LIBRARY_BUILD
    1314. 

  1314.         i = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    1315. 

  1315. #else
    1316. 

  1316.       i = gethuff(huff);
    1317. 

  1317. #endif
    1318. 

  1318.       len = i & 15;
    1319. 

  1319.       shl = i >> 4;
    1320. 

  1320. #ifdef LIBRAW_LIBRARY_BUILD
    1321. 

  1321.       diff = ((bits._getbits(buf,len-shl,zero_after_ff) << 1) + 1) << shl >> 1;
    1322. 

  1322. #else
    1323. 

  1323.       diff = ((getbits(len-shl) << 1) + 1) << shl >> 1;
    1324. 

  1324. #endif
    1325. 

  1325.       if ((diff & (1 << (len-1))) == 0)
    1326. 

  1326. 	diff -= (1 << len) - !shl;
    1327. 

  1327.       if (col < 2) hpred[col] = vpred[row & 1][col] += diff;
    1328. 

  1328.       else	   hpred[col & 1] += diff;
    1329. 

  1329.       if ((ushort)(hpred[col & 1] + min) >= max) derror();
    1330. 

  1330. #ifndef LIBRAW_LIBRARY_BUILD
    1331. 

  1331.       if ((unsigned) (col-left_margin) < width)
    1332. 

  1332. 	BAYER(row,col-left_margin) =  curve[LIM((short)hpred[col & 1],0,0x3fff)];
    1333. 

  1333. #else
    1334. 

  1334.       ushort xval = hpred[col & 1];
    1335. 

  1335.       xval = curve[LIM((short)xval,0,0x3fff)];
    1336. 

  1336.       RBAYER(row,col) = xval;
    1337. 

  1337. #endif
    1338. 

  1338. 

  1339.     }
    1340. 

  1340.   }
    1341. 

  1341. #ifdef LIBRAW_LIBRARY_BUILD
    1342. 

  1342.   delete buf;
    1343. 

  1343. #endif
    1344. 

  1344.   free (huff);
    1345. 

  1345. }
    1346. 

  1346. 

  1347. /*
    1348. 

  1348.    Figure out if a NEF file is compressed.  These fancy heuristics
    1349. 

  1349.    are only needed for the D100, thanks to a bug in some cameras
    1350. 

  1350.    that tags all images as "compressed".
    1351. 

  1351.  */
    1352. 

  1352. int CLASS nikon_is_compressed()
    1353. 

  1353. {
    1354. 

  1354.   uchar test[256];
    1355. 

  1355.   int i;
    1356. 

  1356. 

  1357.   fseek (ifp, data_offset, SEEK_SET);
    1358. 

  1358.   fread (test, 1, 256, ifp);
    1359. 

  1359.   for (i=15; i < 256; i+=16)
    1360. 

  1360.     if (test[i]) return 1;
    1361. 

  1361.   return 0;
    1362. 

  1362. }
    1363. 

  1363. 

  1364. /*
    1365. 

  1365.    Returns 1 for a Coolpix 995, 0 for anything else.
    1366. 

  1366.  */
    1367. 

  1367. int CLASS nikon_e995()
    1368. 

  1368. {
    1369. 

  1369.   int i, histo[256];
    1370. 

  1370.   const uchar often[] = { 0x00, 0x55, 0xaa, 0xff };
    1371. 

  1371. 

  1372.   memset (histo, 0, sizeof histo);
    1373. 

  1373.   fseek (ifp, -2000, SEEK_END);
    1374. 

  1374.   for (i=0; i < 2000; i++)
    1375. 

  1375.     histo[fgetc(ifp)]++;
    1376. 

  1376.   for (i=0; i < 4; i++)
    1377. 

  1377.     if (histo[often[i]] < 200)
    1378. 

  1378.       return 0;
    1379. 

  1379.   return 1;
    1380. 

  1380. }
    1381. 

  1381. 

  1382. /*
    1383. 

  1383.    Returns 1 for a Coolpix 2100, 0 for anything else.
    1384. 

  1384.  */
    1385. 

  1385. int CLASS nikon_e2100()
    1386. 

  1386. {
    1387. 

  1387.   uchar t[12];
    1388. 

  1388.   int i;
    1389. 

  1389. 

  1390.   fseek (ifp, 0, SEEK_SET);
    1391. 

  1391.   for (i=0; i < 1024; i++) {
    1392. 

  1392.     fread (t, 1, 12, ifp);
    1393. 

  1393.     if (((t[2] & t[4] & t[7] & t[9]) >> 4
    1394. 

  1394. 	& t[1] & t[6] & t[8] & t[11] & 3) != 3)
    1395. 

  1395.       return 0;
    1396. 

  1396.   }
    1397. 

  1397.   return 1;
    1398. 

  1398. }
    1399. 

  1399. 

  1400. void CLASS nikon_3700()
    1401. 

  1401. {
    1402. 

  1402.   int bits, i;
    1403. 

  1403.   uchar dp[24];
    1404. 

  1404.   static const struct {
    1405. 

  1405.     int bits;
    1406. 

  1406.     char t_make[12], t_model[15];
    1407. 

  1407.   } table[] = {
    1408. 

  1408.     { 0x00, "PENTAX",  "Optio 33WR" },
    1409. 

  1409.     { 0x03, "NIKON",   "E3200" },
    1410. 

  1410.     { 0x32, "NIKON",   "E3700" },
    1411. 

  1411.     { 0x33, "OLYMPUS", "C740UZ" } };
    1412. 

  1412. 

  1413.   fseek (ifp, 3072, SEEK_SET);
    1414. 

  1414.   fread (dp, 1, 24, ifp);
    1415. 

  1415.   bits = (dp[8] & 3) << 4 | (dp[20] & 3);
    1416. 

  1416.   for (i=0; i < sizeof table / sizeof *table; i++)
    1417. 

  1417.     if (bits == table[i].bits) {
    1418. 

  1418.       strcpy (make,  table[i].t_make );
    1419. 

  1419.       strcpy (model, table[i].t_model);
    1420. 

  1420.     }
    1421. 

  1421. }
    1422. 

  1422. 

  1423. /*
    1424. 

  1424.    Separates a Minolta DiMAGE Z2 from a Nikon E4300.
    1425. 

  1425.  */
    1426. 

  1426. int CLASS minolta_z2()
    1427. 

  1427. {
    1428. 

  1428.   int i, nz;
    1429. 

  1429.   char tail[424];
    1430. 

  1430. 

  1431.   fseek (ifp, -sizeof tail, SEEK_END);
    1432. 

  1432.   fread (tail, 1, sizeof tail, ifp);
    1433. 

  1433.   for (nz=i=0; i < sizeof tail; i++)
    1434. 

  1434.     if (tail[i]) nz++;
    1435. 

  1435.   return nz > 20;
    1436. 

  1436. }
    1437. 

  1437. 

  1438. /*
    1439. 

  1439.    The Fuji Super CCD is just a Bayer grid rotated 45 degrees.
    1440. 

  1440.  */
    1441. 

  1441. void CLASS fuji_load_raw()
    1442. 

  1442. {
    1443. 

  1443. #ifndef LIBRAW_LIBRARY_BUILD
    1444. 

  1444.   ushort *pixel;
    1445. 

  1445.   int wide, row, col, r, c;
    1446. 

  1446. 

  1447.   fseek (ifp, (top_margin*raw_width + left_margin) * 2, SEEK_CUR);
    1448. 

  1448.   wide = fuji_width << !fuji_layout;
    1449. 

  1449.   pixel = (ushort *) calloc (wide, sizeof *pixel);
    1450. 

  1450.   merror (pixel, "fuji_load_raw()");
    1451. 

  1451.   for (row=0; row < raw_height; row++) {
    1452. 

  1452.     read_shorts (pixel, wide);
    1453. 

  1453.     fseek (ifp, 2*(raw_width - wide), SEEK_CUR);
    1454. 

  1454.     for (col=0; col < wide; col++) {
    1455. 

  1455.       if (fuji_layout) {
    1456. 

  1456. 	r = fuji_width - 1 - col + (row >> 1);
    1457. 

  1457. 	c = col + ((row+1) >> 1);
    1458. 

  1458.       } else {
    1459. 

  1459. 	r = fuji_width - 1 + row - (col >> 1);
    1460. 

  1460. 	c = row + ((col+1) >> 1);
    1461. 

  1461.       }
    1462. 

  1462.       BAYER(r,c) = pixel[col];
    1463. 

  1463.     }
    1464. 

  1464.   }
    1465. 

  1465.   free (pixel);
    1466. 

  1466. #else
    1467. 

  1467.   read_shorts(raw_image,raw_width*raw_height);
    1468. 

  1468. #endif
    1469. 

  1469. }
    1470. 

  1470. void CLASS ppm_thumb()
    1471. 

  1471. {
    1472. 

  1472.   char *thumb;
    1473. 

  1473.   thumb_length = thumb_width*thumb_height*3;
    1474. 

  1474.   thumb = (char *) malloc (thumb_length);
    1475. 

  1475.   merror (thumb, "ppm_thumb()");
    1476. 

  1476.   fprintf (ofp, "P6\n%d %d\n255\n", thumb_width, thumb_height);
    1477. 

  1477.   fread  (thumb, 1, thumb_length, ifp);
    1478. 

  1478.   fwrite (thumb, 1, thumb_length, ofp);
    1479. 

  1479.   free (thumb);
    1480. 

  1480. }
    1481. 

  1481. 

  1482. void CLASS layer_thumb()
    1483. 

  1483. {
    1484. 

  1484.   int i, c;
    1485. 

  1485.   char *thumb, map[][4] = { "012","102" };
    1486. 

  1486. 

  1487.   colors = thumb_misc >> 5 & 7;
    1488. 

  1488.   thumb_length = thumb_width*thumb_height;
    1489. 

  1489.   thumb = (char *) calloc (colors, thumb_length);
    1490. 

  1490.   merror (thumb, "layer_thumb()");
    1491. 

  1491.   fprintf (ofp, "P%d\n%d %d\n255\n",
    1492. 

  1492. 	5 + (colors >> 1), thumb_width, thumb_height);
    1493. 

  1493.   fread (thumb, thumb_length, colors, ifp);
    1494. 

  1494.   for (i=0; i < thumb_length; i++)
    1495. 

  1495.     FORCC putc (thumb[i+thumb_length*(map[thumb_misc >> 8][c]-'0')], ofp);
    1496. 

  1496.   free (thumb);
    1497. 

  1497. }
    1498. 

  1498. 

  1499. void CLASS rollei_thumb()
    1500. 

  1500. {
    1501. 

  1501.   unsigned i;
    1502. 

  1502.   ushort *thumb;
    1503. 

  1503. 

  1504.   thumb_length = thumb_width * thumb_height;
    1505. 

  1505.   thumb = (ushort *) calloc (thumb_length, 2);
    1506. 

  1506.   merror (thumb, "rollei_thumb()");
    1507. 

  1507.   fprintf (ofp, "P6\n%d %d\n255\n", thumb_width, thumb_height);
    1508. 

  1508.   read_shorts (thumb, thumb_length);
    1509. 

  1509.   for (i=0; i < thumb_length; i++) {
    1510. 

  1510.     putc (thumb[i] << 3, ofp);
    1511. 

  1511.     putc (thumb[i] >> 5  << 2, ofp);
    1512. 

  1512.     putc (thumb[i] >> 11 << 3, ofp);
    1513. 

  1513.   }
    1514. 

  1514.   free (thumb);
    1515. 

  1515. }
    1516. 

  1516. 

  1517. void CLASS rollei_load_raw()
    1518. 

  1518. {
    1519. 

  1519.   uchar pixel[10];
    1520. 

  1520.   unsigned iten=0, isix, i, buffer=0, row, col, todo[16];
    1521. 

  1521. 

  1522.   isix = raw_width * raw_height * 5 / 8;
    1523. 

  1523.   while (fread (pixel, 1, 10, ifp) == 10) {
    1524. 

  1524.     for (i=0; i < 10; i+=2) {
    1525. 

  1525.       todo[i]   = iten++;
    1526. 

  1526.       todo[i+1] = pixel[i] << 8 | pixel[i+1];
    1527. 

  1527.       buffer    = pixel[i] >> 2 | buffer << 6;
    1528. 

  1528.     }
    1529. 

  1529.     for (   ; i < 16; i+=2) {
    1530. 

  1530.       todo[i]   = isix++;
    1531. 

  1531.       todo[i+1] = buffer >> (14-i)*5;
    1532. 

  1532.     }
    1533. 

  1533.     for (i=0; i < 16; i+=2) {
    1534. 

  1534. #ifndef LIBRAW_LIBRARY_BUILD
    1535. 

  1535.       row = todo[i] / raw_width - top_margin;
    1536. 

  1536.       col = todo[i] % raw_width - left_margin;
    1537. 

  1537.       if (row < height && col < width)
    1538. 

  1538.               BAYER(row,col) = (todo[i+1] & 0x3ff);
    1539. 

  1539. #else
    1540. 

  1540.       RBAYER(todo[i] / raw_width,todo[i] % raw_width) = (todo[i+1] & 0x3ff);
    1541. 

  1541. #endif
    1542. 

  1542.     }
    1543. 

  1543.   }
    1544. 

  1544.   maximum = 0x3ff;
    1545. 

  1545. }
    1546. 

  1546. 

  1547. int CLASS bayer (unsigned row, unsigned col)
    1548. 

  1548. {
    1549. 

  1549.   return (row < height && col < width) ? BAYER(row,col) : 0;
    1550. 

  1550. }
    1551. 

  1551. 

  1552. void CLASS phase_one_flat_field (int is_float, int nc)
    1553. 

  1553. {
    1554. 

  1554.   ushort head[8];
    1555. 

  1555.   unsigned wide, y, x, c, rend, cend, row, col;
    1556. 

  1556.   float *mrow, num, mult[4];
    1557. 

  1557. 

  1558.   read_shorts (head, 8);
    1559. 

  1559.   wide = head[2] / head[4];
    1560. 

  1560.   mrow = (float *) calloc (nc*wide, sizeof *mrow);
    1561. 

  1561.   merror (mrow, "phase_one_flat_field()");
    1562. 

  1562.   for (y=0; y < head[3] / head[5]; y++) {
    1563. 

  1563.     for (x=0; x < wide; x++)
    1564. 

  1564.       for (c=0; c < nc; c+=2) {
    1565. 

  1565. 	num = is_float ? getreal(11) : get2()/32768.0;
    1566. 

  1566. 	if (y==0) mrow[c*wide+x] = num;
    1567. 

  1567. 	else mrow[(c+1)*wide+x] = (num - mrow[c*wide+x]) / head[5];
    1568. 

  1568.       }
    1569. 

  1569.     if (y==0) continue;
    1570. 

  1570.     rend = head[1]-top_margin + y*head[5];
    1571. 

  1571.     for (row = rend-head[5]; row < height && row < rend; row++) {
    1572. 

  1572.       for (x=1; x < wide; x++) {
    1573. 

  1573. 	for (c=0; c < nc; c+=2) {
    1574. 

  1574. 	  mult[c] = mrow[c*wide+x-1];
    1575. 

  1575. 	  mult[c+1] = (mrow[c*wide+x] - mult[c]) / head[4];
    1576. 

  1576. 	}
    1577. 

  1577. 	cend = head[0]-left_margin + x*head[4];
    1578. 

  1578. 	for (col = cend-head[4]; col < width && col < cend; col++) {
    1579. 

  1579. 	  c = nc > 2 ? FC(row,col) : 0;
    1580. 

  1580. 	  if (!(c & 1)) {
    1581. 

  1581. 	    c = BAYER(row,col) * mult[c];
    1582. 

  1582. 	    BAYER(row,col) = LIM(c,0,65535);
    1583. 

  1583. 	  }
    1584. 

  1584. 	  for (c=0; c < nc; c+=2)
    1585. 

  1585. 	    mult[c] += mult[c+1];
    1586. 

  1586. 	}
    1587. 

  1587.       }
    1588. 

  1588.       for (x=0; x < wide; x++)
    1589. 

  1589. 	for (c=0; c < nc; c+=2)
    1590. 

  1590. 	  mrow[c*wide+x] += mrow[(c+1)*wide+x];
    1591. 

  1591.     }
    1592. 

  1592.   }
    1593. 

  1593.   free (mrow);
    1594. 

  1594. }
    1595. 

  1595. 

  1596. void CLASS phase_one_correct()
    1597. 

  1597. {
    1598. 

  1598.   unsigned entries, tag, data, save, col, row, type;
    1599. 

  1599.   int len, i, j, k, cip, val[4], dev[4], sum, max;
    1600. 

  1600.   int head[9], diff, mindiff=INT_MAX, off_412=0;
    1601. 

  1601.   static const signed char dir[12][2] =
    1602. 

  1602.     { {-1,-1}, {-1,1}, {1,-1}, {1,1}, {-2,0}, {0,-2}, {0,2}, {2,0},
    1603. 

  1603.       {-2,-2}, {-2,2}, {2,-2}, {2,2} };
    1604. 

  1604.   float poly[8], num, cfrac, frac, mult[2], *yval[2];
    1605. 

  1605.   ushort *xval[2];
    1606. 

  1606. 

  1607.   if (half_size || !meta_length) return;
    1608. 

  1608. #ifdef DCRAW_VERBOSE
    1609. 

  1609.   if (verbose) fprintf (stderr,_("Phase One correction...\n"));
    1610. 

  1610. #endif
    1611. 

  1611.   fseek (ifp, meta_offset, SEEK_SET);
    1612. 

  1612.   order = get2();
    1613. 

  1613.   fseek (ifp, 6, SEEK_CUR);
    1614. 

  1614.   fseek (ifp, meta_offset+get4(), SEEK_SET);
    1615. 

  1615.   entries = get4();  get4();
    1616. 

  1616.   while (entries--) {
    1617. 

  1617.     tag  = get4();
    1618. 

  1618.     len  = get4();
    1619. 

  1619.     data = get4();
    1620. 

  1620.     save = ftell(ifp);
    1621. 

  1621.     fseek (ifp, meta_offset+data, SEEK_SET);
    1622. 

  1622.     if (tag == 0x419) {				/* Polynomial curve */
    1623. 

  1623.       for (get4(), i=0; i < 8; i++)
    1624. 

  1624. 	poly[i] = getreal(11);
    1625. 

  1625.       poly[3] += (ph1.tag_210 - poly[7]) * poly[6] + 1;
    1626. 

  1626.       for (i=0; i < 0x10000; i++) {
    1627. 

  1627. 	num = (poly[5]*i + poly[3])*i + poly[1];
    1628. 

  1628. 	curve[i] = LIM(num,0,65535);
    1629. 

  1629.       } goto apply;				/* apply to right half */
    1630. 

  1630.     } else if (tag == 0x41a) {			/* Polynomial curve */
    1631. 

  1631.       for (i=0; i < 4; i++)
    1632. 

  1632. 	poly[i] = getreal(11);
    1633. 

  1633.       for (i=0; i < 0x10000; i++) {
    1634. 

  1634. 	for (num=0, j=4; j--; )
    1635. 

  1635. 	  num = num * i + poly[j];
    1636. 

  1636. 	curve[i] = LIM(num+i,0,65535);
    1637. 

  1637.       } apply:					/* apply to whole image */
    1638. 

  1638.       for (row=0; row < height; row++)
    1639. 

  1639. 	for (col = (tag & 1)*ph1.split_col; col < width; col++)
    1640. 

  1640. 	  BAYER(row,col) = curve[BAYER(row,col)];
    1641. 

  1641.     } else if (tag == 0x400) {			/* Sensor defects */
    1642. 

  1642.       while ((len -= 8) >= 0) {
    1643. 

  1643. 	col  = get2() - left_margin;
    1644. 

  1644. 	row  = get2() - top_margin;
    1645. 

  1645. 	type = get2(); get2();
    1646. 

  1646. 	if (col >= width) continue;
    1647. 

  1647. 	if (type == 131)			/* Bad column */
    1648. 

  1648. 	  for (row=0; row < height; row++)
    1649. 

  1649. 	    if (FC(row,col) == 1) {
    1650. 

  1650. 	      for (sum=i=0; i < 4; i++)
    1651. 

  1651. 		sum += val[i] = bayer (row+dir[i][0], col+dir[i][1]);
    1652. 

  1652. 	      for (max=i=0; i < 4; i++) {
    1653. 

  1653. 		dev[i] = abs((val[i] << 2) - sum);
    1654. 

  1654. 		if (dev[max] < dev[i]) max = i;
    1655. 

  1655. 	      }
    1656. 

  1656. 	      BAYER(row,col) = (sum - val[max])/3.0 + 0.5;
    1657. 

  1657. 	    } else {
    1658. 

  1658. 	      for (sum=0, i=8; i < 12; i++)
    1659. 

  1659. 		sum += bayer (row+dir[i][0], col+dir[i][1]);
    1660. 

  1660. 	      BAYER(row,col) = 0.5 + sum * 0.0732233 +
    1661. 

  1661. 		(bayer(row,col-2) + bayer(row,col+2)) * 0.3535534;
    1662. 

  1662. 	    }
    1663. 

  1663. 	else if (type == 129) {			/* Bad pixel */
    1664. 

  1664. 	  if (row >= height) continue;
    1665. 

  1665. 	  j = (FC(row,col) != 1) * 4;
    1666. 

  1666. 	  for (sum=0, i=j; i < j+8; i++)
    1667. 

  1667. 	    sum += bayer (row+dir[i][0], col+dir[i][1]);
    1668. 

  1668. 	  BAYER(row,col) = (sum + 4) >> 3;
    1669. 

  1669. 	}
    1670. 

  1670.       }
    1671. 

  1671.     } else if (tag == 0x401) {			/* All-color flat fields */
    1672. 

  1672.       phase_one_flat_field (1, 2);
    1673. 

  1673.     } else if (tag == 0x416 || tag == 0x410) {
    1674. 

  1674.       phase_one_flat_field (0, 2);
    1675. 

  1675.     } else if (tag == 0x40b) {			/* Red+blue flat field */
    1676. 

  1676.       phase_one_flat_field (0, 4);
    1677. 

  1677.     } else if (tag == 0x412) {
    1678. 

  1678.       fseek (ifp, 36, SEEK_CUR);
    1679. 

  1679.       diff = abs (get2() - ph1.tag_21a);
    1680. 

  1680.       if (mindiff > diff) {
    1681. 

  1681. 	mindiff = diff;
    1682. 

  1682. 	off_412 = ftell(ifp) - 38;
    1683. 

  1683.       }
    1684. 

  1684.     }
    1685. 

  1685.     fseek (ifp, save, SEEK_SET);
    1686. 

  1686.   }
    1687. 

  1687.   if (off_412) {
    1688. 

  1688.     fseek (ifp, off_412, SEEK_SET);
    1689. 

  1689.     for (i=0; i < 9; i++) head[i] = get4() & 0x7fff;
    1690. 

  1690.     yval[0] = (float *) calloc (head[1]*head[3] + head[2]*head[4], 6);
    1691. 

  1691.     merror (yval[0], "phase_one_correct()");
    1692. 

  1692.     yval[1] = (float  *) (yval[0] + head[1]*head[3]);
    1693. 

  1693.     xval[0] = (ushort *) (yval[1] + head[2]*head[4]);
    1694. 

  1694.     xval[1] = (ushort *) (xval[0] + head[1]*head[3]);
    1695. 

  1695.     get2();
    1696. 

  1696.     for (i=0; i < 2; i++)
    1697. 

  1697.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1698. 

  1698. 	yval[i][j] = getreal(11);
    1699. 

  1699.     for (i=0; i < 2; i++)
    1700. 

  1700.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1701. 

  1701. 	xval[i][j] = get2();
    1702. 

  1702.     for (row=0; row < height; row++)
    1703. 

  1703.       for (col=0; col < width; col++) {
    1704. 

  1704. 	cfrac = (float) col * head[3] / raw_width;
    1705. 

  1705. 	cfrac -= cip = cfrac;
    1706. 

  1706. 	num = BAYER(row,col) * 0.5;
    1707. 

  1707. 	for (i=cip; i < cip+2; i++) {
    1708. 

  1708. 	  for (k=j=0; j < head[1]; j++)
    1709. 

  1709. 	    if (num < xval[0][k = head[1]*i+j]) break;
    1710. 

  1710. 	  frac = (j == 0 || j == head[1]) ? 0 :
    1711. 

  1711. 		(xval[0][k] - num) / (xval[0][k] - xval[0][k-1]);
    1712. 

  1712. 	  mult[i-cip] = yval[0][k-1] * frac + yval[0][k] * (1-frac);
    1713. 

  1713. 	}
    1714. 

  1714. 	i = ((mult[0] * (1-cfrac) + mult[1] * cfrac)
    1715. 

  1715. 		* (row + top_margin) + num) * 2;
    1716. 

  1716. 	BAYER(row,col) = LIM(i,0,65535);
    1717. 

  1717.       }
    1718. 

  1718.     free (yval[0]);
    1719. 

  1719.   }
    1720. 

  1720. }
    1721. 

  1721. 

  1722. void CLASS phase_one_load_raw()
    1723. 

  1723. {
    1724. 

  1724.   int row, col, a, b;
    1725. 

  1725.   ushort *pixel, a…
    1726.

Large files files are truncated, but you can click here to view the full file