PageRenderTime 127ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 1ms

/src/FreeImage/Source/LibRawLite/internal/dcraw_common.cpp

https://bitbucket.org/cabalistic/ogredeps/
C++ | 9257 lines | 8724 code | 384 blank | 149 comment | 2770 complexity | 72935f0889776ffd03608fe38e768ba2 MD5 | raw file
Possible License(s): LGPL-3.0, BSD-3-Clause, CPL-1.0, Unlicense, GPL-2.0, GPL-3.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, BSD-2-Clause, LGPL-2.1 
    

  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. #ifdef ANDROID
    35. 

  35. #include <asm/byteorder.h> 
    36. 

  36. void swab(const void *from, void*to, ssize_t n) 
    37. 

  37. { 
    38. 

  38. 	if (n < 0) 
    39. 

  39. 		return; 
    40. 

  40.  		 
    41. 

  41. 	for (ssize_t i = 0; i < (n/2)*2; i += 2) 
    42. 

  42. 	{
    43. 

  43. 		*((uint16_t*)to+i) = __arch__swab16(*((uint16_t*)from+i)); 
    44. 

  44. 	}
    45. 

  45. } 
    46. 

  46. #endif
    47. 

  47. 

  48. #ifndef __GLIBC__
    49. 

  49. char *my_memmem (char *haystack, size_t haystacklen,
    50. 

  50. 	      char *needle, size_t needlelen)
    51. 

  51. {
    52. 

  52.   char *c;
    53. 

  53.   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
    54. 

  54.     if (!memcmp (c, needle, needlelen))
    55. 

  55.       return c;
    56. 

  56.   return 0;
    57. 

  57. }
    58. 

  58. #define memmem my_memmem
    59. 

  59. #endif
    60. 

  60. 

  61. 

  62. ushort CLASS sget2 (uchar *s)
    63. 

  63. {
    64. 

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

  65.     return s[0] | s[1] << 8;
    66. 

  66.   else				/* "MM" means big-endian */
    67. 

  67.     return s[0] << 8 | s[1];
    68. 

  68. }
    69. 

  69. 

  70. ushort CLASS get2()
    71. 

  71. {
    72. 

  72.   uchar str[2] = { 0xff,0xff };
    73. 

  73.   fread (str, 1, 2, ifp);
    74. 

  74.   return sget2(str);
    75. 

  75. }
    76. 

  76. 

  77. unsigned CLASS sget4 (uchar *s)
    78. 

  78. {
    79. 

  79.   if (order == 0x4949)
    80. 

  80.     return s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
    81. 

  81.   else
    82. 

  82.     return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
    83. 

  83. }
    84. 

  84. #define sget4(s) sget4((uchar *)s)
    85. 

  85. 

  86. unsigned CLASS get4()
    87. 

  87. {
    88. 

  88.   uchar str[4] = { 0xff,0xff,0xff,0xff };
    89. 

  89.   fread (str, 1, 4, ifp);
    90. 

  90.   return sget4(str);
    91. 

  91. }
    92. 

  92. 

  93. unsigned CLASS getint (int type)
    94. 

  94. {
    95. 

  95.   return type == 3 ? get2() : get4();
    96. 

  96. }
    97. 

  97. 

  98. float CLASS int_to_float (int i)
    99. 

  99. {
    100. 

  100.   union { int i; float f; } u;
    101. 

  101.   u.i = i;
    102. 

  102.   return u.f;
    103. 

  103. }
    104. 

  104. 

  105. double CLASS getreal (int type)
    106. 

  106. {
    107. 

  107.   union { char c[8]; double d; } u;
    108. 

  108.   int i, rev;
    109. 

  109. 

  110.   switch (type) {
    111. 

  111.     case 3: return (unsigned short) get2();
    112. 

  112.     case 4: return (unsigned int) get4();
    113. 

  113.     case 5:  u.d = (unsigned int) get4();
    114. 

  114.       return u.d / (unsigned int) get4();
    115. 

  115.     case 8: return (signed short) get2();
    116. 

  116.     case 9: return (signed int) get4();
    117. 

  117.     case 10: u.d = (signed int) get4();
    118. 

  118.       return u.d / (signed int) get4();
    119. 

  119.     case 11: return int_to_float (get4());
    120. 

  120.     case 12:
    121. 

  121.       rev = 7 * ((order == 0x4949) == (ntohs(0x1234) == 0x1234));
    122. 

  122.       for (i=0; i < 8; i++)
    123. 

  123. 	u.c[i ^ rev] = fgetc(ifp);
    124. 

  124.       return u.d;
    125. 

  125.     default: return fgetc(ifp);
    126. 

  126.   }
    127. 

  127. }
    128. 

  128. 

  129. void CLASS read_shorts (ushort *pixel, int count)
    130. 

  130. {
    131. 

  131.   if (fread (pixel, 2, count, ifp) < count) derror();
    132. 

  132.   if ((order == 0x4949) == (ntohs(0x1234) == 0x1234))
    133. 

  133.       swab ((char*)pixel, (char*)pixel, count*2);
    134. 

  134. }
    135. 

  135. 

  136. #ifdef LIBRAW_LIBRARY_BUILD
    137. 

  137. #define RBAYER(x,y) raw_image[(x)*raw_width+(y)]
    138. 

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

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

  140. #else
    141. 

  141. #define CBAYER(x,y) BAYER((x),(y))
    142. 

  142. #define RBAYER(x,y) BAYER((x),(y))
    143. 

  143. #define RRBAYER(x,y) BAYER((x),(y))
    144. 

  144. #endif
    145. 

  145. 

  146. void CLASS canon_600_fixed_wb (int temp)
    147. 

  147. {
    148. 

  148.   static const short mul[4][5] = {
    149. 

  149.     {  667, 358,397,565,452 },
    150. 

  150.     {  731, 390,367,499,517 },
    151. 

  151.     { 1119, 396,348,448,537 },
    152. 

  152.     { 1399, 485,431,508,688 } };
    153. 

  153.   int lo, hi, i;
    154. 

  154.   float frac=0;
    155. 

  155. 

  156.   for (lo=4; --lo; )
    157. 

  157.     if (*mul[lo] <= temp) break;
    158. 

  158.   for (hi=0; hi < 3; hi++)
    159. 

  159.     if (*mul[hi] >= temp) break;
    160. 

  160.   if (lo != hi)
    161. 

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

  162.   for (i=1; i < 5; i++)
    163. 

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

  164. #ifdef LIBRAW_LIBRARY_BUILD
    165. 

  165.   color_flags.pre_mul_state = LIBRAW_COLORSTATE_CONST;
    166. 

  166. #endif
    167. 

  167. }
    168. 

  168. 

  169. /* Return values:  0 = white  1 = near white  2 = not white */
    170. 

  170. int CLASS canon_600_color (int ratio[2], int mar)
    171. 

  171. {
    172. 

  172.   int clipped=0, target, miss;
    173. 

  173. 

  174.   if (flash_used) {
    175. 

  175.     if (ratio[1] < -104)
    176. 

  176.       { ratio[1] = -104; clipped = 1; }
    177. 

  177.     if (ratio[1] >   12)
    178. 

  178.       { ratio[1] =   12; clipped = 1; }
    179. 

  179.   } else {
    180. 

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

  181.     if (ratio[1] < -50)
    182. 

  182.       { ratio[1] = -50; clipped = 1; }
    183. 

  183.     if (ratio[1] > 307)
    184. 

  184.       { ratio[1] = 307; clipped = 1; }
    185. 

  185.   }
    186. 

  186.   target = flash_used || ratio[1] < 197
    187. 

  187. 	? -38 - (398 * ratio[1] >> 10)
    188. 

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

  189.   if (target - mar <= ratio[0] &&
    190. 

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

  191.   miss = target - ratio[0];
    192. 

  192.   if (abs(miss) >= mar*4) return 2;
    193. 

  193.   if (miss < -20) miss = -20;
    194. 

  194.   if (miss > mar) miss = mar;
    195. 

  195.   ratio[0] = target - miss;
    196. 

  196.   return 1;
    197. 

  197. }
    198. 

  198. 

  199. void CLASS canon_600_auto_wb()
    200. 

  200. {
    201. 

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

  202.   int test[8], total[2][8], ratio[2][2], stat[2];
    203. 

  203. 

  204.   memset (&total, 0, sizeof total);
    205. 

  205.   i = canon_ev + 0.5;
    206. 

  206.   if      (i < 10) mar = 150;
    207. 

  207.   else if (i > 12) mar = 20;
    208. 

  208.   else mar = 280 - 20 * i;
    209. 

  209.   if (flash_used) mar = 80;
    210. 

  210.   for (row=14; row < height-14; row+=4)
    211. 

  211.     for (col=10; col < width; col+=2) {
    212. 

  212.       for (i=0; i < 8; i++)
    213. 

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

  214. 		    BAYER(row+(i >> 1),col+(i & 1));
    215. 

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

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

  217.       for (i=0; i < 4; i++)
    218. 

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

  219.       for (i=0; i < 2; i++) {
    220. 

  220. 	for (j=0; j < 4; j+=2)
    221. 

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

  222. 	stat[i] = canon_600_color (ratio[i], mar);
    223. 

  223.       }
    224. 

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

  225.       for (i=0; i < 2; i++)
    226. 

  226. 	if (stat[i])
    227. 

  227. 	  for (j=0; j < 2; j++)
    228. 

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

  229.       for (i=0; i < 8; i++)
    230. 

  230. 	total[st][i] += test[i];
    231. 

  231.       count[st]++;
    232. 

  232. next: ;
    233. 

  233.     }
    234. 

  234.   if (count[0] | count[1]) {
    235. 

  235.     st = count[0]*200 < count[1];
    236. 

  236.     for (i=0; i < 4; i++)
    237. 

  237.       pre_mul[i] = 1.0 / (total[st][i] + total[st][i+4]);
    238. 

  238. #ifdef LIBRAW_LIBRARY_BUILD
    239. 

  239.     color_flags.pre_mul_state = LIBRAW_COLORSTATE_CALCULATED;
    240. 

  240. #endif
    241. 

  241.   }
    242. 

  242. }
    243. 

  243. 

  244. void CLASS canon_600_coeff()
    245. 

  245. {
    246. 

  246.   static const short table[6][12] = {
    247. 

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

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

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

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

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

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

  253.   int t=0, i, c;
    254. 

  254.   float mc, yc;
    255. 

  255. 

  256.   mc = pre_mul[1] / pre_mul[2];
    257. 

  257.   yc = pre_mul[3] / pre_mul[2];
    258. 

  258.   if (mc > 1 && mc <= 1.28 && yc < 0.8789) t=1;
    259. 

  259.   if (mc > 1.28 && mc <= 2) {
    260. 

  260.     if  (yc < 0.8789) t=3;
    261. 

  261.     else if (yc <= 2) t=4;
    262. 

  262.   }
    263. 

  263.   if (flash_used) t=5;
    264. 

  264.   for (raw_color = i=0; i < 3; i++)
    265. 

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

  266. #ifdef LIBRAW_LIBRARY_BUILD
    267. 

  267.   color_flags.rgb_cam_state = LIBRAW_COLORSTATE_CALCULATED;
    268. 

  268. #endif
    269. 

  269. }
    270. 

  270. 

  271. void CLASS canon_600_load_raw()
    272. 

  272. {
    273. 

  273.   uchar  data[1120], *dp;
    274. 

  274.   ushort pixel[896], *pix;
    275. 

  275.   int irow, row, col, val;
    276. 

  276.   static const short mul[4][2] =
    277. 

  277.   { { 1141,1145 }, { 1128,1109 }, { 1178,1149 }, { 1128,1109 } };
    278. 

  278. 

  279.   for (irow=row=0; irow < height; irow++) {
    280. 

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

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

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

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

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

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

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

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

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

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

  290.     }
    291. 

  291. #ifndef LIBRAW_LIBRARY_BUILD
    292. 

  292.     for (col=0; col < width; col++)
    293. 

  293.         {
    294. 

  294.             BAYER(row,col) = pixel[col];
    295. 

  295.         }
    296. 

  296. #else
    297. 

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

  298.             RBAYER(row,col) = pixel[col];
    299. 

  299. #endif
    300. 

  300. 

  301.     for (col=width; col < raw_width; col++)
    302. 

  302.         {
    303. 

  303.             black += pixel[col];
    304. 

  304.         }
    305. 

  305.     if ((row+=2) > height) row = 1;
    306. 

  306.   }
    307. 

  307.   if (raw_width > width)
    308. 

  308.     black = black / ((raw_width - width) * height) - 4;
    309. 

  309. #ifndef LIBRAW_LIBRARY_BUILD
    310. 

  310.   for (row=0; row < height; row++)
    311. 

  311.     for (col=0; col < width; col++) {
    312. 

  312.       if ((val = BAYER(row,col) - black) < 0) val = 0;
    313. 

  313.       val = val * mul[row & 3][col & 1] >> 9;
    314. 

  314.       BAYER(row,col) = val;
    315. 

  315.     }
    316. 

  316. #else
    317. 

  317.   for (row=0; row < height; row++)
    318. 

  318.     for (col=0; col < raw_width; col++) {
    319. 

  319.       if ((val = RBAYER(row,col) - black) < 0) val = 0;
    320. 

  320.       val = val * mul[row & 3][col & 1] >> 9;
    321. 

  321.       RBAYER(row,col) = val;
    322. 

  322.     }
    323. 

  323. 

  324. #endif
    325. 

  325.   canon_600_fixed_wb(1311);
    326. 

  326.   canon_600_auto_wb();
    327. 

  327.   canon_600_coeff();
    328. 

  328.   maximum = (0x3ff - black) * 1109 >> 9;
    329. 

  329.   black = 0;
    330. 

  330. }
    331. 

  331. 

  332. void CLASS remove_zeroes()
    333. 

  333. {
    334. 

  334.   unsigned row, col, tot, n, r, c;
    335. 

  335. 

  336. #ifdef LIBRAW_LIBRARY_BUILD
    337. 

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

  338. #endif
    339. 

  339.   for (row=0; row < height; row++)
    340. 

  340.     for (col=0; col < width; col++)
    341. 

  341.       if (BAYER(row,col) == 0) {
    342. 

  342. 	tot = n = 0;
    343. 

  343. 	for (r = row-2; r <= row+2; r++)
    344. 

  344. 	  for (c = col-2; c <= col+2; c++)
    345. 

  345. 	    if (r < height && c < width &&
    346. 

  346. 		FC(r,c) == FC(row,col) && BAYER(r,c))
    347. 

  347. 	      tot += (n++,BAYER(r,c));
    348. 

  348. 	if (n) BAYER(row,col) = tot/n;
    349. 

  349.       }
    350. 

  350. #ifdef LIBRAW_LIBRARY_BUILD
    351. 

  351.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,1,2);
    352. 

  352. #endif
    353. 

  353. }
    354. 

  354. 

  355. int CLASS canon_s2is()
    356. 

  356. {
    357. 

  357.   unsigned row;
    358. 

  358. 

  359.   for (row=0; row < 100; row++) {
    360. 

  360.     fseek (ifp, row*3340 + 3284, SEEK_SET);
    361. 

  361.     if (getc(ifp) > 15) return 1;
    362. 

  362.   }
    363. 

  363.   return 0;
    364. 

  364. }
    365. 

  365. 

  366. /*
    367. 

  367.    getbits(-1) initializes the buffer
    368. 

  368.    getbits(n) where 0 <= n <= 25 returns an n-bit integer
    369. 

  369.  */
    370. 

  370. 

  371. unsigned CLASS getbithuff (int nbits, ushort *huff)
    372. 

  372. {
    373. 

  373. #ifdef LIBRAW_NOTHREADS
    374. 

  374.   static unsigned bitbuf=0;
    375. 

  375.   static int vbits=0, reset=0;
    376. 

  376. #else
    377. 

  377. #define bitbuf tls->getbits.bitbuf
    378. 

  378. #define vbits  tls->getbits.vbits
    379. 

  379. #define reset  tls->getbits.reset
    380. 

  380. #endif
    381. 

  381.   unsigned c;
    382. 

  382. 

  383.   if (nbits == -1)
    384. 

  384.     return bitbuf = vbits = reset = 0;
    385. 

  385.   if (nbits == 0 || vbits < 0) return 0;
    386. 

  386.   while (!reset && vbits < nbits && (c = fgetc(ifp)) != EOF &&
    387. 

  387.     !(reset = zero_after_ff && c == 0xff && fgetc(ifp))) {
    388. 

  388.     bitbuf = (bitbuf << 8) + (uchar) c;
    389. 

  389.     vbits += 8;
    390. 

  390.   }
    391. 

  391.   c = bitbuf << (32-vbits) >> (32-nbits);
    392. 

  392.   if (huff) {
    393. 

  393.     vbits -= huff[c] >> 8;
    394. 

  394.     c = (uchar) huff[c];
    395. 

  395.   } else
    396. 

  396.     vbits -= nbits;
    397. 

  397.   if (vbits < 0) derror();
    398. 

  398.   return c;
    399. 

  399. #ifndef LIBRAW_NOTHREADS
    400. 

  400. #undef bitbuf
    401. 

  401. #undef vbits
    402. 

  402. #undef reset
    403. 

  403. #endif
    404. 

  404. }
    405. 

  405. 

  406. #define getbits(n) getbithuff(n,0)
    407. 

  407. #define gethuff(h) getbithuff(*h,h+1)
    408. 

  408. 

  409. /*
    410. 

  410.    Construct a decode tree according to the specification in *source.
    411. 

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

  412.    3-bit, etc.  Bytes after that are the leaf values.
    413. 

    414. 

  414.    For example, if the source is
    415. 

    416. 

  416.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    417. 

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

    419. 

  419.    then the code is
    420. 

    421. 

  421. 	00		0x04
    422. 

  422. 	010		0x03
    423. 

  423. 	011		0x05
    424. 

  424. 	100		0x06
    425. 

  425. 	101		0x02
    426. 

  426. 	1100		0x07
    427. 

  427. 	1101		0x01
    428. 

  428. 	11100		0x08
    429. 

  429. 	11101		0x09
    430. 

  430. 	11110		0x00
    431. 

  431. 	111110		0x0a
    432. 

  432. 	1111110		0x0b
    433. 

  433. 	1111111		0xff
    434. 

  434.  */
    435. 

  435. ushort * CLASS make_decoder_ref (const uchar **source)
    436. 

  436. {
    437. 

  437.   int max, len, h, i, j;
    438. 

  438.   const uchar *count;
    439. 

  439.   ushort *huff;
    440. 

  440. 

  441.   count = (*source += 16) - 17;
    442. 

  442.   for (max=16; max && !count[max]; max--);
    443. 

  443.   huff = (ushort *) calloc (1 + (1 << max), sizeof *huff);
    444. 

  444.   merror (huff, "make_decoder()");
    445. 

  445.   huff[0] = max;
    446. 

  446.   for (h=len=1; len <= max; len++)
    447. 

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

  448.       for (j=0; j < 1 << (max-len); j++)
    449. 

  449. 	if (h <= 1 << max)
    450. 

  450. 	  huff[h++] = len << 8 | **source;
    451. 

  451.   return huff;
    452. 

  452. }
    453. 

  453. 

  454. ushort * CLASS make_decoder (const uchar *source)
    455. 

  455. {
    456. 

  456.   return make_decoder_ref (&source);
    457. 

  457. }
    458. 

  458. 

  459. void CLASS crw_init_tables (unsigned table, ushort *huff[2])
    460. 

  460. {
    461. 

  461.   static const uchar first_tree[3][29] = {
    462. 

  462.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    463. 

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

  464.     { 0,2,2,3,1,1,1,1,2,0,0,0,0,0,0,0,
    465. 

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

  466.     { 0,0,6,3,1,1,2,0,0,0,0,0,0,0,0,0,
    467. 

  467. 

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

  469.   };
    470. 

  470.   static const uchar second_tree[3][180] = {
    471. 

  471.     { 0,2,2,2,1,4,2,1,2,5,1,1,0,0,0,139,
    472. 

  472.       0x03,0x04,0x02,0x05,0x01,0x06,0x07,0x08,
    473. 

  473.       0x12,0x13,0x11,0x14,0x09,0x15,0x22,0x00,0x21,0x16,0x0a,0xf0,
    474. 

  474.       0x23,0x17,0x24,0x31,0x32,0x18,0x19,0x33,0x25,0x41,0x34,0x42,
    475. 

  475.       0x35,0x51,0x36,0x37,0x38,0x29,0x79,0x26,0x1a,0x39,0x56,0x57,
    476. 

  476.       0x28,0x27,0x52,0x55,0x58,0x43,0x76,0x59,0x77,0x54,0x61,0xf9,
    477. 

  477.       0x71,0x78,0x75,0x96,0x97,0x49,0xb7,0x53,0xd7,0x74,0xb6,0x98,
    478. 

  478.       0x47,0x48,0x95,0x69,0x99,0x91,0xfa,0xb8,0x68,0xb5,0xb9,0xd6,
    479. 

  479.       0xf7,0xd8,0x67,0x46,0x45,0x94,0x89,0xf8,0x81,0xd5,0xf6,0xb4,
    480. 

  480.       0x88,0xb1,0x2a,0x44,0x72,0xd9,0x87,0x66,0xd4,0xf5,0x3a,0xa7,
    481. 

  481.       0x73,0xa9,0xa8,0x86,0x62,0xc7,0x65,0xc8,0xc9,0xa1,0xf4,0xd1,
    482. 

  482.       0xe9,0x5a,0x92,0x85,0xa6,0xe7,0x93,0xe8,0xc1,0xc6,0x7a,0x64,
    483. 

  483.       0xe1,0x4a,0x6a,0xe6,0xb3,0xf1,0xd3,0xa5,0x8a,0xb2,0x9a,0xba,
    484. 

  484.       0x84,0xa4,0x63,0xe5,0xc5,0xf3,0xd2,0xc4,0x82,0xaa,0xda,0xe4,
    485. 

  485.       0xf2,0xca,0x83,0xa3,0xa2,0xc3,0xea,0xc2,0xe2,0xe3,0xff,0xff  },
    486. 

  486.     { 0,2,2,1,4,1,4,1,3,3,1,0,0,0,0,140,
    487. 

  487.       0x02,0x03,0x01,0x04,0x05,0x12,0x11,0x06,
    488. 

  488.       0x13,0x07,0x08,0x14,0x22,0x09,0x21,0x00,0x23,0x15,0x31,0x32,
    489. 

  489.       0x0a,0x16,0xf0,0x24,0x33,0x41,0x42,0x19,0x17,0x25,0x18,0x51,
    490. 

  490.       0x34,0x43,0x52,0x29,0x35,0x61,0x39,0x71,0x62,0x36,0x53,0x26,
    491. 

  491.       0x38,0x1a,0x37,0x81,0x27,0x91,0x79,0x55,0x45,0x28,0x72,0x59,
    492. 

  492.       0xa1,0xb1,0x44,0x69,0x54,0x58,0xd1,0xfa,0x57,0xe1,0xf1,0xb9,
    493. 

  493.       0x49,0x47,0x63,0x6a,0xf9,0x56,0x46,0xa8,0x2a,0x4a,0x78,0x99,
    494. 

  494.       0x3a,0x75,0x74,0x86,0x65,0xc1,0x76,0xb6,0x96,0xd6,0x89,0x85,
    495. 

  495.       0xc9,0xf5,0x95,0xb4,0xc7,0xf7,0x8a,0x97,0xb8,0x73,0xb7,0xd8,
    496. 

  496.       0xd9,0x87,0xa7,0x7a,0x48,0x82,0x84,0xea,0xf4,0xa6,0xc5,0x5a,
    497. 

  497.       0x94,0xa4,0xc6,0x92,0xc3,0x68,0xb5,0xc8,0xe4,0xe5,0xe6,0xe9,
    498. 

  498.       0xa2,0xa3,0xe3,0xc2,0x66,0x67,0x93,0xaa,0xd4,0xd5,0xe7,0xf8,
    499. 

  499.       0x88,0x9a,0xd7,0x77,0xc4,0x64,0xe2,0x98,0xa5,0xca,0xda,0xe8,
    500. 

  500.       0xf3,0xf6,0xa9,0xb2,0xb3,0xf2,0xd2,0x83,0xba,0xd3,0xff,0xff  },
    501. 

  501.     { 0,0,6,2,1,3,3,2,5,1,2,2,8,10,0,117,
    502. 

  502.       0x04,0x05,0x03,0x06,0x02,0x07,0x01,0x08,
    503. 

  503.       0x09,0x12,0x13,0x14,0x11,0x15,0x0a,0x16,0x17,0xf0,0x00,0x22,
    504. 

  504.       0x21,0x18,0x23,0x19,0x24,0x32,0x31,0x25,0x33,0x38,0x37,0x34,
    505. 

  505.       0x35,0x36,0x39,0x79,0x57,0x58,0x59,0x28,0x56,0x78,0x27,0x41,
    506. 

  506.       0x29,0x77,0x26,0x42,0x76,0x99,0x1a,0x55,0x98,0x97,0xf9,0x48,
    507. 

  507.       0x54,0x96,0x89,0x47,0xb7,0x49,0xfa,0x75,0x68,0xb6,0x67,0x69,
    508. 

  508.       0xb9,0xb8,0xd8,0x52,0xd7,0x88,0xb5,0x74,0x51,0x46,0xd9,0xf8,
    509. 

  509.       0x3a,0xd6,0x87,0x45,0x7a,0x95,0xd5,0xf6,0x86,0xb4,0xa9,0x94,
    510. 

  510.       0x53,0x2a,0xa8,0x43,0xf5,0xf7,0xd4,0x66,0xa7,0x5a,0x44,0x8a,
    511. 

  511.       0xc9,0xe8,0xc8,0xe7,0x9a,0x6a,0x73,0x4a,0x61,0xc7,0xf4,0xc6,
    512. 

  512.       0x65,0xe9,0x72,0xe6,0x71,0x91,0x93,0xa6,0xda,0x92,0x85,0x62,
    513. 

  513.       0xf3,0xc5,0xb2,0xa4,0x84,0xba,0x64,0xa5,0xb3,0xd2,0x81,0xe5,
    514. 

  514.       0xd3,0xaa,0xc4,0xca,0xf2,0xb1,0xe4,0xd1,0x83,0x63,0xea,0xc3,
    515. 

  515.       0xe2,0x82,0xf1,0xa3,0xc2,0xa1,0xc1,0xe3,0xa2,0xe1,0xff,0xff  }
    516. 

  516.   };
    517. 

  517.   if (table > 2) table = 2;
    518. 

  518.   huff[0] = make_decoder ( first_tree[table]);
    519. 

  519.   huff[1] = make_decoder (second_tree[table]);
    520. 

  520. }
    521. 

  521. 

  522. /*
    523. 

  523.    Return 0 if the image starts with compressed data,
    524. 

  524.    1 if it starts with uncompressed low-order bits.
    525. 

    526. 

  526.    In Canon compressed data, 0xff is always followed by 0x00.
    527. 

  527.  */
    528. 

  528. int CLASS canon_has_lowbits()
    529. 

  529. {
    530. 

  530.   uchar test[0x4000];
    531. 

  531.   int ret=1;
    532. 

  532.   unsigned i;
    533. 

  533. 

  534.   fseek (ifp, 0, SEEK_SET);
    535. 

  535.   fread (test, 1, sizeof test, ifp);
    536. 

  536.   for (i=540; i < sizeof test - 1; i++)
    537. 

  537.     if (test[i] == 0xff) {
    538. 

  538.       if (test[i+1]) return 1;
    539. 

  539.       ret=0;
    540. 

  540.     }
    541. 

  541.   return ret;
    542. 

  542. }
    543. 

  543. 

  544. void CLASS canon_compressed_load_raw()
    545. 

  545. {
    546. 

  546.   ushort *pixel, *prow, *huff[2];
    547. 

  547.   int nblocks, lowbits, i, c, row, r, col, save, val;
    548. 

  548.   unsigned irow, icol;
    549. 

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

  550. 

  551.   crw_init_tables (tiff_compress, huff);
    552. 

  552.   pixel = (ushort *) calloc (raw_width*8, sizeof *pixel);
    553. 

  553.   merror (pixel, "canon_compressed_load_raw()");
    554. 

  554.   lowbits = canon_has_lowbits();
    555. 

  555.   if (!lowbits) maximum = 0x3ff;
    556. 

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

  557.   zero_after_ff = 1;
    558. 

  558.   getbits(-1);
    559. 

  559.   for (row=0; row < raw_height; row+=8) {
    560. 

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

  561.     for (block=0; block < nblocks; block++) {
    562. 

  562.       memset (diffbuf, 0, sizeof diffbuf);
    563. 

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

  564. 	leaf = gethuff(huff[i > 0]);
    565. 

  565. 	if (leaf == 0 && i) break;
    566. 

  566. 	if (leaf == 0xff) continue;
    567. 

  567. 	i  += leaf >> 4;
    568. 

  568. 	len = leaf & 15;
    569. 

  569. 	if (len == 0) continue;
    570. 

  570. 	diff = getbits(len);
    571. 

  571. 	if ((diff & (1 << (len-1))) == 0)
    572. 

  572. 	  diff -= (1 << len) - 1;
    573. 

  573. 	if (i < 64) diffbuf[i] = diff;
    574. 

  574.       }
    575. 

  575.       diffbuf[0] += carry;
    576. 

  576.       carry = diffbuf[0];
    577. 

  577.       for (i=0; i < 64; i++ ) {
    578. 

  578. 	if (pnum++ % raw_width == 0)
    579. 

  579. 	  base[0] = base[1] = 512;
    580. 

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

  581. 	  derror();
    582. 

  582.       }
    583. 

  583.     }
    584. 

  584.     if (lowbits) {
    585. 

  585.       save = ftell(ifp);
    586. 

  586.       fseek (ifp, 26 + row*raw_width/4, SEEK_SET);
    587. 

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

  588. 	c = fgetc(ifp);
    589. 

  589. 	for (r=0; r < 8; r+=2, prow++) {
    590. 

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

  591. 	  if (raw_width == 2672 && val < 512) val += 2;
    592. 

  592. 	  *prow = val;
    593. 

  593. 	}
    594. 

  594.       }
    595. 

  595.       fseek (ifp, save, SEEK_SET);
    596. 

  596.     }
    597. 

  597. 

  598. #ifdef LIBRAW_LIBRARY_BUILD
    599. 

  599.     for (r=0; r < 8; r++) {
    600. 

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

  601.         // MOVE entire row into place
    602. 

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

  603. 

  604.         irow = row - top_margin + r;
    605. 

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

  606. 

  607.         // only margins!
    608. 

  608.         for (col=0; col < left_margin; col++) 
    609. 

  609.             {
    610. 

  610.                 icol = col - left_margin;
    611. 

  611.                 c = FC(irow,icol);
    612. 

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

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

  614.             }
    615. 

  615.         for (col=width+left_margin; col < raw_width; col++) 
    616. 

  616.             {
    617. 

  617.                 icol = col - left_margin;
    618. 

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

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

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

  621.             }
    622. 

  622. 

  623.     }
    624. 

  624. #else
    625. 

  625.     // dcraw original code
    626. 

  626.     for (r=0; r < 8; r++) {
    627. 

  627.       irow = row - top_margin + r;
    628. 

  628.       if (irow >= height) continue;
    629. 

  629.       for (col=0; col < raw_width; col++) {
    630. 

  630. 	icol = col - left_margin;
    631. 

  631. 	c = FC(irow,icol);
    632. 

  632. 	if (icol < width)
    633. 

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

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

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

  636.       }
    637. 

  637.     }
    638. 

  638. #endif
    639. 

  639.   }
    640. 

  640.   free (pixel);
    641. 

  641.   FORC(2) free (huff[c]);
    642. 

  642.   FORC4 if (cblack[4+c]) cblack[c] /= cblack[4+c];
    643. 

  643. }
    644. 

  644. 

  645. int CLASS ljpeg_start (struct jhead *jh, int info_only)
    646. 

  646. {
    647. 

  647.   int c, tag, len;
    648. 

  648.   uchar data[0x10000];
    649. 

  649.   const uchar *dp;
    650. 

  650. 

  651.   memset (jh, 0, sizeof *jh);
    652. 

  652.   jh->restart = INT_MAX;
    653. 

  653.   fread (data, 2, 1, ifp);
    654. 

  654.   if (data[1] != 0xd8) return 0;
    655. 

  655.   do {
    656. 

  656.     fread (data, 2, 2, ifp);
    657. 

  657.     tag =  data[0] << 8 | data[1];
    658. 

  658.     len = (data[2] << 8 | data[3]) - 2;
    659. 

  659.     if (tag <= 0xff00) return 0;
    660. 

  660.     fread (data, 1, len, ifp);
    661. 

  661.     switch (tag) {
    662. 

  662.       case 0xffc3:
    663. 

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

  664.       case 0xffc0:
    665. 

  665. 	jh->bits = data[0];
    666. 

  666. 	jh->high = data[1] << 8 | data[2];
    667. 

  667. 	jh->wide = data[3] << 8 | data[4];
    668. 

  668. 	jh->clrs = data[5] + jh->sraw;
    669. 

  669. 	if (len == 9 && !dng_version) getc(ifp);
    670. 

  670. 	break;
    671. 

  671.       case 0xffc4:
    672. 

  672. 	if (info_only) break;
    673. 

  673. 	for (dp = data; dp < data+len && (c = *dp++) < 4; )
    674. 

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

  675. 	break;
    676. 

  676.       case 0xffda:
    677. 

  677. 	jh->psv = data[1+data[0]*2];
    678. 

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

  679. 	break;
    680. 

  680.       case 0xffdd:
    681. 

  681. 	jh->restart = data[0] << 8 | data[1];
    682. 

  682.     }
    683. 

  683.   } while (tag != 0xffda);
    684. 

  684.   if (info_only) return 1;
    685. 

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

  686.   if (jh->sraw) {
    687. 

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

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

  689.   }
    690. 

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

  691.   merror (jh->row, "ljpeg_start()");
    692. 

  692.   return zero_after_ff = 1;
    693. 

  693. }
    694. 

  694. 

  695. void CLASS ljpeg_end (struct jhead *jh)
    696. 

  696. {
    697. 

  697.   int c;
    698. 

  698.   FORC4 if (jh->free[c]) free (jh->free[c]);
    699. 

  699.   free (jh->row);
    700. 

  700. }
    701. 

  701. 

  702. // used for kodak-262 decoder
    703. 

  703. int CLASS ljpeg_diff (ushort *huff)
    704. 

  704. {
    705. 

  705.   int len, diff;
    706. 

  706. 

  707.   len = gethuff(huff);
    708. 

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

  709.     return -32768;
    710. 

  710.   diff = getbits(len);
    711. 

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

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

  713.   return diff;
    714. 

  714. }
    715. 

  715. 

  716. #ifdef LIBRAW_LIBRARY_BUILD
    717. 

  717. int CLASS ljpeg_diff_new (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    718. 

  718. {
    719. 

  719.   int len, diff;
    720. 

  720. 

  721.   len = bits._gethuff_lj(buf,*huff,huff+1);
    722. 

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

  723.     return -32768;
    724. 

  724.   diff = bits._getbits_lj(buf,len);
    725. 

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

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

  727.   return diff;
    728. 

  728. }
    729. 

  729. 

  730. int CLASS ljpeg_diff_pef (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    731. 

  731. {
    732. 

  732.   int len, diff;
    733. 

  733. 

  734.   len = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    735. 

  735.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    736. 

  736.     return -32768;
    737. 

  737.   diff = bits._getbits(buf,len,zero_after_ff);
    738. 

  738.   if ((diff & (1 << (len-1))) == 0)
    739. 

  739.     diff -= (1 << len) - 1;
    740. 

  740.   return diff;
    741. 

  741. }
    742. 

  742. 

  743. 

  744. #endif
    745. 

  745. 

  746. 

  747. ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
    748. 

  748. {
    749. 

  749.   int col, c, diff, pred, spred=0;
    750. 

  750.   ushort mark=0, *row[3];
    751. 

  751. 

  752.   if (jrow * jh->wide % jh->restart == 0) {
    753. 

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

  754.     if (jrow) {
    755. 

  755.       fseek (ifp, -2, SEEK_CUR);
    756. 

  756.       do mark = (mark << 8) + (c = fgetc(ifp));
    757. 

  757.       while (c != EOF && mark >> 4 != 0xffd);
    758. 

  758.     }
    759. 

  759.     getbits(-1);
    760. 

  760.   }
    761. 

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

  762.   for (col=0; col < jh->wide; col++)
    763. 

  763.     FORC(jh->clrs) {
    764. 

  764.       diff = ljpeg_diff (jh->huff[c]);
    765. 

  765.       if (jh->sraw && c <= jh->sraw && (col | c))
    766. 

  766. 		    pred = spred;
    767. 

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

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

  769.       if (jrow && col) switch (jh->psv) {
    770. 

  770. 	case 1:	break;
    771. 

  771. 	case 2: pred = row[1][0];					break;
    772. 

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

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

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

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

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

  777. 	default: pred = 0;
    778. 

  778.       }
    779. 

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

  780.       if (c <= jh->sraw) spred = **row;
    781. 

  781.       row[0]++; row[1]++;
    782. 

  782.     }
    783. 

  783.   return row[2];
    784. 

  784. }
    785. 

  785. 

  786. #ifdef LIBRAW_LIBRARY_BUILD
    787. 

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

  788. {
    789. 

  789.   int col, c, diff, pred, spred=0;
    790. 

  790.   ushort mark=0, *row[3];
    791. 

  791. 

  792.   if (jrow * jh->wide % jh->restart == 0) {
    793. 

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

  794.     if (jrow) {
    795. 

  795.         bytes->unseek2();
    796. 

  796.         do mark = (mark << 8) + (c = bytes->get_byte());
    797. 

  797.         while (c != EOF && mark >> 4 != 0xffd);
    798. 

  798.     }
    799. 

  799.     bits.reset();
    800. 

  800.   }
    801. 

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

  802.   for (col=0; col < jh->wide; col++)
    803. 

  803.     FORC(jh->clrs) {
    804. 

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

  805.       if (jh->sraw && c <= jh->sraw && (col | c))
    806. 

  806. 		    pred = spred;
    807. 

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

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

  809.       if (jrow && col) switch (jh->psv) {
    810. 

  810. 	case 1:	break;
    811. 

  811. 	case 2: pred = row[1][0];					break;
    812. 

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

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

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

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

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

  817. 	default: pred = 0;
    818. 

  818.       }
    819. 

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

  820.       if (c <= jh->sraw) spred = **row;
    821. 

  821.       row[0]++; row[1]++;
    822. 

  822.     }
    823. 

  823.   return row[2];
    824. 

  824. }
    825. 

  825. 

  826. #endif
    827. 

  827. 

  828. void CLASS lossless_jpeg_load_raw()
    829. 

  829. {
    830. 

  830.   int jwide, jrow, jcol, val, c, i, row=0, col=0;
    831. 

  831. #ifndef LIBRAW_LIBRARY_BUILD
    832. 

  832.   int jidx,j;
    833. 

  833. #endif
    834. 

  834.   struct jhead jh;
    835. 

  835.   int min=INT_MAX;
    836. 

  836.   ushort *rp;
    837. 

  837. #ifdef LIBRAW_LIBRARY_BUILD
    838. 

  838.   int save_min = 0;
    839. 

  839.   unsigned slicesW[16],slicesWcnt=0,slices;
    840. 

  840.   unsigned *offset;
    841. 

  841.   unsigned t_y=0,t_x=0,t_s=0,slice=0,pixelsInSlice,pixno;
    842. 

  842.   if (!strcasecmp(make,"KODAK"))
    843. 

  843.       save_min = 1;
    844. 

  844. #endif
    845. 

  845. 

  846. #ifdef LIBRAW_LIBRARY_BUILD
    847. 

  847.   if (cr2_slice[0]>15)
    848. 

  848.       throw LIBRAW_EXCEPTION_IO_EOF; // change many slices
    849. 

  849. #else
    850. 

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

  851.   return;
    852. 

  852. #endif
    853. 

  853. 

  854. 

  855.   if (!ljpeg_start (&jh, 0)) return;
    856. 

  856.   jwide = jh.wide * jh.clrs;
    857. 

  857. 

  858. #ifdef LIBRAW_LIBRARY_BUILD
    859. 

  859.   if(cr2_slice[0])
    860. 

  860.       {
    861. 

  861.           for(i=0;i<cr2_slice[0];i++)
    862. 

  862.               slicesW[slicesWcnt++] = cr2_slice[1];
    863. 

  863.           slicesW[slicesWcnt++] = cr2_slice[2];
    864. 

  864.       }
    865. 

  865.   else
    866. 

  866.       {
    867. 

  867.           // not sliced
    868. 

  868.           slicesW[slicesWcnt++] = raw_width; // safe fallback
    869. 

  869.       }
    870. 

  870.        
    871. 

  871.   slices = slicesWcnt * jh.high;
    872. 

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

  873.   
    874. 

  874.   for(slice=0;slice<slices;slice++)
    875. 

  875.       {
    876. 

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

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

  878.               throw LIBRAW_EXCEPTION_IO_BADFILE; 
    879. 

  879.           t_y++;
    880. 

  880.           if(t_y == jh.high)
    881. 

  881.               {
    882. 

  882.                   t_y = 0;
    883. 

  883.                   t_x += slicesW[t_s++];
    884. 

  884.               }
    885. 

  885.       }
    886. 

  886.   offset[slices] = offset[slices-1];
    887. 

  887.   slice = 1; // next slice
    888. 

  888.   pixno = offset[0];
    889. 

  889.   pixelsInSlice = slicesW[0];
    890. 

  890. #endif
    891. 

  891. 

  892. #ifdef LIBRAW_LIBRARY_BUILD
    893. 

  893.   LibRaw_byte_buffer *buf=NULL;
    894. 

  894.   if(data_size)
    895. 

  895.       buf = ifp->make_byte_buffer(data_size);
    896. 

  896.   LibRaw_bit_buffer bits;
    897. 

  897. #endif
    898. 

  898.   for (jrow=0; jrow < jh.high; jrow++) {
    899. 

  899. #ifdef LIBRAW_LIBRARY_BUILD
    900. 

  900.       if (data_size)
    901. 

  901.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    902. 

  902.       else
    903. 

  903. #endif
    904. 

  904.     rp = ljpeg_row (jrow, &jh);
    905. 

  905. 

  906.     if (load_flags & 1)
    907. 

  907.       row = jrow & 1 ? height-1-jrow/2 : jrow/2;
    908. 

  908.     for (jcol=0; jcol < jwide; jcol++) {
    909. 

  909.       val = *rp++;
    910. 

  910.       if (jh.bits <= 12)
    911. 

  911. 	val = curve[val & 0xfff];
    912. 

  912. #ifndef LIBRAW_LIBRARY_BUILD
    913. 

  913.       // slow dcraw way to calculate row/col
    914. 

  914.       if (cr2_slice[0]) {
    915. 

  915. 	jidx = jrow*jwide + jcol;
    916. 

  916. 	i = jidx / (cr2_slice[1]*jh.high);
    917. 

  917. 	if ((j = i >= cr2_slice[0]))
    918. 

  918. 		 i  = cr2_slice[0];
    919. 

  919. 	jidx -= i * (cr2_slice[1]*jh.high);
    920. 

  920. 	row = jidx / cr2_slice[1+j];
    921. 

  921. 	col = jidx % cr2_slice[1+j] + i*cr2_slice[1];
    922. 

  922.       }
    923. 

  923. #else
    924. 

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

  925.       if(data_size) 
    926. 

  926.           {
    927. 

  927.               row = pixno/raw_width;
    928. 

  928.               col = pixno % raw_width;
    929. 

  929.               pixno++;
    930. 

  930.               if (0 == --pixelsInSlice)
    931. 

  931.                   {
    932. 

  932.                       unsigned o = offset[slice++];
    933. 

  933.                       pixno = o & 0x0fffffff;
    934. 

  934.                       pixelsInSlice = slicesW[o>>28];
    935. 

  935.                   }
    936. 

  936.           }
    937. 

  937. #endif
    938. 

  938. #ifndef LIBRAW_LIBRARY_BUILD
    939. 

  939. 

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

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

  942. 

  943.       if ((unsigned) (row-top_margin) < height) {
    944. 

  944. 	c = FC(row-top_margin,col-left_margin);
    945. 

  945. 	if ((unsigned) (col-left_margin) < width) {
    946. 

  946. 	  BAYER(row-top_margin,col-left_margin) = val;
    947. 

  947. 	  if (min > val) min = val;
    948. 

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

  949. 	  cblack[c] += (cblack[4+c]++,val);
    950. 

  950.       }
    951. 

  951. #else
    952. 

  952.       if (raw_width == 3984)
    953. 

  953.           {
    954. 

  954.               if ( (col -= 2) < 0)
    955. 

  955.                   col += (row--,raw_width);
    956. 

  956.               if(row >= 0 && row < raw_height && col >= 0 && col < raw_width)
    957. 

  957.                   RBAYER(row,col) = val;
    958. 

  958.           }
    959. 

  959.       else 
    960. 

  960.           RBAYER(row,col) = val;
    961. 

  961. 

  962.       if ((unsigned) (row-top_margin) < height) 
    963. 

  963.           {
    964. 

  964.               // within image height
    965. 

  965.               if ((unsigned) (col-left_margin) < width) 
    966. 

  966.                   {
    967. 

  967.                       // within image area, save min
    968. 

  968.                       if(save_min)
    969. 

  969.                           if (min > val) min = val;
    970. 

  970.                   } 
    971. 

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

  972.                   {
    973. 

  973.                       c = FC(row-top_margin,col-left_margin);
    974. 

  974.                       cblack[c] += (cblack[4+c]++,val);
    975. 

  975.                   }
    976. 

  976.           }
    977. 

  977. #endif
    978. 

  978. 

  979. #ifndef LIBRAW_LIBRARY_BUILD
    980. 

  980.       if (++col >= raw_width)
    981. 

  981. 	col = (row++,0);
    982. 

  982. #else
    983. 

  983.       if(!data_size) // 1D or 1Ds case
    984. 

  984.           if (++col >= raw_width)
    985. 

  985.               col = (row++,0);
    986. 

  986. #endif
    987. 

  987.     }
    988. 

  988.   }
    989. 

  989.   ljpeg_end (&jh);
    990. 

  990.   FORC4 if (cblack[4+c]) cblack[c] /= cblack[4+c];
    991. 

  991.   if (!strcasecmp(make,"KODAK"))
    992. 

  992.     black = min;
    993. 

  993. #ifdef LIBRAW_LIBRARY_BUILD
    994. 

  994.   if(buf)
    995. 

  995.       delete buf;
    996. 

  996.   free(offset);
    997. 

  997. #endif
    998. 

  998. }
    999. 

  999. 

  1000. void CLASS canon_sraw_load_raw()
    1001. 

  1001. {
    1002. 

  1002.   struct jhead jh;
    1003. 

  1003.   short *rp=0, (*ip)[4];
    1004. 

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

  1005.   int v[3]={0,0,0}, ver, hue;
    1006. 

  1006.   char *cp;
    1007. 

  1007. 

  1008.   if (!ljpeg_start (&jh, 0)) return;
    1009. 

  1009.   jwide = (jh.wide >>= 1) * jh.clrs;
    1010. 

  1010. 

  1011. #ifdef LIBRAW_LIBRARY_BUILD
    1012. 

  1012.   if(!data_size)
    1013. 

  1013.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1014. 

  1014.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1015. 

  1015.   LibRaw_bit_buffer bits;
    1016. 

  1016. #endif
    1017. 

  1017. 

  1018. 

  1019.   for (ecol=slice=0; slice <= cr2_slice[0]; slice++) {
    1020. 

  1020.     scol = ecol;
    1021. 

  1021.     ecol += cr2_slice[1] * 2 / jh.clrs;
    1022. 

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

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

  1024.       ip = (short (*)[4]) image + row*width;
    1025. 

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

  1026. 	if ((jcol %= jwide) == 0)
    1027. 

  1027. #ifdef LIBRAW_LIBRARY_BUILD
    1028. 

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

  1029. #else
    1030. 

  1030.             rp = (short *) ljpeg_row (jrow++, &jh);
    1031. 

  1031. #endif
    1032. 

  1032. 	if (col >= width) continue;
    1033. 

  1033. 	FORC (jh.clrs-2)
    1034. 

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

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

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

  1037.       }
    1038. 

  1038.     }
    1039. 

  1039.   }
    1040. 

  1040.   for (cp=model2; *cp && !isdigit(*cp); cp++);
    1041. 

  1041.   sscanf (cp, "%d.%d.%d", v, v+1, v+2);
    1042. 

  1042.   ver = (v[0]*1000 + v[1])*1000 + v[2];
    1043. 

  1043.   hue = (jh.sraw+1) << 2;
    1044. 

  1044.   if (unique_id >= 0x80000281 || (unique_id == 0x80000218 && ver > 1000006))
    1045. 

  1045.     hue = jh.sraw << 1;
    1046. 

  1046.   ip = (short (*)[4]) image;
    1047. 

  1047.   rp = ip[0];
    1048. 

  1048.   for (row=0; row < height; row++, ip+=width) {
    1049. 

  1049.     if (row & (jh.sraw >> 1))
    1050. 

  1050.       for (col=0; col < width; col+=2)
    1051. 

  1051. 	for (c=1; c < 3; c++)
    1052. 

  1052. 	  if (row == height-1)
    1053. 

  1053. 	       ip[col][c] =  ip[col-width][c];
    1054. 

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

  1055.     for (col=1; col < width; col+=2)
    1056. 

  1056.       for (c=1; c < 3; c++)
    1057. 

  1057. 	if (col == width-1)
    1058. 

  1058. 	     ip[col][c] =  ip[col-1][c];
    1059. 

  1059. 	else ip[col][c] = (ip[col-1][c] + ip[col+1][c] + 1) >> 1;
    1060. 

  1060.   }
    1061. 

  1061.   for ( ; rp < ip[0]; rp+=4) {
    1062. 

  1062.     if (unique_id < 0x80000218) {
    1063. 

  1063.       pix[0] = rp[0] + rp[2] - 512;
    1064. 

  1064.       pix[2] = rp[0] + rp[1] - 512;
    1065. 

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

  1066.     } else {
    1067. 

  1067.       rp[1] = (rp[1] << 2) + hue;
    1068. 

  1068.       rp[2] = (rp[2] << 2) + hue;
    1069. 

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

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

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

  1072.     }
    1073. 

  1073.     FORC3 
    1074. 

  1074.         rp[c] = CLIP(pix[c] * sraw_mul[c] >> 10);
    1075. 

  1075.   }
    1076. 

  1076. #ifdef LIBRAW_LIBRARY_BUILD
    1077. 

  1077.   delete buf;
    1078. 

  1078. #endif
    1079. 

  1079.   ljpeg_end (&jh);
    1080. 

  1080.   maximum = 0x3fff;
    1081. 

  1081. }
    1082. 

  1082. 

  1083. void CLASS adobe_copy_pixel (int row, int col, ushort **rp)
    1084. 

  1084. {
    1085. 

  1085.   unsigned r, c;
    1086. 

  1086. 

  1087. #ifndef LIBRAW_LIBRARY_BUILD
    1088. 

  1088.   r = row -= top_margin;
    1089. 

  1089.   c = col -= left_margin;
    1090. 

  1090.   if (is_raw == 2 && shot_select) (*rp)++;
    1091. 

  1091.   if (filters) {
    1092. 

  1092.     if (fuji_width) {
    1093. 

  1093.       r = row + fuji_width - 1 - (col >> 1);
    1094. 

  1094.       c = row + ((col+1) >> 1);
    1095. 

  1095.     }
    1096. 

  1096.     if (r < height && c < width)
    1097. 

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

  1098.     *rp += is_raw;
    1099. 

  1099.   } else {
    1100. 

  1100.     if (r < height && c < width)
    1101. 

  1101.       FORC(tiff_samples)
    1102. 

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

  1103.     *rp += tiff_samples;
    1104. 

  1104.   }
    1105. 

  1105. #else
    1106. 

  1106.   if (is_raw == 2 && shot_select) (*rp)++;
    1107. 

  1107.   if (filters) {
    1108. 

  1108.       if(row < raw_height && col < raw_width)
    1109. 

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

  1110.     *rp += is_raw;
    1111. 

  1111.   } else {
    1112. 

  1112.       if (row < raw_height && col < raw_width)
    1113. 

  1113.           FORC(tiff_samples)
    1114. 

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

  1115.       *rp += tiff_samples;
    1116. 

  1116.   }
    1117. 

  1117. 

  1118. #endif
    1119. 

  1119.   if (is_raw == 2 && shot_select) (*rp)--;
    1120. 

  1120. 

  1121. }
    1122. 

  1122. 

  1123. void CLASS adobe_dng_load_raw_lj()
    1124. 

  1124. {
    1125. 

  1125.   unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col;
    1126. 

  1126.   struct jhead jh;
    1127. 

  1127.   ushort *rp;
    1128. 

  1128.   while (trow < raw_height) {
    1129. 

  1129.     save = ftell(ifp);
    1130. 

  1130.     if (tile_length < INT_MAX)
    1131. 

  1131.       fseek (ifp, get4(), SEEK_SET);
    1132. 

  1132.     if (!ljpeg_start (&jh, 0)) break;
    1133. 

  1133.     jwide = jh.wide;
    1134. 

  1134.     if (filters) jwide *= jh.clrs;
    1135. 

  1135.     jwide /= is_raw;
    1136. 

  1136. #ifdef LIBRAW_LIBRARY_BUILD
    1137. 

  1137.     if(!data_size)
    1138. 

  1138.         throw LIBRAW_EXCEPTION_IO_BADFILE;
    1139. 

  1139.     LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1140. 

  1140.     LibRaw_bit_buffer bits;
    1141. 

  1141. #endif
    1142. 

  1142.     for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1143. 

  1143. #ifdef LIBRAW_LIBRARY_BUILD
    1144. 

  1144.         rp = ljpeg_row_new (jrow, &jh,bits,buf);
    1145. 

  1145. #else
    1146. 

  1146.         rp = ljpeg_row (jrow, &jh);
    1147. 

  1147. #endif
    1148. 

  1148.       for (jcol=0; jcol < jwide; jcol++) {
    1149. 

  1149. 	adobe_copy_pixel (trow+row, tcol+col, &rp);
    1150. 

  1150. 	if (++col >= tile_width || col >= raw_width)
    1151. 

  1151. 	  row += 1 + (col = 0);
    1152. 

  1152.       }
    1153. 

  1153.     }
    1154. 

  1154.     fseek (ifp, save+4, SEEK_SET);
    1155. 

  1155.     if ((tcol += tile_width) >= raw_width)
    1156. 

  1156.       trow += tile_length + (tcol = 0);
    1157. 

  1157.     ljpeg_end (&jh);
    1158. 

  1158. #ifdef LIBRAW_LIBRARY_BUILD
    1159. 

  1159.     delete buf;
    1160. 

  1160. #endif
    1161. 

  1161.   }
    1162. 

  1162. }
    1163. 

  1163. 

  1164. void CLASS adobe_dng_load_raw_nc()
    1165. 

  1165. {
    1166. 

  1166.   ushort *pixel, *rp;
    1167. 

  1167.   int row, col;
    1168. 

  1168. 

  1169.   pixel = (ushort *) calloc (raw_width * tiff_samples, sizeof *pixel);
    1170. 

  1170.   merror (pixel, "adobe_dng_load_raw_nc()");
    1171. 

  1171. 

  1172. 

  1173. #ifdef LIBRAW_LIBRARY_BUILD
    1174. 

  1174.   int dsz= raw_height*raw_width * tiff_samples * tiff_bps/8;
    1175. 

  1175.   LibRaw_byte_buffer *buf = NULL;
    1176. 

  1176.   if (tiff_bps != 16)
    1177. 

  1177.       {
    1178. 

  1178.           buf = ifp->make_byte_buffer(dsz);
    1179. 

  1179.       }
    1180. 

  1180.   LibRaw_bit_buffer bits;
    1181. 

  1181. #endif
    1182. 

  1182. 

  1183.   for (row=0; row < raw_height; row++) {
    1184. 

  1184.     if (tiff_bps == 16)
    1185. 

  1185.       read_shorts (pixel, raw_width * tiff_samples);
    1186. 

  1186.     else {
    1187. 

  1187. #ifdef LIBRAW_LIBRARY_BUILD
    1188. 

  1188.         bits.reset();
    1189. 

  1189.         for (col=0; col < raw_width * tiff_samples; col++)
    1190. 

  1190.             pixel[col] = bits._getbits(buf,tiff_bps,zero_after_ff);
    1191. 

  1191. 

  1192. #else
    1193. 

  1193.       getbits(-1);
    1194. 

  1194.       for (col=0; col < raw_width * tiff_samples; col++)
    1195. 

  1195. 	pixel[col] = getbits(tiff_bps);
    1196. 

  1196. #endif
    1197. 

  1197.     }
    1198. 

  1198.     for (rp=pixel, col=0; col < raw_width; col++)
    1199. 

  1199.       adobe_copy_pixel (row, col, &rp);
    1200. 

  1200.   }
    1201. 

  1201.   free (pixel);
    1202. 

  1202. #ifdef LIBRAW_LIBRARY_BUILD
    1203. 

  1203.     if(buf)
    1204. 

  1204.         delete buf;
    1205. 

  1205. #endif
    1206. 

  1206. }
    1207. 

  1207. 

  1208. void CLASS pentax_load_raw()
    1209. 

  1209. {
    1210. 

  1210.   ushort bit[2][15], huff[4097];
    1211. 

  1211.   int dep, row, col, diff, c, i;
    1212. 

  1212.   ushort vpred[2][2] = {{0,0},{0,0}}, hpred[2];
    1213. 

  1213. 

  1214.   fseek (ifp, meta_offset, SEEK_SET);
    1215. 

  1215.   dep = (get2() + 12) & 15;
    1216. 

  1216.   fseek (ifp, 12, SEEK_CUR);
    1217. 

  1217.   FORC(dep) bit[0][c] = get2();
    1218. 

  1218.   FORC(dep) bit[1][c] = fgetc(ifp);
    1219. 

  1219.   FORC(dep)
    1220. 

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

  1221.       huff[++i] = bit[1][c] << 8 | c;
    1222. 

  1222.   huff[0] = 12;
    1223. 

  1223.   fseek (ifp, data_offset, SEEK_SET);
    1224. 

  1224. #ifdef LIBRAW_LIBRARY_BUILD
    1225. 

  1225.   if(!data_size)
    1226. 

  1226.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1227. 

  1227.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1228. 

  1228.   LibRaw_bit_buffer bits;
    1229. 

  1229.   bits.reset();
    1230. 

  1230. #else
    1231. 

  1231.   getbits(-1);
    1232. 

  1232. #endif
    1233. 

  1233.   for (row=0; row < raw_height; row++)
    1234. 

  1234.       {
    1235. 

  1235.           for (col=0; col < raw_width; col++) {
    1236. 

  1236. #ifdef LIBRAW_LIBRARY_BUILD
    1237. 

  1237.               diff = ljpeg_diff_pef(bits,buf,huff);
    1238. 

  1238. #else
    1239. 

  1239.               diff = ljpeg_diff (huff);
    1240. 

  1240. #endif
    1241. 

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

  1242.               else	   hpred[col & 1] += diff;
    1243. 

  1243. 

  1244.               unsigned val = hpred[col & 1];
    1245. 

  1245. 

  1246. #ifndef LIBRAW_LIBRARY_BUILD
    1247. 

  1247.               if ((unsigned) (row-top_margin) < height && 
    1248. 

  1248.                   (unsigned)(col-left_margin) < width)
    1249. 

  1249.                   BAYER(row-top_margin,col-left_margin) = val;
    1250. 

  1250. #else
    1251. 

  1251.               RBAYER(row,col) = val;
    1252. 

  1252. #endif
    1253. 

  1253.               if (val >> tiff_bps) derror();
    1254. 

  1254.           }
    1255. 

  1255.       }
    1256. 

  1256. #ifdef LIBRAW_LIBRARY_BUILD
    1257. 

  1257.   delete buf;
    1258. 

  1258. #endif
    1259. 

  1259. }
    1260. 

  1260. 

  1261. void CLASS nikon_compressed_load_raw()
    1262. 

  1262. {
    1263. 

  1263.   static const uchar nikon_tree[][32] = {
    1264. 

  1264.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy */
    1265. 

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

  1266.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy after split */
    1267. 

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

  1268.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,  /* 12-bit lossless */
    1269. 

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

  1270.     { 0,1,4,3,1,1,1,1,1,2,0,0,0,0,0,0,	/* 14-bit lossy */
    1271. 

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

  1272.     { 0,1,5,1,1,1,1,1,1,1,2,0,0,0,0,0,	/* 14-bit lossy after split */
    1273. 

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

  1274.     { 0,1,4,2,2,3,1,2,0,0,0,0,0,0,0,0,	/* 14-bit lossless */
    1275. 

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

  1276.   ushort *huff, ver0, ver1, vpred[2][2], hpred[2], csize;
    1277. 

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

  1278. 

  1279.   fseek (ifp, meta_offset, SEEK_SET);
    1280. 

  1280.   ver0 = fgetc(ifp);
    1281. 

  1281.   ver1 = fgetc(ifp);
    1282. 

  1282.   if (ver0 == 0x49 || ver1 == 0x58)
    1283. 

  1283.     fseek (ifp, 2110, SEEK_CUR);
    1284. 

  1284.   if (ver0 == 0x46) tree = 2;
    1285. 

  1285.   if (tiff_bps == 14) tree += 3;
    1286. 

  1286.   read_shorts (vpred[0], 4);
    1287. 

  1287.   max = 1 << tiff_bps & 0x7fff;
    1288. 

  1288.   if ((csize = get2()) > 1)
    1289. 

  1289.     step = max / (csize-1);
    1290. 

  1290.   if (ver0 == 0x44 && ver1 == 0x20 && step > 0) {
    1291. 

  1291.     for (i=0; i < csize; i++)
    1292. 

  1292.       curve[i*step] = get2();
    1293. 

  1293.     for (i=0; i < max; i++)
    1294. 

  1294.       curve[i] = ( curve[i-i%step]*(step-i%step) +
    1295. 

  1295. 		   curve[i-i%step+step]*(i%step) ) / step;
    1296. 

  1296. #ifdef LIBRAW_LIBRARY_BUILD
    1297. 

  1297.     color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    1298. 

  1298. #endif
    1299. 

  1299.     fseek (ifp, meta_offset+562, SEEK_SET);
    1300. 

  1300.     split = get2();
    1301. 

  1301.   } else if (ver0 != 0x46 && csize <= 0x4001)
    1302. 

  1302.       {
    1303. 

  1303.     read_shorts (curve, max=csize);
    1304. 

  1304. #ifdef LIBRAW_LIBRARY_BUILD
    1305. 

  1305.     color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    1306. 

  1306. #endif
    1307. 

  1307.       }
    1308. 

  1308.   while (curve[max-2] == curve[max-1]) max--;
    1309. 

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

  1310.   fseek (ifp, data_offset, SEEK_SET);
    1311. 

  1311. #ifdef LIBRAW_LIBRARY_BUILD
    1312. 

  1312.   if(!data_size)
    1313. 

  1313.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1314. 

  1314.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1315. 

  1315.   LibRaw_bit_buffer bits;
    1316. 

  1316.   bits.reset();
    1317. 

  1317. #else
    1318. 

  1318.   getbits(-1);
    1319. 

  1319. #endif
    1320. 

  1320.   for (min=row=0; row < height; row++) {
    1321. 

  1321.     if (split && row == split) {
    1322. 

  1322.       free (huff);
    1323. 

  1323.       huff = make_decoder (nikon_tree[tree+1]);
    1324. 

  1324.       max += (min = 16) << 1;
    1325. 

  1325.     }
    1326. 

  1326.     for (col=0; col < raw_width; col++) {
    1327. 

  1327. #ifdef LIBRAW_LIBRARY_BUILD
    1328. 

  1328.         i = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    1329. 

  1329. #else
    1330. 

  1330.       i = gethuff(huff);
    1331. 

  1331. #endif
    1332. 

  1332.       len = i & 15;
    1333. 

  1333.       shl = i >> 4;
    1334. 

  1334. #ifdef LIBRAW_LIBRARY_BUILD
    1335. 

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

  1336. #else
    1337. 

  1337.       diff = ((getbits(len-shl) << 1) + 1) << shl >> 1;
    1338. 

  1338. #endif
    1339. 

  1339.       if ((diff & (1 << (len-1))) == 0)
    1340. 

  1340. 	diff -= (1 << len) - !shl;
    1341. 

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

  1342.       else	   hpred[col & 1] += diff;
    1343. 

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

  1344. #ifndef LIBRAW_LIBRARY_BUILD
    1345. 

  1345.       if ((unsigned) (col-left_margin) < width)
    1346. 

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

  1347. #else
    1348. 

  1348.       ushort xval = hpred[col & 1];
    1349. 

  1349.       xval = curve[LIM((short)xval,0,0x3fff)];
    1350. 

  1350.       RBAYER(row,col) = xval;
    1351. 

  1351. #endif
    1352. 

  1352. 

  1353.     }
    1354. 

  1354.   }
    1355. 

  1355. #ifdef LIBRAW_LIBRARY_BUILD
    1356. 

  1356.   delete buf;
    1357. 

  1357. #endif
    1358. 

  1358.   free (huff);
    1359. 

  1359. }
    1360. 

  1360. 

  1361. /*
    1362. 

  1362.    Figure out if a NEF file is compressed.  These fancy heuristics
    1363. 

  1363.    are only needed for the D100, thanks to a bug in some cameras
    1364. 

  1364.    that tags all images as "compressed".
    1365. 

  1365.  */
    1366. 

  1366. int CLASS nikon_is_compressed()
    1367. 

  1367. {
    1368. 

  1368.   uchar test[256];
    1369. 

  1369.   int i;
    1370. 

  1370. 

  1371.   fseek (ifp, data_offset, SEEK_SET);
    1372. 

  1372.   fread (test, 1, 256, ifp);
    1373. 

  1373.   for (i=15; i < 256; i+=16)
    1374. 

  1374.     if (test[i]) return 1;
    1375. 

  1375.   return 0;
    1376. 

  1376. }
    1377. 

  1377. 

  1378. /*
    1379. 

  1379.    Returns 1 for a Coolpix 995, 0 for anything else.
    1380. 

  1380.  */
    1381. 

  1381. int CLASS nikon_e995()
    1382. 

  1382. {
    1383. 

  1383.   int i, histo[256];
    1384. 

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

  1385. 

  1386.   memset (histo, 0, sizeof histo);
    1387. 

  1387.   fseek (ifp, -2000, SEEK_END);
    1388. 

  1388.   for (i=0; i < 2000; i++)
    1389. 

  1389.     histo[fgetc(ifp)]++;
    1390. 

  1390.   for (i=0; i < 4; i++)
    1391. 

  1391.     if (histo[often[i]] < 200)
    1392. 

  1392.       return 0;
    1393. 

  1393.   return 1;
    1394. 

  1394. }
    1395. 

  1395. 

  1396. /*
    1397. 

  1397.    Returns 1 for a Coolpix 2100, 0 for anything else.
    1398. 

  1398.  */
    1399. 

  1399. int CLASS nikon_e2100()
    1400. 

  1400. {
    1401. 

  1401.   uchar t[12];
    1402. 

  1402.   int i;
    1403. 

  1403. 

  1404.   fseek (ifp, 0, SEEK_SET);
    1405. 

  1405.   for (i=0; i < 1024; i++) {
    1406. 

  1406.     fread (t, 1, 12, ifp);
    1407. 

  1407.     if (((t[2] & t[4] & t[7] & t[9]) >> 4
    1408. 

  1408. 	& t[1] & t[6] & t[8] & t[11] & 3) != 3)
    1409. 

  1409.       return 0;
    1410. 

  1410.   }
    1411. 

  1411.   return 1;
    1412. 

  1412. }
    1413. 

  1413. 

  1414. void CLASS nikon_3700()
    1415. 

  1415. {
    1416. 

  1416.   int bits, i;
    1417. 

  1417.   uchar dp[24];
    1418. 

  1418.   static const struct {
    1419. 

  1419.     int bits;
    1420. 

  1420.     char t_make[12], t_model[15];
    1421. 

  1421.   } table[] = {
    1422. 

  1422.     { 0x00, "PENTAX",  "Optio 33WR" },
    1423. 

  1423.     { 0x03, "NIKON",   "E3200" },
    1424. 

  1424.     { 0x32, "NIKON",   "E3700" },
    1425. 

  1425.     { 0x33, "OLYMPUS", "C740UZ" } };
    1426. 

  1426. 

  1427.   fseek (ifp, 3072, SEEK_SET);
    1428. 

  1428.   fread (dp, 1, 24, ifp);
    1429. 

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

  1430.   for (i=0; i < sizeof table / sizeof *table; i++)
    1431. 

  1431.     if (bits == table[i].bits) {
    1432. 

  1432.       strcpy (make,  table[i].t_make );
    1433. 

  1433.       strcpy (model, table[i].t_model);
    1434. 

  1434.     }
    1435. 

  1435. }
    1436. 

  1436. 

  1437. /*
    1438. 

  1438.    Separates a Minolta DiMAGE Z2 from a Nikon E4300.
    1439. 

  1439.  */
    1440. 

  1440. int CLASS minolta_z2()
    1441. 

  1441. {
    1442. 

  1442.   int i, nz;
    1443. 

  1443.   char tail[424];
    1444. 

  1444. 

  1445.   fseek (ifp, -sizeof tail, SEEK_END);
    1446. 

  1446.   fread (tail, 1, sizeof tail, ifp);
    1447. 

  1447.   for (nz=i=0; i < sizeof tail; i++)
    1448. 

  1448.     if (tail[i]) nz++;
    1449. 

  1449.   return nz > 20;
    1450. 

  1450. }
    1451. 

  1451. 

  1452. /*
    1453. 

  1453.    The Fuji Super CCD is just a Bayer grid rotated 45 degrees.
    1454. 

  1454.  */
    1455. 

  1455. void CLASS fuji_load_raw()
    1456. 

  1456. {
    1457. 

  1457. #ifndef LIBRAW_LIBRARY_BUILD
    1458. 

  1458.   ushort *pixel;
    1459. 

  1459.   int wide, row, col, r, c;
    1460. 

  1460. 

  1461.   fseek (ifp, (top_margin*raw_width + left_margin) * 2, SEEK_CUR);
    1462. 

  1462.   wide = fuji_width << !fuji_layout;
    1463. 

  1463.   pixel = (ushort *) calloc (wide, sizeof *pixel);
    1464. 

  1464.   merror (pixel, "fuji_load_raw()");
    1465. 

  1465.   for (row=0; row < raw_height; row++) {
    1466. 

  1466.     read_shorts (pixel, wide);
    1467. 

  1467.     fseek (ifp, 2*(raw_width - wide), SEEK_CUR);
    1468. 

  1468.     for (col=0; col < wide; col++) {
    1469. 

  1469.       if (fuji_layout) {
    1470. 

  1470. 	r = fuji_width - 1 - col + (row >> 1);
    1471. 

  1471. 	c = col + ((row+1) >> 1);
    1472. 

  1472.       } else {
    1473. 

  1473. 	r = fuji_width - 1 + row - (col >> 1);
    1474. 

  1474. 	c = row + ((col+1) >> 1);
    1475. 

  1475.       }
    1476. 

  1476.       BAYER(r,c) = pixel[col];
    1477. 

  1477.     }
    1478. 

  1478.   }
    1479. 

  1479.   free (pixel);
    1480. 

  1480. #else
    1481. 

  1481.   read_shorts(raw_image,raw_width*raw_height);
    1482. 

  1482. #endif
    1483. 

  1483. }
    1484. 

  1484. void CLASS ppm_thumb()
    1485. 

  1485. {
    1486. 

  1486.   char *thumb;
    1487. 

  1487.   thumb_length = thumb_width*thumb_height*3;
    1488. 

  1488.   thumb = (char *) malloc (thumb_length);
    1489. 

  1489.   merror (thumb, "ppm_thumb()");
    1490. 

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

  1491.   fread  (thumb, 1, thumb_length, ifp);
    1492. 

  1492.   fwrite (thumb, 1, thumb_length, ofp);
    1493. 

  1493.   free (thumb);
    1494. 

  1494. }
    1495. 

  1495. 

  1496. void CLASS layer_thumb()
    1497. 

  1497. {
    1498. 

  1498.   int i, c;
    1499. 

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

  1500. 

  1501.   colors = thumb_misc >> 5 & 7;
    1502. 

  1502.   thumb_length = thumb_width*thumb_height;
    1503. 

  1503.   thumb = (char *) calloc (colors, thumb_length);
    1504. 

  1504.   merror (thumb, "layer_thumb()");
    1505. 

  1505.   fprintf (ofp, "P%d\n%d %d\n255\n",
    1506. 

  1506. 	5 + (colors >> 1), thumb_width, thumb_height);
    1507. 

  1507.   fread (thumb, thumb_length, colors, ifp);
    1508. 

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

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

  1510.   free (thumb);
    1511. 

  1511. }
    1512. 

  1512. 

  1513. void CLASS rollei_thumb()
    1514. 

  1514. {
    1515. 

  1515.   unsigned i;
    1516. 

  1516.   ushort *thumb;
    1517. 

  1517. 

  1518.   thumb_length = thumb_width * thumb_height;
    1519. 

  1519.   thumb = (ushort *) calloc (thumb_length, 2);
    1520. 

  1520.   merror (thumb, "rollei_thumb()");
    1521. 

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

  1522.   read_shorts (thumb, thumb_length);
    1523. 

  1523.   for (i=0; i < thumb_length; i++) {
    1524. 

  1524.     putc (thumb[i] << 3, ofp);
    1525. 

  1525.     putc (thumb[i] >> 5  << 2, ofp);
    1526. 

  1526.     putc (thumb[i] >> 11 << 3, ofp);
    1527. 

  1527.   }
    1528. 

  1528.   free (thumb);
    1529. 

  1529. }
    1530. 

  1530. 

  1531. void CLASS rollei_load_raw()
    1532. 

  1532. {
    1533. 

  1533.   uchar pixel[10];
    1534. 

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

  1535. 

  1536.   isix = raw_width * raw_height * 5 / 8;
    1537. 

  1537.   while (fread (pixel, 1, 10, ifp) == 10) {
    1538. 

  1538.     for (i=0; i < 10; i+=2) {
    1539. 

  1539.       todo[i]   = iten++;
    1540. 

  1540.       todo[i+1] = pixel[i] << 8 | pixel[i+1];
    1541. 

  1541.       buffer    = pixel[i] >> 2 | buffer << 6;
    1542. 

  1542.     }
    1543. 

  1543.     for (   ; i < 16; i+=2) {
    1544. 

  1544.       todo[i]   = isix++;
    1545. 

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

  1546.     }
    1547. 

  1547.     for (i=0; i < 16; i+=2) {
    1548. 

  1548. #ifndef LIBRAW_LIBRARY_BUILD
    1549. 

  1549.       row = todo[i] / raw_width - top_margin;
    1550. 

  1550.       col = todo[i] % raw_width - left_margin;
    1551. 

  1551.       if (row < height && col < width)
    1552. 

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

  1553. #else
    1554. 

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

  1555. #endif
    1556. 

  1556.     }
    1557. 

  1557.   }
    1558. 

  1558.   maximum = 0x3ff;
    1559. 

  1559. }
    1560. 

  1560. 

  1561. int CLASS bayer (unsigned row, unsigned col)
    1562. 

  1562. {
    1563. 

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

  1564. }
    1565. 

  1565. 

  1566. void CLASS phase_one_flat_field (int is_float, int nc)
    1567. 

  1567. {
    1568. 

  1568.   ushort head[8];
    1569. 

  1569.   unsigned wide, y, x, c, rend, cend, row, col;
    1570. 

  1570.   float *mrow, num, mult[4];
    1571. 

  1571. 

  1572.   read_shorts (head, 8);
    1573. 

  1573.   wide = head[2] / head[4];
    1574. 

  1574.   mrow = (float *) calloc (nc*wide, sizeof *mrow);
    1575. 

  1575.   merror (mrow, "phase_one_flat_field()");
    1576. 

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

  1577.     for (x=0; x < wide; x++)
    1578. 

  1578.       for (c=0; c < nc; c+=2) {
    1579. 

  1579. 	num = is_float ? getreal(11) : get2()/32768.0;
    1580. 

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

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

  1582.       }
    1583. 

  1583.     if (y==0) continue;
    1584. 

  1584.     rend = head[1]-top_margin + y*head[5];
    1585. 

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

  1586.       for (x=1; x < wide; x++) {
    1587. 

  1587. 	for (c=0; c < nc; c+=2) {
    1588. 

  1588. 	  mult[c] = mrow[c*wide+x-1];
    1589. 

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

  1590. 	}
    1591. 

  1591. 	cend = head[0]-left_margin + x*head[4];
    1592. 

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

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

  1594. 	  if (!(c & 1)) {
    1595. 

  1595. 	    c = BAYER(row,col) * mult[c];
    1596. 

  1596. 	    BAYER(row,col) = LIM(c,0,65535);
    1597. 

  1597. 	  }
    1598. 

  1598. 	  for (c=0; c < nc; c+=2)
    1599. 

  1599. 	    mult[c] += mult[c+1];
    1600. 

  1600. 	}
    1601. 

  1601.       }
    1602. 

  1602.       for (x=0; x < wide; x++)
    1603. 

  1603. 	for (c=0; c < nc; c+=2)
    1604. 

  1604. 	  mrow[c*wide+x] += mrow[(c+1)*wide+x];
    1605. 

  1605.     }
    1606. 

  1606.   }
    1607. 

  1607.   free (mrow);
    1608. 

  1608. }
    1609. 

  1609. 

  1610. void CLASS phase_one_correct()
    1611. 

  1611. {
    1612. 

  1612.   unsigned entries, tag, data, save, col, row, type;
    1613. 

  1613.   int len, i, j, k, cip, val[4], dev[4], sum, max;
    1614. 

  1614.   int head[9], diff, mindiff=INT_MAX, off_412=0;
    1615. 

  1615.   static const signed char dir[12][2] =
    1616. 

  1616.     { {-1,-1}, {-1,1}, {1,-1}, {1,1}, {-2,0}, {0,-2}, {0,2}, {2,0},
    1617. 

  1617.       {-2,-2}, {-2,2}, {2,-2}, {2,2} };
    1618. 

  1618.   float poly[8], num, cfrac, frac, mult[2], *yval[2];
    1619. 

  1619.   ushort *xval[2];
    1620. 

  1620. 

  1621.   if (half_size || !meta_length) return;
    1622. 

  1622. #ifdef DCRAW_VERBOSE
    1623. 

  1623.   if (verbose) fprintf (stderr,_("Phase One correction...\n"));
    1624. 

  1624. #endif
    1625. 

  1625.   fseek (ifp, meta_offset, SEEK_SET);
    1626. 

  1626.   order = get2();
    1627. 

  1627.   fseek (ifp, 6, SEEK_CUR);
    1628. 

  1628.   fseek (ifp, meta_offset+get4(), SEEK_SET);
    1629. 

  1629.   entries = get4();  get4();
    1630. 

  1630.   while (entries--) {
    1631. 

  1631.     tag  = get4();
    1632. 

  1632.     len  = get4();
    1633. 

  1633.     data = get4();
    1634. 

  1634.     save = ftell(ifp);
    1635. 

  1635.     fseek (ifp, meta_offset+data, SEEK_SET);
    1636. 

  1636.     if (tag == 0x419) {				/* Polynomial curve */
    1637. 

  1637.       for (get4(), i=0; i < 8; i++)
    1638. 

  1638. 	poly[i] = getreal(11);
    1639. 

  1639.       poly[3] += (ph1.tag_210 - poly[7]) * poly[6] + 1;
    1640. 

  1640.       for (i=0; i < 0x10000; i++) {
    1641. 

  1641. 	num = (poly[5]*i + poly[3])*i + poly[1];
    1642. 

  1642. 	curve[i] = LIM(num,0,65535);
    1643. 

  1643.       } goto apply;				/* apply to right half */
    1644. 

  1644.     } else if (tag == 0x41a) {			/* Polynomial curve */
    1645. 

  1645.       for (i=0; i < 4; i++)
    1646. 

  1646. 	poly[i] = getreal(11);
    1647. 

  1647.       for (i=0; i < 0x10000; i++) {
    1648. 

  1648. 	for (num=0, j=4; j--; )
    1649. 

  1649. 	  num = num * i + poly[j];
    1650. 

  1650. 	curve[i] = LIM(num+i,0,65535);
    1651. 

  1651.       } apply:					/* apply to whole image */
    1652. 

  1652.       for (row=0; row < height; row++)
    1653. 

  1653. 	for (col = (tag & 1)*ph1.split_col; col < width; col++)
    1654. 

  1654. 	  BAYER(row,col) = curve[BAYER(row,col)];
    1655. 

  1655.     } else if (tag == 0x400) {			/* Sensor defects */
    1656. 

  1656.       while ((len -= 8) >= 0) {
    1657. 

  1657. 	col  = get2() - left_margin;
    1658. 

  1658. 	row  = get2() - top_margin;
    1659. 

  1659. 	type = get2(); get2();
    1660. 

  1660. 	if (col >= width) continue;
    1661. 

  1661. 	if (type == 131)			/* Bad column */
    1662. 

  1662. 	  for (row=0; row < height; row++)
    1663. 

  1663. 	    if (FC(row,col) == 1) {
    1664. 

  1664. 	      for (sum=i=0; i < 4; i++)
    1665. 

  1665. 		sum += val[i] = bayer (row+dir[i][0], col+dir[i][1]);
    1666. 

  1666. 	      for (max=i=0; i < 4; i++) {
    1667. 

  1667. 		dev[i] = abs((val[i] << 2) - sum);
    1668. 

  1668. 		if (dev[max] < dev[i]) max = i;
    1669. 

  1669. 	      }
    1670. 

  1670. 	      BAYER(row,col) = (sum - val[max])/3.0 + 0.5;
    1671. 

  1671. 	    } else {
    1672. 

  1672. 	      for (sum=0, i=8; i < 12; i++)
    1673. 

  1673. 		sum += bayer (row+dir[i][0], col+dir[i][1]);
    1674. 

  1674. 	      BAYER(row,col) = 0.5 + sum * 0.0732233 +
    1675. 

  1675. 		(bayer(row,col-2) + bayer(row,col+2)) * 0.3535534;
    1676. 

  1676. 	    }
    1677. 

  1677. 	else if (type == 129) {			/* Bad pixel */
    1678. 

  1678. 	  if (row >= height) continue;
    1679. 

  1679. 	  j = (FC(row,col) != 1) * 4;
    1680. 

  1680. 	  for (sum=0, i=j; i < j+8; i++)
    1681. 

  1681. 	    sum += bayer (row+dir[i][0], col+dir[i][1]);
    1682. 

  1682. 	  BAYER(row,col) = (sum + 4) >> 3;
    1683. 

  1683. 	}
    1684. 

  1684.       }
    1685. 

  1685.     } else if (tag == 0x401) {			/* All-color flat fields */
    1686. 

  1686.       phase_one_flat_field (1, 2);
    1687. 

  1687.     } else if (tag == 0x416 || tag == 0x410) {
    1688. 

  1688.       phase_one_flat_field (0, 2);
    1689. 

  1689.     } else if (tag == 0x40b) {			/* Red+blue flat field */
    1690. 

  1690.       phase_one_flat_field (0, 4);
    1691. 

  1691.     } else if (tag == 0x412) {
    1692. 

  1692.       fseek (ifp, 36, SEEK_CUR);
    1693. 

  1693.       diff = abs (get2() - ph1.tag_21a);
    1694. 

  1694.       if (mindiff > diff) {
    1695. 

  1695. 	mindiff = diff;
    1696. 

  1696. 	off_412 = ftell(ifp) - 38;
    1697. 

  1697.       }
    1698. 

  1698.     }
    1699. 

  1699.     fseek (ifp, save, SEEK_SET);
    1700. 

  1700.   }
    1701. 

  1701.   if (off_412) {
    1702. 

  1702.     fseek (ifp, off_412, SEEK_SET);
    1703. 

  1703.     for (i=0; i < 9; i++) head[i] = get4() & 0x7fff;
    1704. 

  1704.     yval[0] = (float *) calloc (head[1]*head[3] + head[2]*head[4], 6);
    1705. 

  1705.     merror (yval[0], "phase_one_correct()");
    1706. 

  1706.     yval[1] = (float  *) (yval[0] + head[1]*head[3]);
    1707. 

  1707.     xval[0] = (ushort *) (yval[1] + head[2]*head[4]);
    1708. 

  1708.     xval[1] = (ushort *) (xval[0] + head[1]*head[3]);
    1709. 

  1709.     get2();
    1710. 

  1710.     for (i=0; i < 2; i++)
    1711. 

  1711.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1712. 

  1712. 	yval[i][j] = getreal(11);
    1713. 

  1713.     for (i=0; i < 2; i++)
    1714. 

  1714.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1715. 

  1715. 	xval[i][j] = get2();
    1716. 

  1716.     for (row=0; row < height; row++)
    1717. 

  1717.       for (col=0; col < width; col++) {
    1718. 

  1718. 	cfrac = (float) col * head[3] / raw_width;
    1719. 

  1719. 	cfrac -= cip = cfrac;
    1720. 

  1720. 	num = BAYER(row,col) * 0.5;
    1721. 

  1721. 	for (i=cip; i < cip+2; i++) {
    1722. 

  1722. 	  for (k=j=0; j < head[1]; j++)
    1723. 

  1723. 	    if (num < xval[0][k = head[1]*i+j]) break;
    1724. 

  1724. 	  frac = (j == 0 || j == head[1]) ? 0 :
    1725. 

  1725. 		(xval[0][k] - num) / (xval[0][k] - xval[0][k-1]);
    1726. 

  1726. 	  mult[i-cip] = yval[0][k-1] * frac + yval[0][k] * (1-frac);
    1727. 

  1727. 	}
    1728. 

  1728. 	i = ((mult[0] * (1-cfrac) + mult[1] * cfrac)
    1729. 

  1729. 		* (row + top_margin) + num) * 2;
    1730. 

  1730. 	BAYER(row,col) = LIM(i,0,65535);
    1731. 

  1731.       }
    1732. 

  1732.     free (yval[0]);
    1733. 

  1733.   }
    1734. 

  1734. }
    1735. 

  1735. 

  1736. void CLASS phase_one_load_raw()
    1737. 

  1737. {
    1738. 

  1738.   int row, col, a, b;
    1739. 

  1739.   ushort *pixel, akey, bkey, mask;
    1740. 

  1740. 

  1741.   fseek (ifp, ph1.key_off, SEEK_SET);
    1742. 

  1742.   akey = get2();
    1743. 

  1743.   bkey = get2();
    1744. 

  1744.   mask = ph1.format == 1 ? 0x5555:0x1354;
    1745. 

  1745. #ifndef LIBRAW_LIBRARY_BUILD
    1746. 

  1746.   fseek (ifp, data_offset + top_margin*raw_width*2, SEEK_SET);
    1747. 

  1747.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1748. 

  1748.   merror (pixel, "phase_one_load_raw()");
    1749. 

  1749.   for (row=0; row < height; row++) {
    1750. 

  1750.     read_shorts (pixel, raw_width);
    1751. 

  1751.     if (ph1.format)
    1752. 

  1752.       for (col=0; col < raw_width; col+=2) {
    1753. 

  1753. 	a = pixel[col+0] ^ akey;
    1754. 

  1754. 	b = pixel[col+1] ^ bkey;
    1755. 

  1755. 	pixel[col+0] = (a & mask) | (b & ~mask);
    1756. 

  1756. 	pixel[col+1] = (b & mask) | (a & ~mask);
    1757. 

  1757.       }
    1758. 

  1758.     for (col=0; col < width; col++)
    1759. 

  1759.       BAYER(row,col) = pixel[col+left_margin];
    1760. 

  1760.   }
    1761. 

  1761.   free (pixel);
    1762. 

  1762.   phase_one_correct();
    1763. 

  1763. #else
    1764. 

  1764.   fseek (ifp, data_offset, SEEK_SET);
    1765. 

  1765.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1766. 

  1766.   merror (pixel, "phase_one_load_raw()");
    1767. 

  1767.   for (row=0; row < raw_height; row++) {
    1768. 

  1768.     read_shorts (pixel, raw_width);
    1769. 

  1769.     if (ph1.format)
    1770. 

  1770.         for (col=0; col < raw_width; col+=2) {
    1771. 

  1771.             a = pixel[col+0] ^ akey;
    1772. 

  1772.             b = pixel[col+1] ^ bkey;
    1773. 

  1773.             pixel[col+0] = (a & mask) | (b & ~mask);
    1774. 

  1774.             pixel[col+1] = (b & mask) | (a & ~mask);
    1775. 

  1775.         }
    1776. 

  1776.     memmove(&raw_image[row*raw_width],pixel,raw_width*sizeof(pixel[0]));
    1777. 

  1777.   }
    1778. 

  1778.   free (pixel);
    1779. 

  1779.   // use correct on postprocessing!
    1780. 

  1780.   imgdata.rawdata.use_ph1_correct=1;
    1781. 

  1781. #endif
    1782. 

  1782. }
    1783. 

  1783. 

  1784. unsigned CLASS ph1_bithuff (int nbits, ushort *huff)
    1785. 

  1785. {
    1786. 

  1786. #ifndef LIBRAW_NOTHREADS
    1787. 

  1787. #define bitbuf tls->ph1_bits.bitbuf
    1788. 

  1788. #define vbits  tls->ph1_bits.vbits    
    1789. 

  1789. #else
    1790. 

  1790.   static UINT64 bitbuf=0;
    1791. 

  1791.   static int vbits=0;
    1792. 

  1792. #endif
    1793. 

  1793.   unsigned c;
    1794. 

  1794. 

  1795.   if (nbits == -1)
    1796. 

  1796.     return bitbuf = vbits = 0;
    1797. 

  1797.   if (nbits == 0) return 0;
    1798. 

  1798.   if (vbits < nbits) {
    1799. 

  1799.     bitbuf = bitbuf << 32 | get4();
    1800. 

  1800.     vbits += 32;
    1801. 

  1801.   }
    1802. 

  1802.   c = bitbuf << (64-vbits) >> (64-nbits);
    1803. 

  1803.   if (huff) {
    1804. 

  1804.     vbits -= huff[c] >> 8;
    1805. 

  1805.     return (uchar) huff[c];
    1806. 

  1806.   }
    1807. 

  1807.   vbits -= nbits;
    1808. 

  1808.   return c;
    1809. 

  1809. #ifndef LIBRAW_NOTHREADS
    1810. 

  1810. #undef bitbuf
    1811. 

  1811. #undef vbits
    1812. 

  1812. #endif
    1813. 

  1813. }
    1814. 

  1814. #define ph1_bits(n) ph1_bithuff(n,0)
    1815. 

  1815. #define ph1_huff(h) ph1_bithuff(*h,h+1)
    1816. 

  1816. 

  1817. void CLASS phase_one_load_raw_c()
    1818. 

  1818. {
    1819. 

  1819.   static const int length[] = { 8,7,6,9,11,10,5,12,14,13 };
    1820. 

  1820.   int *offset, len[2], pred[2], row, col, i, j;
    1821. 

  1821.   ushort *pixel;
    1822. 

  1822.   short (*t_black)[2];
    1823. 

  1823. 

  1824.   pixel = (ushort *) calloc (raw_width + raw_height*4, 2);
    1825. 

  1825.   merror (pixel, "phase_one_load_raw_c()");
    1826. 

  1826.   offset = (int *) (pixel + raw_width);
    1827. 

  1827.   fseek (ifp, strip_offset, SEEK_SET);
    1828. 

  1828.   for (row=0; row < raw_height; row++)
    1829. 

  1829.     offset[row] = get4();
    1830. 

  1830.   t_black = (short (*)[2]) offset + raw_height;
    1831. 

  1831.   fseek (ifp, ph1.black_off, SEEK_SET);
    1832. 

  1832.   if (ph1.black_off)
    1833. 

  1833.       {
    1834. 

  1834.           read_shorts ((ushort *) t_black[0], raw_height*2);
    1835. 

  1835. #ifdef LIBRAW_LIBRARY_BUILD
    1836. 

  1836.           imgdata.rawdata.ph1_black = (short (*)[2])calloc(raw_height*2,sizeof(short));
    1837. 

  1837.           merror (imgdata.rawdata.ph1_black, "phase_one_load_raw_c()");
    1838. 

  1838.           memmove(imgdata.rawdata.ph1_black,(short *) t_black[0],raw_height*2*sizeof(short));
    1839. 

  1839. #endif
    1840. 

  1840.       }
    1841. 

  1841.   for (i=0; i < 256; i++)
    1842. 

  1842.     curve[i] = i*i / 3.969 + 0.5;
    1843. 

  1843. #ifdef LIBRAW_LIBRARY_BUILD
    1844. 

  1844.   color_flags.curve_state = LIBRAW_COLORSTATE_CALCULATED;
    1845. 

  1845. #endif
    1846. 

  1846.   for (row=0; row < raw_height; row++) {
    1847. 

  1847.     fseek (ifp, data_offset + offset[row], SEEK_SET);
    1848. 

  1848.     ph1_bits(-1);
    1849. 

  1849.     pred[0] = pred[1] = 0;
    1850. 

  1850.     for (col=0; col < raw_width; col++) {
    1851. 

  1851.       if (col >= (raw_width & -8))
    1852. 

  1852. 	len[0] = len[1] = 14;
    1853. 

  1853.       else if ((col & 7) == 0)
    1854. 

  1854. 	for (i=0; i < 2; i++) {
    1855. 

  1855. 	  for (j=0; j < 5 && !ph1_bits(1); j++);
    1856. 

  1856. 	  if (j--) len[i] = length[j*2 + ph1_bits(1)];
    1857. 

  1857. 	}
    1858. 

  1858.       if ((i = len[col & 1]) == 14)
    1859. 

  1859. 	pixel[col] = pred[col & 1] = ph1_bits(16);
    1860. 

  1860.       else
    1861. 

  1861. 	pixel[col] = pred[col & 1] += ph1_bits(i) + 1 - (1 << (i - 1));
    1862. 

  1862.       if (pred[col & 1] >> 16) derror();
    1863. 

  1863.       if (ph1.format == 5 && pixel[col] < 256)
    1864. 

  1864. 	pixel[col] = curve[pixel[col]];
    1865. 

  1865.     }
    1866. 

  1866. #ifndef LIBRAW_LIBRARY_BUILD
    1867. 

  1867.     if ((unsigned) (row-top_margin) < height)
    1868. 

  1868.       for (col=0; col < width; col++) {
    1869. 

  1869. 	i = (pixel[col+left_margin] << 2)
    1870. 

  1870. 		- ph1.t_black + t_black[row][col >= ph1.split_col];
    1871. 

  1871. 	if (i > 0) BAYER(row-top_margin,col) = i;
    1872. 

  1872.       }
    1873. 

  1873. #else
    1874. 

  1874.     for (col=0; col < raw_width; col++) 
    1875. 

  1875.         {
    1876. 

  1876.             i = (pixel[col] << 2);
    1877. 

  1877.             RBAYER(row,col) = i;
    1878. 

  1878.         }
    1879. 

  1879. #endif
    1880. 

  1880.   }
    1881. 

  1881.   free (pixel);
    1882. 

  1882. #ifndef LIBRAW_LIBRARY_BUILD
    1883. 

  1883.   phase_one_correct();
    1884. 

  1884.   maximum = 0xfffc - ph1.t_black;
    1885. 

  1885. #else
    1886. 

  1886.   maximum = 0xfffc;
    1887. 

  1887.   black = ph1.t_black;
    1888. 

  1888. #endif
    1889. 

  1889. }
    1890. 

  1890. 

  1891. void CLASS hasselblad_load_raw()
    1892. 

  1892. {
    1893. 

  1893.   struct jhead jh;
    1894. 

  1894.   int row, col, pred[2], len[2], diff, c;
    1895. 

  1895. 

  1896.   if (!ljpeg_start (&jh, 0)) return;
    1897. 

  1897.   order = 0x4949;
    1898. 

  1898.   ph1_bits(-1);
    1899. 

  1899. #ifndef LIBRAW_LIBRARY_BUILD
    1900. 

  1900.   for (row=-top_margin; row < height; row++) {
    1901. 

  1901.     pred[0] = pred[1] = 0x8000 + load_flags;
    1902. 

  1902.     for (col=-left_margin; col < raw_width-left_margin; col+=2) {
    1903. 

  1903.       FORC(2) len[c] = ph1_huff(jh.huff[0]);
    1904. 

  1904.       FORC(2) {
    1905. 

  1905. 	diff = ph1_bits(len[c]);
    1906. 

  1906. 	if ((diff & (1 << (len[c]-1))) == 0)
    1907. 

  1907. 	  diff -= (1 << len[c]) - 1;
    1908. 

  1908. 	if (diff == 65535) diff = -32768;
    1909. 

  1909. 	pred[c] += diff;
    1910. 

  1910. 	if (row >= 0 && (unsigned)(col+c) < width)
    1911. 

  1911. 	  BAYER(row,col+c) = pred[c];
    1912. 

  1912.       }
    1913. 

  1913.     }
    1914. 

  1914.   }
    1915. 

  1915. #else
    1916. 

  1916.   for (row=0; row < raw_height; row++) {
    1917. 

  1917.     pred[0] = pred[1] = 0x8000 + load_flags;
    1918. 

  1918.     for (col=0; col < raw_width; col+=2) {
    1919. 

  1919.       FORC(2) len[c] = ph1_huff(jh.huff[0]);
    1920. 

  1920.       FORC(2) {
    1921. 

  1921. 	diff = ph1_bits(len[c]);
    1922. 

  1922. 	if ((diff & (1 << (len[c]-1))) == 0)
    1923. 

  1923. 	  diff -= (1 << len[c]) - 1;
    1924. 

  1924. 	if (diff == 65535) diff = -32768;
    1925. 

  1925. 	pred[c] += diff;
    1926. 

  1926.         RBAYER(row,col+c) = pred[c];
    1927. 

  1927.       }
    1928. 

  1928.     }
    1929. 

  1929.   }
    1930. 

  1930. 

  1931. #endif
    1932. 

  1932.   ljpeg_end (&jh);
    1933. 

  1933.   maximum = 0xffff;
    1934. 

  1934. }
    1935. 

  1935. 

  1936. void CLASS leaf_hdr_load_raw()
    1937. 

  1937. {
    1938. 

  1938.   ushort *pixel;
    1939. 

  1939.   unsigned tile=0, r, c, row, col;
    1940. 

  1940. 

  1941.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1942. 

  1942.   merror (pixel, "leaf_hdr_load_raw()");
    1943. 

  1943.   FORC(tiff_samples)
    1944. 

  1944.     for (r=0; r < raw_height; r++) {
    1945. 

  1945.       if (r % tile_length == 0) {
    1946. 

  1946. 	fseek (ifp, data_offset + 4*tile++, SEEK_SET);
    1947. 

  1947. 	fseek (ifp, get4() + 2*left_margin, SEEK_SET);
    1948. 

  1948.       }
    1949. 

  1949.       if (filters && c != shot_select) continue;
    1950. 

  1950.       read_shorts (pixel, raw_width);
    1951. 

  1951. #ifndef LIBRAW_LIBRARY_BUILD
    1952. 

  1952.       if ((row = r - top_margin) >= height) continue;
    1953. 

  1953.       for (col=0; col < width; col++)
    1954. 

  1954. 	if (filters)  BAYER(row,col) = pixel[col];
    1955. 

  1955. 	else image[row*width+col][c] = pixel[col];
    1956. 

  1956. #else
    1957. 

  1957.       if(filters)
    1958. 

  1958.           memmove(&raw_image[r*raw_width],pixel,raw_width*sizeof(pixel[0]));
    1959. 

  1959.       else
    1960. 

  1960.           for (col=0; col < raw_width; col++)
    1961. 

  1961.               color_image[r*raw_width+col][c] = pixel[col];
    1962. 

  1962. #endif
    1963. 

  1963.     }
    1964. 

  1964.   free (pixel);
    1965. 

  1965.   if (!filters) {
    1966. 

  1966.     maximum = 0xffff;
    1967. 

  1967.     raw_color = 1;
    1968. 

  1968.   }
    1969. 

  1969. }
    1970. 

  1970. 

  1971. void CLASS sinar_4shot_load_raw()
    1972. 

  1972. {
    1973. 

  1973.   ushort *pixel;
    1974. 

  1974.   unsigned shot, row, col, r, c;
    1975. 

  1975. 

  1976.   if ((shot = shot_select) || half_size) {
    1977. 

  1977.     if (shot) shot--;
    1978. 

  1978.     if (shot > 3) shot = 3;
    1979. 

  1979.     fseek (ifp, data_offset + shot*4, SEEK_SET);
    1980. 

  1980.     fseek (ifp, get4(), SEEK_SET);
    1981. 

  1981.     unpacked_load_raw();
    1982. 

  1982.     return;
    1983. 

  1983.   }
    1984. 

  1984.   free (image);
    1985. 

  1985.   image = (ushort (*)[4])
    1986. 

  1986. 	calloc ((iheight=height)*(iwidth=width), sizeof *image);
    1987. 

  1987.   merror (image, "sinar_4shot_load_raw()");
    1988. 

  1988.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1989. 

  1989.   merror (pixel, "sinar_4shot_load_raw()");
    1990. 

  1990.   for (shot=0; shot < 4; shot++) {
    1991. 

  1991.     fseek (ifp, data_offset + shot*4, SEEK_SET);
    1992. 

  1992.     fseek (ifp, get4(), SEEK_SET);
    1993. 

  1993. #ifndef LIBRAW_LIBRARY_BUILD
    1994. 

  1994.     for (row=0; row < raw_height; row++) {
    1995. 

  1995.       read_shorts (pixel, raw_width);
    1996. 

  1996.       if ((r = row-top_margin - (shot >> 1 & 1)) >= height) continue;
    1997. 

  1997.       for (col=0; col < raw_width; col++) {
    1998. 

  1998. 	if ((c = col-left_margin - (shot & 1)) >= width) continue;
    1999. 

  1999. 	 image[r*width+c][FC(row,col)] = pixel[col];
    2000. 

  2000.       }
    2001. 

  2001.     }
    2002. 

  2002. #else
    2003. 

  2003.     for (row=0; row < raw_height; row++) {
    2004. 

  2004.       read_shorts (pixel, raw_width);
    2005. 

  2005.       if ((r = row - (shot >> 1 & 1)) >= raw_height) continue;
    2006. 

  2006.       for (col=0; col < raw_width; col++) {
    2007. 

  2007. 	if ((c = col- (shot & 1)) >= raw_width) continue;
    2008. 

  2008.          color_image[r*width+c][FC(row,col)] = pixel[col];
    2009. 

  2009.       }
    2010. 

  2010.     }
    2011. 

  2011. #endif
    2012. 

  2012.   }
    2013. 

  2013.   free (pixel);
    2014. 

  2014.   shrink = filters = 0;
    2015. 

  2015. }
    2016. 

  2016. 

  2017. void CLASS imacon_full_load_raw()
    2018. 

  2018. {
    2019. 

  2019.   int row, col;
    2020. 

  2020. 

  2021. #ifndef LIBRAW_LIBRARY_BUILD
    2022. 

  2022.   for (row=0; row < height; row++)
    2023. 

  2023.     for (col=0; col < width; col++)
    2024. 

  2024.         {
    2025. 

  2025.             read_shorts (image[row*width+col], 3);
    2026. 

  2026.         }
    2027. 

  2027. #else
    2028. 

  2028.   for (row=0; row < height; row++)
    2029. 

  2029.     for (col=0; col < width; col++)
    2030. 

  2030.         {
    2031. 

  2031.             read_shorts (color_image[(row+top_margin)*raw_width+col+left_margin], 3);
    2032. 

  2032.         }
    2033. 

  2033. #endif
    2034. 

  2034. }
    2035. 

  2035. 

  2036. void CLASS packed_load_raw()
    2037. 

  2037. {
    2038. 

  2038.   int vbits=0, bwide, pwide, rbits, bite, half, irow, row, col, val, i;
    2039. 

  2039.   int zero=0;
    2040. 

  2040.   UINT64 bitbuf=0;
    2041. 

  2041. 

  2042.   if (raw_width * 8 >= width * tiff_bps)	/* Is raw_width in bytes? */
    2043. 

  2043.        pwide = (bwide = raw_width) * 8 / tiff_bps;
    2044. 

  2044.   else bwide = (pwide = raw_width) * tiff_bps / 8;
    2045. 

  2045.   rbits = bwide * 8 - pwide * tiff_bps;
    2046. 

  2046.   if (load_flags & 1) bwide = bwide * 16 / 15;
    2047. 

  2047.   fseek (ifp, top_margin*bwide, SEEK_CUR);
    2048. 

  2048.   bite = 8 + (load_flags & 24);
    2049. 

  2049.   half = (height+1) >> 1;
    2050. 

  2050.   for (irow=0; irow < height; irow++) 
    2051. 

  2051.   {
    2052. 

  2052.     row = irow;
    2053. 

  2053.     if (load_flags & 2 &&
    2054. 

  2054. 	(row = irow % half * 2 + irow / half) == 1 &&
    2055. 

  2055. 	load_flags & 4) {
    2056. 

  2056.       if (vbits=0, tiff_compress)
    2057. 

  2057. 	fseek (ifp, data_offset - (-half*bwide & -2048), SEEK_SET);
    2058. 

  2058.       else {
    2059. 

  2059. 	fseek (ifp, 0, SEEK_END);
    2060. 

  2060. 	fseek (ifp, ftell(ifp) >> 3 << 2, SEEK_SET);
    2061. 

  2061.       }
    2062. 

  2062.     }
    2063. 

  2063.     for (col=0; col < pwide; col++) {
    2064. 

  2064.       for (vbits -= tiff_bps; vbits < 0; vbits += bite) {
    2065. 

  2065. 	bitbuf <<= bite;
    2066. 

  2066. 	for (i=0; i < bite; i+=8)
    2067. 

  2067. 	  bitbuf |= (unsigned) (fgetc(ifp) << i);
    2068. 

  2068.       }
    2069. 

  2069.       val = bitbuf << (64-tiff_bps-vbits) >> (64-tiff_bps);
    2070. 

  2070.       i = (col ^ (load_flags >> 6)) - left_margin;
    2071. 

  2071. #ifdef LIBRAW_LIBRARY_BUILD
    2072. 

  2072.       RBAYER(row+top_margin,i+left_margin) = val;
    2073. 

  2073.       if (((unsigned)i>=width) && (load_flags & 32) ) {
    2074. 

  2074. 	black += val;
    2075. 

  2075. 	zero += !val;
    2076. 

  2076.       }
    2077. 

  2077. #else
    2078. 

  2078.       if ((unsigned) i < width)
    2079. 

  2079. 	BAYER(row,i+left_margin) = val;
    2080. 

  2080.       else if (load_flags & 32) {
    2081. 

  2081. 	black += val;
    2082. 

  2082. 	zero += !val;
    2083. 

  2083.       }
    2084. 

  2084. #endif
    2085. 

  2085.       if (load_flags & 1 && (col % 10) == 9 &&
    2086. 

  2086. 	fgetc(ifp) && col < width+left_margin) derror();
    2087. 

  2087.     }
    2088. 

  2088.     vbits -= rbits;
    2089. 

  2089.   }
    2090. 

  2090.   if (load_flags & 32 && pwide > width)
    2091. 

  2091.     black /= (pwide - width) * height;
    2092. 

  2092.   if (zero*4 > (pwide - width) * height)
    2093. 

  2093.     black = 0;
    2094. 

  2094. }
    2095. 

  2095. 

  2096. void CLASS unpacked_load_raw()
    2097. 

  2097. {
    2098. 

  2098.   ushort *pixel;
    2099. 

  2099.   int row, col, bits=0;
    2100. 

  2100. 

  2101.   while (1 << ++bits < maximum);
    2102. 

  2102. #ifndef LIBRAW_LIBRARY_BUILD
    2103. 

  2103.   fseek (ifp, (top_margin*raw_width + left_margin) * 2, SEEK_CUR);
    2104. 

  2104.   pixel = (ushort *) calloc (width, sizeof *pixel);
    2105. 

  2105.   merror (pixel, "unpacked_load_raw()");
    2106. 

  2106.   for (row=0; row < height; row++) {
    2107. 

  2107.     read_shorts (pixel, width);
    2108. 

  2108.     fseek (ifp, 2*(raw_width - width), SEEK_CUR);
    2109. 

  2109.     for (col=0; col < width; col++)
    2110. 

  2110.       if ((BAYER2(row,col) = pixel[col] >> load_flags) >> bits) derror();
    2111. 

  2111.   }
    2112. 

  2112.   free (pixel);
    2113. 

  2113. #else
    2114. 

  2114.   // fseek (ifp, (top_margin*raw_width + left_margin) * 2, SEEK_CUR);
    2115. 

  2115.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    2116. 

  2116.   merror (pixel, "unpacked_load_raw()");
    2117. 

  2117.   for (row=0; row < raw_height; row++) {
    2118. 

  2118.     read_shorts (pixel, raw_width);
    2119. 

  2119.     for (col=0; col < raw_width; col++)
    2120. 

  2120.         {
    2121. 

  2121.             RBAYER(row,col) = pixel[col]>>load_flags;
    2122. 

  2122.             if( ((unsigned)(row-top_margin) < height)
    2123. 

  2123.                 && ((unsigned)(col-left_margin)<width ))
    2124. 

  2124.                 if(RBAYER(row,col)>>bits)
    2125. 

  2125.                     derror();
    2126. 

  2126.         }
    2127. 

  2127.   }
    2128. 

  2128.   free (pixel);
    2129. 

  2129. #endif
    2130. 

  2130. }
    2131. 

  2131. 

  2132. void CLASS nokia_load_raw()
    2133. 

  2133. {
    2134. 

  2134.   uchar  *data,  *dp;
    2135. 

  2135.   ushort *pixel, *pix;
    2136. 

  2136.   int rev, dwide, row, c;
    2137. 

  2137. 

  2138.   rev = 3 * (order == 0x4949);
    2139. 

  2139.   dwide = raw_width * 5 / 4;
    2140. 

  2140.   data = (uchar *) malloc (dwide + raw_width*2);
    2141. 

  2141.   merror (data, "nokia_load_raw()");
    2142. 

  2142.   pixel = (ushort *) (data + dwide);
    2143. 

  2143.   for (row=0; row < raw_height; row++) {
    2144. 

  2144.     if (fread (data+dwide, 1, dwide, ifp) < dwide) derror();
    2145. 

  2145.     FORC(dwide) data[c] = data[dwide+(c ^ rev)];
    2146. 

  2146.     for (dp=data, pix=pixel; pix < pixel+raw_width; dp+=5, pix+=4)
    2147. 

  2147.       FORC4 pix[c] = (dp[c] << 2) | (dp[4] >> (c << 1) & 3);
    2148. 

  2148.     if (row < top_margin)
    2149. 

  2149.       FORC(width) black += pixel[c];
    2150. 

  2150. #ifndef LIBRAW_LIBRARY_BUILD
    2151. 

  2151.     else
    2152. 

  2152.       FORC(width) BAYER(row-top_margin,c) = pixel[c];
    2153. 

  2153. #else
    2154. 

  2154.     memmove(&raw_image[row*raw_width],pixel,width*sizeof(pixel[0]));
    2155. 

  2155. #endif
    2156. 

  2156.   }
    2157. 

  2157.   free (data);
    2158. 

  2158.   if (top_margin) black /= top_margin * width;
    2159. 

  2159.   maximum = 0x3ff;
    2160. 

  2160. }
    2161. 

  2161. 

  2162. unsigned CLASS pana_bits (int nbits)
    2163. 

  2163. {
    2164. 

  2164. #ifndef LIBRAW_NOTHREADS
    2165. 

  2165. #define buf tls->pana_bits.buf
    2166. 

  2166. #define vbits tls->pana_bits.vbits   
    2167. 

  2167. #else
    2168. 

  2168.   static uchar buf[0x4000];
    2169. 

  2169.   static int vbits;
    2170. 

  2170. #endif
    2171. 

  2171.   int byte;
    2172. 

  2172. 

  2173.   if (!nbits) return vbits=0;
    2174. 

  2174.   if (!vbits) {
    2175. 

  2175.     fread (buf+load_flags, 1, 0x4000-load_flags, ifp);
    2176. 

  2176.     fread (buf, 1, load_flags, ifp);
    2177. 

  2177.   }
    2178. 

  2178.   vbits = (vbits - nbits) & 0x1ffff;
    2179. 

  2179.   byte = vbits >> 3 ^ 0x3ff0;
    2180. 

  2180.   return (buf[byte] | buf[byte+1] << 8) >> (vbits & 7) & ~(-1 << nbits);
    2181. 

  2181. #ifndef LIBRAW_NOTHREADS
    2182. 

  2182. #undef buf
    2183. 

  2183. #undef vbits
    2184. 

  2184. #endif
    2185. 

  2185. }
    2186. 

  2186. 

  2187. void CLASS panasonic_load_raw()
    2188. 

  2188. {
    2189. 

  2189.   int row, col, i, j, sh=0, pred[2], nonz[2];
    2190. 

  2190. 

  2191.   pana_bits(0);
    2192. 

  2192.   for (row=0; row < height; row++)
    2193. 

  2193.     for (col=0; col < raw_width; col++) {
    2194. 

  2194.       if ((i = col % 14) == 0)
    2195. 

  2195. 	pred[0] = pred[1] = nonz[0] = nonz[1] = 0;
    2196. 

  2196.       if (i % 3 == 2) sh = 4 >> (3 - pana_bits(2));
    2197. 

  2197.       if (nonz[i & 1]) {
    2198. 

  2198. 	if ((j = pana_bits(8))) {
    2199. 

  2199. 	  if ((pred[i & 1] -= 0x80 << sh) < 0 || sh == 4)
    2200. 

  2200. 	       pred[i & 1] &= ~(-1 << sh);
    2201. 

  2201. 	  pred[i & 1] += j << sh;
    2202. 

  2202. 	}
    2203. 

  2203.       } else if ((nonz[i & 1] = pana_bits(8)) || i > 11)
    2204. 

  2204. 	pred[i & 1] = nonz[i & 1] << 4 | pana_bits(4);
    2205. 

  2205. #ifndef LIBRAW_LIBRARY_BUILD
    2206. 

  2206.       if (col < width)
    2207. 

  2207.               if ((BAYER(row,col) = pred[col & 1]) > 4098) derror();
    2208. 

  2208. #else
    2209. 

  2209.       RBAYER(row,col) = pred[col & 1];
    2210. 

  2210.       if (col < width)
    2211. 

  2211.           if (RBAYER(row,col) > 4098) derror();
    2212. 

  2212. #endif
    2213. 

  2213.     }
    2214. 

  2214. }
    2215. 

  2215. 

  2216. 

  2217. void CLASS olympus_load_raw()
    2218. 

  2218. {
    2219. 

  2219.   ushort huff[4096];
    2220. 

  2220.   int row, col, nbits, sign, low, high, i, c, w, n, nw;
    2221. 

  2221.   int acarry[2][3], *carry, pred, diff;
    2222. 

  2222. 

  2223.   huff[n=0] = 0xc0c;
    2224. 

  2224.   for (i=12; i--; )
    2225. 

  2225.     FORC(2048 >> i) huff[++n] = (i+1) << 8 | i;
    2226. 

  2226.   fseek (ifp, 7, SEEK_CUR);
    2227. 

  2227. #ifdef LIBRAW_LIBRARY_BUILD
    2228. 

  2228.   if(!data_size)
    2229. 

  2229.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    2230. 

  2230.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    2231. 

  2231.   LibRaw_bit_buffer bits;
    2232. 

  2232.   bits.reset();
    2233. 

  2233. #else
    2234. 

  2234.   getbits(-1);
    2235. 

  2235. #endif
    2236. 

  2236.   for (row=0; row < height; row++) {
    2237. 

  2237.     memset (acarry, 0, sizeof acarry);
    2238. 

  2238.     for (col=0; col < raw_width; col++) {
    2239. 

  2239.       carry = acarry[col & 1];
    2240. 

  2240.       i = 2 * (carry[2] < 3);
    2241. 

  2241.       for (nbits=2+i; (ushort) carry[0] >> (nbits+i); nbits++);
    2242. 

  2242. #ifdef LIBRAW_LIBRARY_BUILD
    2243. 

  2243.       low = (sign = bits._getbits(buf,3,zero_after_ff)) & 3;
    2244. 

  2244.       sign = sign << 29 >> 31;
    2245. 

  2245.       if ((high = bits._gethuff(buf,12,huff,zero_after_ff)) == 12)
    2246. 

  2246.           high = bits._getbits(buf,16-nbits,zero_after_ff) >> 1;
    2247. 

  2247.       carry[0] = (high << nbits) | bits._getbits(buf,nbits,zero_after_ff);
    2248. 

  2248. #else
    2249. 

  2249.       low = (sign = getbits(3)) & 3;
    2250. 

  2250.       sign = sign << 29 >> 31;
    2251. 

  2251.       if ((high = getbithuff(12,huff)) == 12)
    2252. 

  2252. 	high = getbits(16-nbits) >> 1;
    2253. 

  2253.       carry[0] = (high << nbits) | getbits(nbits);
    2254. 

  2254. #endif
    2255. 

  2255.       diff = (carry[0] ^ sign) + carry[1];
    2256. 

  2256.       carry[1] = (diff*3 + carry[1]) >> 5;
    2257. 

  2257.       carry[2] = carry[0] > 16 ? 0 : carry[2]+1;
    2258. 

  2258.       if (col >= width) continue;
    2259. 

  2259.       if (row < 2 && col < 2) pred = 0;
    2260. 

  2260.       else if (row < 2) pred = RBAYER(row,col-2);
    2261. 

  2261.       else if (col < 2) pred = RBAYER(row-2,col);
    2262. 

  2262.       else {
    2263. 

  2263. 	w  = RBAYER(row,col-2);
    2264. 

  2264. 	n  = RBAYER(row-2,col);
    2265. 

  2265. 	nw = RBAYER(row-2,col-2);
    2266. 

  2266. 	if ((w < nw && nw < n) || (n < nw && nw < w)) {
    2267. 

  2267. 	  if (ABS(w-nw) > 32 || ABS(n-nw) > 32)
    2268. 

  2268. 	    pred = w + n - nw;
    2269. 

  2269. 	  else pred = (w + n) >> 1;
    2270. 

  2270. 	} else pred = ABS(w-nw) > ABS(n-nw) ? w : n;
    2271. 

  2271.       }
    2272. 

  2272.       if ((RBAYER(row,col) = pred + ((diff << 2) | low)) >> 12) derror();
    2273. 

  2273.     }
    2274. 

  2274.   }
    2275. 

  2275. #ifdef LIBRAW_LIBRARY_BUILD
    2276. 

  2276.   delete buf;
    2277. 

  2277. #endif
    2278. 

  2278. }
    2279. 

  2279. 

  2280. 

  2281. void CLASS minolta_rd175_load_raw()
    2282. 

  2282. {
    2283. 

  2283.   uchar pixel[768];
    2284. 

  2284.   unsigned irow, box, row, col;
    2285. 

  2285. 

  2286.   for (irow=0; irow < 1481; irow++) {
    2287. 

  2287.     if (fread (pixel, 1, 768, ifp) < 768) derror();
    2288. 

  2288.     box = irow / 82;
    2289. 

  2289.     row = irow % 82 * 12 + ((box < 12) ? box | 1 : (box-12)*2);
    2290. 

  2290.     switch (irow) {
    2291. 

  2291.       case 1477: case 1479: continue;
    2292. 

  2292.       case 1476: row = 984; break;
    2293. 

  2293.       case 1480: row = 985; break;
    2294. 

  2294.       case 1478: row = 985; box = 1;
    2295. 

  2295.     }
    2296. 

  2296.     if ((box < 12) && (box & 1)) {
    2297. 

  2297.       for (col=0; col < 1533; col++, row ^= 1)
    2298. 

  2298. 	if (col != 1) RRBAYER(row,col) = (col+1) & 2 ?
    2299. 

  2299. 		   pixel[col/2-1] + pixel[col/2+1] : pixel[col/2] << 1;
    2300. 

  2300.       RRBAYER(row,1)    = pixel[1]   << 1;
    2301. 

  2301.       RRBAYER(row,1533) = pixel[765] << 1;
    2302. 

  2302.     } else
    2303. 

  2303.       for (col=row & 1; col < 1534; col+=2)
    2304. 

  2304.           RRBAYER(row,col) = pixel[col/2] << 1;
    2305. 

  2305.   }
    2306. 

  2306.   maximum = 0xff << 1;
    2307. 

  2307. }
    2308. 

  2308. 

  2309. void CLASS quicktake_100_load_raw()
    2310. 

  2310. {
    2311. 

  2311.   uchar pixel[484][644];
    2312. 

  2312.   static const short gstep[16] =
    2313. 

  2313.   { -89,-60,-44,-32,-22,-15,-8,-2,2,8,15,22,32,44,60,89 };
    2314. 

  2314.   static const short rstep[6][4] =
    2315. 

  2315.   { {  -3,-1,1,3  }, {  -5,-1,1,5  }, {  -8,-2,2,8  },
    2316. 

  2316.     { -13,-3,3,13 }, { -19,-4,4,19 }, { -28,-6,6,28 } };
    2317. 

  2317.   static const short t_curve[256] =
    2318. 

  2318.   { 0,1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
    2319. 

  2319.     28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,
    2320. 

  2320.     54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,74,75,76,77,78,
    2321. 

  2321.     79,80,81,82,83,84,86,88,90,92,94,97,99,101,103,105,107,110,112,114,116,
    2322. 

  2322.     118,120,123,125,127,129,131,134,136,138,140,142,144,147,149,151,153,155,
    2323. 

  2323.     158,160,162,164,166,168,171,173,175,177,179,181,184,186,188,190,192,195,
    2324. 

  2324.     197,199,201,203,205,208,210,212,214,216,218,221,223,226,230,235,239,244,
    2325. 

  2325.     248,252,257,261,265,270,274,278,283,287,291,296,300,305,309,313,318,322,
    2326. 

  2326.     326,331,335,339,344,348,352,357,361,365,370,374,379,383,387,392,396,400,
    2327. 

  2327.     405,409,413,418,422,426,431,435,440,444,448,453,457,461,466,470,474,479,
    2328. 

  2328.     483,487,492,496,500,508,519,531,542,553,564,575,587,598,609,620,631,643,
    2329. 

  2329.     654,665,676,687,698,710,721,732,743,754,766,777,788,799,810,822,833,844,
    2330. 

  2330.     855,866,878,889,900,911,922,933,945,956,967,978,989,1001,1012,1023 };
    2331. 

  2331.   int rb, row, col, sharp, val=0;
    2332. 

  2332. 

  2333.   getbits(-1);
    2334. 

  2334.   memset (pixel, 0x80, sizeof pixel);
    2335. 

  2335.   for (row=2; row < height+2; row++) {
    2336. 

  2336.     for (col=2+(row & 1); col < width+2; col+=2) {
    2337. 

  2337.       val = ((pixel[row-1][col-1] + 2*pixel[row-1][col+1] +
    2338. 

  2338. 		pixel[row][col-2]) >> 2) + gstep[getbits(4)];
    2339. 

  2339.       pixel[row][col] = val = LIM(val,0,255);
    2340. 

  2340.       if (col < 4)
    2341. 

  2341. 	pixel[row][col-2] = pixel[row+1][~row & 1] = val;
    2342. 

  2342.       if (row == 2)
    2343. 

  2343. 	pixel[row-1][col+1] = pixel[row-1][col+3] = val;
    2344. 

  2344.     }
    2345. 

  2345.     pixel[row][col] = val;
    2346. 

  2346.   }
    2347. 

  2347.   for (rb=0; rb < 2; rb++)
    2348. 

  2348.     for (row=2+rb; row < height+2; row+=2)
    2349. 

  2349.       for (col=3-(row & 1); col < width+2; col+=2) {
    2350. 

  2350. 	if (row < 4 || col < 4) sharp = 2;
    2351. 

  2351. 	else {
    2352. 

  2352. 	  val = ABS(pixel[row-2][col] - pixel[row][col-2])
    2353. 

  2353. 	      + ABS(pixel[row-2][col] - pixel[row-2][col-2])
    2354. 

  2354. 	      + ABS(pixel[row][col-2] - pixel[row-2][col-2]);
    2355. 

  2355. 	  sharp = val <  4 ? 0 : val <  8 ? 1 : val < 16 ? 2 :
    2356. 

  2356. 		  val < 32 ? 3 : val < 48 ? 4 : 5;
    2357. 

  2357. 	}
    2358. 

  2358. 	val = ((pixel[row-2][col] + pixel[row][col-2]) >> 1)
    2359. 

  2359. 	      + rstep[sharp][getbits(2)];
    2360. 

  2360. 	pixel[row][col] = val = LIM(val,0,255);
    2361. 

  2361. 	if (row < 4) pixel[row-2][col+2] = val;
    2362. 

  2362. 	if (col < 4) pixel[row+2][col-2] = val;
    2363. 

  2363.       }
    2364. 

  2364.   for (row=2; row < height+2; row++)
    2365. 

  2365.     for (col=3-(row & 1); col < width+2; col+=2) {
    2366. 

  2366.       val = ((pixel[row][col-1] + (pixel[row][col] << 2) +
    2367. 

  2367. 	      pixel[row][col+1]) >> 1) - 0x100;
    2368. 

  2368.       pixel[row][col] = LIM(val,0,255);
    2369. 

  2369.     }
    2370. 

  2370.   for (row=0; row < height; row++)
    2371. 

  2371.     for (col=0; col < width; col++)
    2372. 

  2372.             RBAYER(row,col) = t_curve[pixel[row+2][col+2]];
    2373. 

  2373.   maximum = 0x3ff;
    2374. 

  2374. }
    2375. 

  2375. 

  2376. #define radc_token(tree) ((signed char) getbithuff(8,huff[tree]))
    2377. 

  2377. 

  2378. #define FORYX for (y=1; y < 3; y++) for (x=col+1; x >= col; x--)
    2379. 

  2379. 

  2380. #define PREDICTOR (c ? (buf[c][y-1][x] + buf[c][y][x+1]) / 2 \
    2381. 

  2381. : (buf[c][y-1][x+1] + 2*buf[c][y-1][x] + buf[c][y][x+1]) / 4)
    2382. 

  2382. 

  2383. void CLASS kodak_radc_load_raw()
    2384. 

  2384. {
    2385. 

  2385.   static const char src[] = {
    2386. 

  2386.     1,1, 2,3, 3,4, 4,2, 5,7, 6,5, 7,6, 7,8,
    2387. 

  2387.     1,0, 2,1, 3,3, 4,4, 5,2, 6,7, 7,6, 8,5, 8,8,
    2388. 

  2388.     2,1, 2,3, 3,0, 3,2, 3,4, 4,6, 5,5, 6,7, 6,8,
    2389. 

  2389.     2,0, 2,1, 2,3, 3,2, 4,4, 5,6, 6,7, 7,5, 7,8,
    2390. 

  2390.     2,1, 2,4, 3,0, 3,2, 3,3, 4,7, 5,5, 6,6, 6,8,
    2391. 

  2391.     2,3, 3,1, 3,2, 3,4, 3,5, 3,6, 4,7, 5,0, 5,8,
    2392. 

  2392.     2,3, 2,6, 3,0, 3,1, 4,4, 4,5, 4,7, 5,2, 5,8,
    2393. 

  2393.     2,4, 2,7, 3,3, 3,6, 4,1, 4,2, 4,5, 5,0, 5,8,
    2394. 

  2394.     2,6, 3,1, 3,3, 3,5, 3,7, 3,8, 4,0, 5,2, 5,4,
    2395. 

  2395.     2,0, 2,1, 3,2, 3,3, 4,4, 4,5, 5,6, 5,7, 4,8,
    2396. 

  2396.     1,0, 2,2, 2,-2,
    2397. 

  2397.     1,-3, 1,3,
    2398. 

  2398.     2,-17, 2,-5, 2,5, 2,17,
    2399. 

  2399.     2,-7, 2,2, 2,9, 2,18,
    2400. 

  2400.     2,-18, 2,-9, 2,-2, 2,7,
    2401. 

  2401.     2,-28, 2,28, 3,-49, 3,-9, 3,9, 4,49, 5,-79, 5,79,
    2402. 

  2402.     2,-1, 2,13, 2,26, 3,39, 4,-16, 5,55, 6,-37, 6,76,
    2403. 

  2403.     2,-26, 2,-13, 2,1, 3,-39, 4,16, 5,-55, 6,-76, 6,37
    2404. 

  2404.   };
    2405. 

  2405.   ushort huff[19][256];
    2406. 

  2406.   int row, col, tree, nreps, rep, step, i, c, s, r, x, y, val;
    2407. 

  2407.   short last[3] = { 16,16,16 }, mul[3], buf[3][3][386];
    2408. 

  2408.   static const ushort pt[] =
    2409. 

  2409.     { 0,0, 1280,1344, 2320,3616, 3328,8000, 4095,16383, 65535,16383 };
    2410. 

  2410. 

  2411.   for (i=2; i < 12; i+=2)
    2412. 

  2412.     for (c=pt[i-2]; c <= pt[i]; c++)
    2413. 

  2413.       curve[c] = (float)
    2414. 

  2414. 	(c-pt[i-2]) / (pt[i]-pt[i-2]) * (pt[i+1]-pt[i-1]) + pt[i-1] + 0.5;
    2415. 

  2415.   for (s=i=0; i < sizeof src; i+=2)
    2416. 

  2416.     FORC(256 >> src[i])
    2417. 

  2417.       huff[0][s++] = src[i] << 8 | (uchar) src[i+1];
    2418. 

  2418.   s = kodak_cbpp == 243 ? 2 : 3;
    2419. 

  2419.   FORC(256) huff[18][c] = (8-s) << 8 | c >> s << s | 1 << (s-1);
    2420. 

  2420.   getbits(-1);
    2421. 

  2421.   for (i=0; i < sizeof(buf)/sizeof(short); i++)
    2422. 

  2422.     buf[0][0][i] = 2048;
    2423. 

  2423.   for (row=0; row < height; row+=4) {
    2424. 

  2424.     FORC3 mul[c] = getbits(6);
    2425. 

  2425.     FORC3 {
    2426. 

  2426.       val = ((0x1000000/last[c] + 0x7ff) >> 12) * mul[c];
    2427. 

  2427.       s = val > 65564 ? 10:12;
    2428. 

  2428.       x = ~(-1 << (s-1));
    2429. 

  2429.       val <<= 12-s;
    2430. 

  2430.       for (i=0; i < sizeof(buf[0])/sizeof(short); i++)
    2431. 

  2431. 	buf[c][0][i] = (buf[c][0][i] * val + x) >> s;
    2432. 

  2432.       last[c] = mul[c];
    2433. 

  2433.       for (r=0; r <= !c; r++) {
    2434. 

  2434. 	buf[c][1][width/2] = buf[c][2][width/2] = mul[c] << 7;
    2435. 

  2435. 	for (tree=1, col=width/2; col > 0; ) {
    2436. 

  2436. 	  if ((tree = radc_token(tree))) {
    2437. 

  2437. 	    col -= 2;
    2438. 

  2438. 	    if (tree == 8)
    2439. 

  2439. 	      FORYX buf[c][y][x] = (uchar) radc_token(18) * mul[c];
    2440. 

  2440. 	    else
    2441. 

  2441. 	      FORYX buf[c][y][x] = radc_token(tree+10) * 16 + PREDICTOR;
    2442. 

  2442. 	  } else
    2443. 

  2443. 	    do {
    2444. 

  2444. 	      nreps = (col > 2) ? radc_token(9) + 1 : 1;
    2445. 

  2445. 	      for (rep=0; rep < 8 && rep < nreps && col > 0; rep++) {
    2446. 

  2446. 		col -= 2;
    2447. 

  2447. 		FORYX buf[c][y][x] = PREDICTOR;
    2448. 

  2448. 		if (rep & 1) {
    2449. 

  2449. 		  step = radc_token(10) << 4;
    2450. 

  2450. 		  FORYX buf[c][y][x] += step;
    2451. 

  2451. 		}
    2452. 

  2452. 	      }
    2453. 

  2453. 	    } while (nreps == 9);
    2454. 

  2454. 	}
    2455. 

  2455. 	for (y=0; y < 2; y++)
    2456. 

  2456. 	  for (x=0; x < width/2; x++) {
    2457. 

  2457. 	    val = (buf[c][y+1][x] << 4) / mul[c];
    2458. 

  2458. 	    if (val < 0) val = 0;
    2459. 

  2459. 	    if (c) CBAYER(row+y*2+c-1,x*2+2-c) = val;
    2460. 

  2460. 	    else   CBAYER(row+r*2+y,x*2+y) = val;
    2461. 

  2461. 	  }
    2462. 

  2462. 	memcpy (buf[c][0]+!c, buf[c][2], sizeof buf[c][0]-2*!c);
    2463. 

  2463.       }
    2464. 

  2464.     }
    2465. 

  2465.     for (y=row; y < row+4; y++)
    2466. 

  2466.       for (x=0; x < width; x++)
    2467. 

  2467. 	if ((x+y) & 1) {
    2468. 

  2468. 	  r = x ? x-1 : x+1;
    2469. 

  2469. 	  s = x+1 < width ? x+1 : x-1;
    2470. 

  2470. 	  val = (CBAYER(y,x)-2048)*2 + (CBAYER(y,r)+CBAYER(y,s))/2;
    2471. 

  2471. 	  if (val < 0) val = 0;
    2472. 

  2472. 	  CBAYER(y,x) = val;
    2473. 

  2473. 	}
    2474. 

  2474.   }
    2475. 

  2475. #ifndef LIBRAW_LIBRARY_BUILD
    2476. 

  2476.   for (i=0; i < iheight*iwidth*4; i++)
    2477. 

  2477.     image[0][i] = curve[image[0][i]];
    2478. 

  2478. #else
    2479. 

  2479.   for (i=0; i < height*width*4; i++)
    2480. 

  2480.     color_image[0][i] = curve[color_image[0][i]];
    2481. 

  2481. #endif
    2482. 

  2482.   maximum = 0x3fff;
    2483. 

  2483. }
    2484. 

  2484. 

  2485. #undef FORYX
    2486. 

  2486. #undef PREDICTOR
    2487. 

  2487. 

  2488. #ifdef NO_JPEG
    2489. 

  2489. void CLASS kodak_jpeg_load_raw() {}
    2490. 

  2490. #else
    2491. 

  2491. 

  2492. METHODDEF(boolean)
    2493. 

  2493. fill_input_buffer (j_decompress_ptr cinfo)
    2494. 

  2494. {
    2495. 

  2495. #ifndef LIBRAW_NOTHREADS
    2496. 

  2496. #define jpeg_buffer tls->jpeg_buffer
    2497. 

  2497. #else
    2498. 

  2498.   static uchar jpeg_buffer[4096];
    2499. 

  2499. #endif
    2500. 

  2500.   size_t nbytes;
    2501. 

  2501. 

  2502.   nbytes = fread (jpeg_buffer, 1, 4096, ifp);
    2503. 

  2503.   swab (jpeg_buffer, jpeg_buffer, nbytes);
    2504. 

  2504.   cinfo->src->next_input_byte = jpeg_buffer;
    2505. 

  2505.   cinfo->src->bytes_in_buffer = nbytes;
    2506. 

  2506.   return TRUE;
    2507. 

  2507. #ifndef LIBRAW_NOTHREADS
    2508. 

  2508. #undef jpeg_buffer
    2509. 

  2509. #endif
    2510. 

  2510. }
    2511. 

  2511. 

  2512. void CLASS kodak_jpeg_load_raw()
    2513. 

  2513. {
    2514. 

  2514.   struct jpeg_decompress_struct cinfo;
    2515. 

  2515.   struct jpeg_error_mgr jerr;
    2516. 

  2516.   JSAMPARRAY buf;
    2517. 

  2517.   JSAMPLE (*pixel)[3];
    2518. 

  2518.   int row, col;
    2519. 

  2519. 

  2520.   cinfo.err = jpeg_std_error (&jerr);
    2521. 

  2521.   jpeg_create_decompress (&cinfo);
    2522. 

  2522.   jpeg_stdio_src (&cinfo, ifp);
    2523. 

  2523.   cinfo.src->fill_input_buffer = fill_input_buffer;
    2524. 

  2524.   jpeg_read_header (&cinfo, TRUE);
    2525. 

  2525.   jpeg_start_decompress (&cinfo);
    2526. 

  2526.   if ((cinfo.output_width      != width  ) ||
    2527. 

  2527.       (cinfo.output_height*2   != height ) ||
    2528. 

  2528.       (cinfo.output_components != 3      )) {
    2529. 

  2529. #ifdef DCRAW_VERBOSE
    2530. 

  2530.     fprintf (stderr,_("%s: incorrect JPEG dimensions\n"), ifname);
    2531. 

  2531. #endif
    2532. 

  2532.     jpeg_destroy_decompress (&cinfo);
    2533. 

  2533. #ifdef LIBRAW_LIBRARY_BUILD
    2534. 

  2534.     throw LIBRAW_EXCEPTION_DECODE_JPEG;
    2535. 

  2535. #else
    2536. 

  2536.     longjmp (failure, 3);
    2537. 

  2537. #endif
    2538. 

  2538.   }
    2539. 

  2539.   buf = (*cinfo.mem->alloc_sarray)
    2540. 

  2540. 		((j_common_ptr) &cinfo, JPOOL_IMAGE, width*3, 1);
    2541. 

  2541. 

  2542.   while (cinfo.output_scanline < cinfo.output_height) {
    2543. 

  2543.     row = cinfo.output_scanline * 2;
    2544. 

  2544.     jpeg_read_scanlines (&cinfo, buf, 1);
    2545. 

  2545.     pixel = (JSAMPLE (*)[3]) buf[0];
    2546. 

  2546.     for (col=0; col < width; col+=2) {
    2547. 

  2547.       RBAYER(row+0,col+0) = pixel[col+0][1] << 1;
    2548. 

  2548.       RBAYER(row+1,col+1) = pixel[col+1][1] << 1;
    2549. 

  2549.       RBAYER(row+0,col+1) = pixel[col][0] + pixel[col+1][0];
    2550. 

  2550.       RBAYER(row+1,col+0) = pixel[col][2] + pixel[col+1][2];
    2551. 

  2551.     }
    2552. 

  2552.   }
    2553. 

  2553.   jpeg_finish_decompress (&cinfo);
    2554. 

  2554.   jpeg_destroy_decompress (&cinfo);
    2555. 

  2555.   maximum = 0xff << 1;
    2556. 

  2556. }
    2557. 

  2557. #endif
    2558. 

  2558. 

  2559. void CLASS kodak_dc120_load_raw()
    2560. 

  2560. {
    2561. 

  2561.   static const int mul[4] = { 162, 192, 187,  92 };
    2562. 

  2562.   static const int add[4] = {   0, 636, 424, 212 };
    2563. 

  2563.   uchar pixel[848];
    2564. 

  2564.   int row, shift, col;
    2565. 

  2565. 

  2566.   for (row=0; row < height; row++) {
    2567. 

  2567.     if (fread (pixel, 1, 848, ifp) < 848) derror();
    2568. 

  2568.     shift = row * mul[row & 3] + add[row & 3];
    2569. 

  2569.     for (col=0; col < width; col++)
    2570. 

  2570.       RBAYER(row,col) = (ushort) pixel[(col + shift) % 848];
    2571. 

  2571.   }
    2572. 

  2572.   maximum = 0xff;
    2573. 

  2573. }
    2574. 

  2574. 

  2575. void CLASS eight_bit_load_raw()
    2576. 

  2576. {
    2577. 

  2577.   uchar *pixel;
    2578. 

  2578.   unsigned row, col, val, lblack=0;
    2579. 

  2579. 

  2580.   pixel = (uchar *) calloc (raw_width, sizeof *pixel);
    2581. 

  2581.   merror (pixel, "eight_bit_load_raw()");
    2582. 

  2582. #ifndef LIBRAW_LIBRARY_BUILD
    2583. 

  2583.   fseek (ifp, top_margin*raw_width, SEEK_CUR);
    2584. 

  2584.   for (row=0; row < height; row++) {
    2585. 

  2585.     if (fread (pixel, 1, raw_width, ifp) < raw_width) derror();
    2586. 

  2586.     for (col=0; col < raw_width; col++) {
    2587. 

  2587.       val = curve[pixel[col]];
    2588. 

  2588.       if ((unsigned) (col-left_margin) < width)
    2589. 

  2589. 	BAYER(row,col-left_margin) = val;
    2590. 

  2590.       else lblack += val;
    2591. 

  2591.     }
    2592. 

  2592.   }
    2593. 

  2593. #else
    2594. 

  2594.   for (row=0; row < raw_height; row++) {
    2595. 

  2595.     if (fread (pixel, 1, raw_width, ifp) < raw_width) derror();
    2596. 

  2596.     for (col=0; col < raw_width; col++) {
    2597. 

  2597.             val = curve[pixel[col]];
    2598. 

  2598.         RBAYER(row,col) = val;
    2599. 

  2599.         if((unsigned) (row-top_margin)< height)
    2600. 

  2600.             if ((unsigned) (col-left_margin) >= width)
    2601. 

  2601.                 lblack+=val;
    2602. 

  2602.     }
    2603. 

  2603.   }
    2604. 

  2604. #endif
    2605. 

  2605. 

  2606.   free (pixel);
    2607. 

  2607.   if (raw_width > width+1)
    2608. 

  2608.     black = lblack / ((raw_width - width) * height);
    2609. 

  2609.   if (!strncmp(model,"DC2",3))
    2610. 

  2610.     black = 0;
    2611. 

  2611.   maximum = curve[0xff];
    2612. 

  2612. }
    2613. 

  2613. 

  2614. void CLASS kodak_yrgb_load_raw()
    2615. 

  2615. {
    2616. 

  2616.   uchar *pixel;
    2617. 

  2617.   int row, col, y, cb, cr, rgb[3], c;
    2618. 

  2618. 

  2619.   pixel = (uchar *) calloc (raw_width, 3*sizeof *pixel);
    2620. 

  2620.   merror (pixel, "kodak_yrgb_load_raw()");
    2621. 

  2621.   for (row=0; row < height; row++) {
    2622. 

  2622.     if (~row & 1)
    2623. 

  2623.       if (fread (pixel, raw_width, 3, ifp) < 3) derror();
    2624. 

  2624.     for (col=0; col < raw_width; col++) {
    2625. 

  2625.       y  = pixel[width*2*(row & 1) + col];
    2626. 

  2626.       cb = pixel[width + (col & -2)]   - 128;
    2627. 

  2627.       cr = pixel[width + (col & -2)+1] - 128;
    2628. 

  2628.       rgb[1] = y-((cb + cr + 2) >> 2);
    2629. 

  2629.       rgb[2] = rgb[1] + cb;
    2630. 

  2630.       rgb[0] = rgb[1] + cr;
    2631. 

  2631.       FORC3{
    2632. 

  2632. #ifndef LIBRAW_LIBRARY_BUILD
    2633. 

  2633.           image[row*width+col][c] = curve[LIM(rgb[c],0,255)];
    2634. 

  2634. #else
    2635. 

  2635.           color_image[(row+top_margin)*raw_width+col+left_margin][c] = curve[LIM(rgb[c],0,255)];
    2636. 

  2636. #endif
    2637. 

  2637.       }
    2638. 

  2638.     }
    2639. 

  2639.   }
    2640. 

  2640.   free (pixel);
    2641. 

  2641.   maximum = curve[0xff];
    2642. 

  2642. }
    2643. 

  2643. 

  2644. void CLASS kodak_262_load_raw()
    2645. 

  2645. {
    2646. 

  2646.   static const uchar kodak_tree[2][26] =
    2647. 

  2647.   { { 0,1,5,1,1,2,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9 },
    2648. 

  2648.     { 0,3,1,1,1,1,1,2,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9 } };
    2649. 

  2649.   ushort *huff[2];
    2650. 

  2650.   uchar *pixel;
    2651. 

  2651.   int *strip, ns, c, row, col, chess, pi=0, pi1, pi2, pred, val;
    2652. 

  2652. 

  2653.   FORC(2) huff[c] = make_decoder (kodak_tree[c]);
    2654. 

  2654.   ns = (raw_height+63) >> 5;
    2655. 

  2655.   pixel = (uchar *) malloc (raw_width*32 + ns*4);
    2656. 

  2656.   merror (pixel, "kodak_262_load_raw()");
    2657. 

  2657.   strip = (int *) (pixel + raw_width*32);
    2658. 

  2658.   order = 0x4d4d;
    2659. 

  2659.   FORC(ns) strip[c] = get4();
    2660. 

  2660.   for (row=0; row < raw_height; row++) {
    2661. 

  2661.     if ((row & 31) == 0) {
    2662. 

  2662.       fseek (ifp, strip[row >> 5], SEEK_SET);
    2663. 

  2663.       getbits(-1);
    2664. 

  2664.       pi = 0;
    2665. 

  2665.     }
    2666. 

  2666.     for (col=0; col < raw_width; col++) {
    2667. 

  2667.       chess = (row + col) & 1;
    2668. 

  2668.       pi1 = chess ? pi-2           : pi-raw_width-1;
    2669. 

  2669.       pi2 = chess ? pi-2*raw_width : pi-raw_width+1;
    2670. 

  2670.       if (col <= chess) pi1 = -1;
    2671. 

  2671.       if (pi1 < 0) pi1 = pi2;
    2672. 

  2672.       if (pi2 < 0) pi2 = pi1;
    2673. 

  2673.       if (pi1 < 0 && col > 1) pi1 = pi2 = pi-2;
    2674. 

  2674.       pred = (pi1 < 0) ? 0 : (pixel[pi1] + pixel[pi2]) >> 1;
    2675. 

  2675.       pixel[pi] = val = pred + ljpeg_diff (huff[chess]);
    2676. 

  2676.       if (val >> 8) derror();
    2677. 

  2677. 

  2678.       val = curve[pixel[pi++]];
    2679. 

  2679. 

  2680. #ifdef LIBRAW_LIBRARY_BUILD
    2681. 

  2681.       RBAYER(row,col) = val;
    2682. 

  2682.       if ((unsigned) (col-left_margin) >= width)
    2683. 

  2683.           black+=val;
    2684. 

  2684. #else
    2685. 

  2685.       if ((unsigned) (col-left_margin) < width)
    2686. 

  2686. 	BAYER(row,col-left_margin) = val;
    2687. 

  2687.       else black += val;
    2688. 

  2688. #endif
    2689. 

  2689.     }
    2690. 

  2690.   }
    2691. 

  2691.   free (pixel);
    2692. 

  2692.   FORC(2) free (huff[c]);
    2693. 

  2693.   if (raw_width > width)
    2694. 

  2694.     black /= (raw_width - width) * height;
    2695. 

  2695. }
    2696. 

  2696. 

  2697. int CLASS kodak_65000_decode (short *out, int bsize)
    2698. 

  2698. {
    2699. 

  2699.   uchar c, blen[768];
    2700. 

  2700.   ushort raw[6];
    2701. 

  2701.   INT64 bitbuf=0;
    2702. 

  2702.   int save, bits=0, i, j, len, diff;
    2703. 

  2703. 

  2704.   save = ftell(ifp);
    2705. 

  2705.   bsize = (bsize + 3) & -4;
    2706. 

  2706.   for (i=0; i < bsize; i+=2) {
    2707. 

  2707.     c = fgetc(ifp);
    2708. 

  2708.     if ((blen[i  ] = c & 15) > 12 ||
    2709. 

  2709. 	(blen[i+1] = c >> 4) > 12 ) {
    2710. 

  2710.       fseek (ifp, save, SEEK_SET);
    2711. 

  2711.       for (i=0; i < bsize; i+=8) {
    2712. 

  2712. 	read_shorts (raw, 6);
    2713. 

  2713. 	out[i  ] = raw[0] >> 12 << 8 | raw[2] >> 12 << 4 | raw[4] >> 12;
    2714. 

  2714. 	out[i+1] = raw[1] >> 12 << 8 | raw[3] >> 12 << 4 | raw[5] >> 12;
    2715. 

  2715. 	for (j=0; j < 6; j++)
    2716. 

  2716. 	  out[i+2+j] = raw[j] & 0xfff;
    2717. 

  2717.       }
    2718. 

  2718.       return 1;
    2719. 

  2719.     }
    2720. 

  2720.   }
    2721. 

  2721.   if ((bsize & 7) == 4) {
    2722. 

  2722.     bitbuf  = fgetc(ifp) << 8;
    2723. 

  2723.     bitbuf += fgetc(ifp);
    2724. 

  2724.     bits = 16;
    2725. 

  2725.   }
    2726. 

  2726.   for (i=0; i < bsize; i++) {
    2727. 

  2727.     len = blen[i];
    2728. 

  2728.     if (bits < len) {
    2729. 

  2729.       for (j=0; j < 32; j+=8)
    2730. 

  2730. 	bitbuf += (INT64) fgetc(ifp) << (bits+(j^8));
    2731. 

  2731.       bits += 32;
    2732. 

  2732.     }
    2733. 

  2733.     diff = bitbuf & (0xffff >> (16-len));
    2734. 

  2734.     bitbuf >>= len;
    2735. 

  2735.     bits -= len;
    2736. 

  2736.     if ((diff & (1 << (len-1))) == 0)
    2737. 

  2737.       diff -= (1 << len) - 1;
    2738. 

  2738.     out[i] = diff;
    2739. 

  2739.   }
    2740. 

  2740.   return 0;
    2741. 

  2741. }
    2742. 

  2742. 

  2743. void CLASS kodak_65000_load_raw()
    2744. 

  2744. {
    2745. 

  2745.   short buf[256];
    2746. 

  2746.   int row, col, len, pred[2], ret, i;
    2747. 

  2747. 

  2748.   for (row=0; row < height; row++)
    2749. 

  2749.     for (col=0; col < width; col+=256) {
    2750. 

  2750.       pred[0] = pred[1] = 0;
    2751. 

  2751.       len = MIN (256, width-col);
    2752. 

  2752.       ret = kodak_65000_decode (buf, len);
    2753. 

  2753.       for (i=0; i < len; i++)
    2754. 

  2754. #ifndef LIBRAW_LIBRARY_BUILD
    2755. 

  2755. 	if ((BAYER(row,col+i) =	curve[ret ? buf[i] :
    2756. 

  2756. 		(pred[i & 1] += buf[i])]) >> 12) derror();
    2757. 

  2757. #else
    2758. 

  2758.       {
    2759. 

  2759.           ushort val = ret ? buf[i] : (pred[i & 1] += buf[i]);
    2760. 

  2760.           val = curve[val];
    2761. 

  2761.           RBAYER(row,col+i) = val;
    2762. 

  2762.           if(curve[val]>>12) derror();
    2763. 

  2763.       }
    2764. 

  2764. #endif
    2765. 

  2765.     }
    2766. 

  2766. }
    2767. 

  2767. 

  2768. void CLASS kodak_ycbcr_load_raw()
    2769. 

  2769. {
    2770. 

  2770.   short buf[384], *bp;
    2771. 

  2771.   int row, col, len, c, i, j, k, y[2][2], cb, cr, rgb[3];
    2772. 

  2772.   ushort *ip;
    2773. 

  2773. 

  2774.   for (row=0; row < height; row+=2)
    2775. 

  2775.     for (col=0; col < width; col+=128) {
    2776. 

  2776.       len = MIN (128, width-col);
    2777. 

  2777.       kodak_65000_decode (buf, len*3);
    2778. 

  2778.       y[0][1] = y[1][1] = cb = cr = 0;
    2779. 

  2779.       for (bp=buf, i=0; i < len; i+=2, bp+=2) {
    2780. 

  2780. 	cb += bp[4];
    2781. 

  2781. 	cr += bp[5];
    2782. 

  2782. 	rgb[1] = -((cb + cr + 2) >> 2);
    2783. 

  2783. 	rgb[2] = rgb[1] + cb;
    2784. 

  2784. 	rgb[0] = rgb[1] + cr;
    2785. 

  2785. 	for (j=0; j < 2; j++)
    2786. 

  2786. 	  for (k=0; k < 2; k++) {
    2787. 

  2787. 	    if ((y[j][k] = y[j][k^1] + *bp++) >> 10) derror();
    2788. 

  2788. #ifndef LIBRAW_LIBRARY_BUILD
    2789. 

  2789. 	    ip = image[(row+j)*width + col+i+k];
    2790. 

  2790. 	    FORC3 ip[c] = curve[LIM(y[j][k]+rgb[c], 0, 0xfff)];
    2791. 

  2791. #else
    2792. 

  2792. 	    ip = color_image[(row+top_margin+j)*raw_width + col+i+k+left_margin];
    2793. 

  2793.             FORC3 ip[c] = curve[LIM(y[j][k]+rgb[c], 0, 0xfff)];
    2794. 

  2794. #endif
    2795. 

  2795. 	  }
    2796. 

  2796.       }
    2797. 

  2797.     }
    2798. 

  2798. }
    2799. 

  2799. 

  2800. void CLASS kodak_rgb_load_raw()
    2801. 

  2801. {
    2802. 

  2802.   short buf[768], *bp;
    2803. 

  2803.   int row, col, len, c, i, rgb[3];
    2804. 

  2804. #ifndef LIBRAW_LIBRARY_BUILD
    2805. 

  2805.   ushort *ip=image[0];
    2806. 

  2806. #else
    2807. 

  2807.   ushort *ip;
    2808. 

  2808. #endif
    2809. 

  2809. 

  2810.   for (row=0; row < height; row++)
    2811. 

  2811.     for (col=0; col < width; col+=256) {
    2812. 

  2812.       len = MIN (256, width-col);
    2813. 

  2813.       kodak_65000_decode (buf, len*3);
    2814. 

  2814.       memset (rgb, 0, sizeof rgb);
    2815. 

  2815. #ifdef LIBRAW_LIBRARY_BUILD
    2816. 

  2816.       ip = &color_image[(row+top_margin)*raw_width+left_margin][0];
    2817. 

  2817. #endif
    2818. 

  2818.       for (bp=buf, i=0; i < len; i++, ip+=4)
    2819. 

  2819.           FORC3{
    2820. 

  2820.               if ((ip[c] = rgb[c] += *bp++) >> 12) derror();
    2821. 

  2821.           }
    2822. 

  2822.     }
    2823. 

  2823. }
    2824. 

  2824. 

  2825. void CLASS kodak_ycbcr_load_thumb()
    2826. 

  2826. {
    2827. 

  2827.   short buf[384], *bp;
    2828. 

  2828.   int row, col, len, c, i, j, k, y[2][2], cb, cr, rgb[3];
    2829. 

  2829.   ushort *ip;
    2830. 

  2830. 

  2831.   for (row=0; row < height; row+=2)
    2832. 

  2832.     for (col=0; col < width; col+=128) {
    2833. 

  2833.       len = MIN (128, width-col);
    2834. 

  2834.       kodak_65000_decode (buf, len*3);
    2835. 

  2835.       y[0][1] = y[1][1] = cb = cr = 0;
    2836. 

  2836.       for (bp=buf, i=0; i < len; i+=2, bp+=2) {
    2837. 

  2837. 	cb += bp[4];
    2838. 

  2838. 	cr += bp[5];
    2839. 

  2839. 	rgb[1] = -((cb + cr + 2) >> 2);
    2840. 

  2840. 	rgb[2] = rgb[1] + cb;
    2841. 

  2841. 	rgb[0] = rgb[1] + cr;
    2842. 

  2842. 	for (j=0; j < 2; j++)
    2843. 

  2843. 	  for (k=0; k < 2; k++) {
    2844. 

  2844. 	    if ((y[j][k] = y[j][k^1] + *bp++) >> 10) derror();
    2845. 

  2845. 	    ip = image[(row+j)*width + col+i+k];
    2846. 

  2846. 	    FORC3 ip[c] = curve[LIM(y[j][k]+rgb[c], 0, 0xfff)];
    2847. 

  2847. 	  }
    2848. 

  2848.       }
    2849. 

  2849.     }
    2850. 

  2850. }
    2851. 

  2851. 

  2852. void CLASS kodak_rgb_load_thumb()
    2853. 

  2853. {
    2854. 

  2854.   short buf[768], *bp;
    2855. 

  2855.   int row, col, len, c, i, rgb[3];
    2856. 

  2856.   ushort *ip=image[0];
    2857. 

  2857. 

  2858.   for (row=0; row < height; row++)
    2859. 

  2859.     for (col=0; col < width; col+=256) {
    2860. 

  2860.       len = MIN (256, width-col);
    2861. 

  2861.       kodak_65000_decode (buf, len*3);
    2862. 

  2862.       memset (rgb, 0, sizeof rgb);
    2863. 

  2863.       for (bp=buf, i=0; i < len; i++, ip+=4)
    2864. 

  2864. 	FORC3 if ((ip[c] = rgb[c] += *bp++) >> 12) derror();
    2865. 

  2865.     }
    2866. 

  2866. }
    2867. 

  2867. 

  2868. void CLASS kodak_thumb_load_raw()
    2869. 

  2869. {
    2870. 

  2870.   int row, col;
    2871. 

  2871.   colors = thumb_misc >> 5;
    2872. 

  2872.   for (row=0; row < height; row++)
    2873. 

  2873.     for (col=0; col < width; col++)
    2874. 

  2874.       read_shorts (image[row*width+col], colors);
    2875. 

  2875.   maximum = (1 << (thumb_misc & 31)) - 1;
    2876. 

  2876. }
    2877. 

  2877. 

  2878. void CLASS sony_decrypt (unsigned *data, int len, int start, int key)
    2879. 

  2879. {
    2880. 

  2880. #ifndef LIBRAW_NOTHREADS
    2881. 

  2881. #define pad tls->sony_decrypt.pad
    2882. 

  2882. #define p   tls->sony_decrypt.p
    2883. 

  2883. #else
    2884. 

  2884.   static unsigned pad[128], p;
    2885. 

  2885. #endif
    2886. 

  2886. 

  2887.   if (start) {
    2888. 

  2888.     for (p=0; p < 4; p++)
    2889. 

  2889.       pad[p] = key = key * 48828125 + 1;
    2890. 

  2890.     pad[3] = pad[3] << 1 | (pad[0]^pad[2]) >> 31;
    2891. 

  2891.     for (p=4; p < 127; p++)
    2892. 

  2892.       pad[p] = (pad[p-4]^pad[p-2]) << 1 | (pad[p-3]^pad[p-1]) >> 31;
    2893. 

  2893.     for (p=0; p < 127; p++)
    2894. 

  2894.       pad[p] = htonl(pad[p]);
    2895. 

  2895.   }
    2896. 

  2896.   while (len--)
    2897. 

  2897.     *data++ ^= pad[p++ & 127] = pad[(p+1) & 127] ^ pad[(p+65) & 127];
    2898. 

  2898. #ifndef LIBRAW_NOTHREADS
    2899. 

  2899. #undef pad
    2900. 

  2900. #undef p
    2901. 

  2901. #endif
    2902. 

  2902. }
    2903. 

  2903. 

  2904. void CLASS sony_load_raw()
    2905. 

  2905. {
    2906. 

  2906.   uchar head[40];
    2907. 

  2907.   ushort *pixel;
    2908. 

  2908.   unsigned i, key, row, col;
    2909. 

  2909. 

  2910.   fseek (ifp, 200896, SEEK_SET);
    2911. 

  2911.   fseek (ifp, (unsigned) fgetc(ifp)*4 - 1, SEEK_CUR);
    2912. 

  2912.   order = 0x4d4d;
    2913. 

  2913.   key = get4();
    2914. 

  2914.   fseek (ifp, 164600, SEEK_SET);
    2915. 

  2915.   fread (head, 1, 40, ifp);
    2916. 

  2916.   sony_decrypt ((unsigned int *) head, 10, 1, key);
    2917. 

  2917.   for (i=26; i-- > 22; )
    2918. 

  2918.     key = key << 8 | head[i];
    2919. 

  2919.   fseek (ifp, data_offset, SEEK_SET);
    2920. 

  2920.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    2921. 

  2921.   merror (pixel, "sony_load_raw()");
    2922. 

  2922.   for (row=0; row < height; row++) {
    2923. 

  2923.     if (fread (pixel, 2, raw_width, ifp) < raw_width) derror();
    2924. 

  2924.     sony_decrypt ((unsigned int *) pixel, raw_width/2, !row, key);
    2925. 

  2925.     for (col=9; col < left_margin; col++)
    2926. 

  2926.       black += ntohs(pixel[col]);
    2927. 

  2927. #ifndef LIBRAW_LIBRARY_BUILD
    2928. 

  2928.     for (col=0; col < width; col++)
    2929. 

  2929.       if ((BAYER(row,col) = ntohs(pixel[col+left_margin])) >> 14)
    2930. 

  2930. 	derror();
    2931. 

  2931. #else
    2932. 

  2932.     for (col=0; col < raw_width; col++)
    2933. 

  2933.         {
    2934. 

  2934.             RBAYER(row,col) = ntohs(pixel[col]);
    2935. 

  2935.             if(col >= left_margin && col < width+left_margin
    2936. 

  2936.                && (RBAYER(row,col)>>14))
    2937. 

  2937.                 derror();
    2938. 

  2938.         }
    2939. 

  2939. #endif
    2940. 

  2940.    }
    2941. 

  2941.   free (pixel);
    2942. 

  2942.   if (left_margin > 9)
    2943. 

  2943.     black /= (left_margin-9) * height;
    2944. 

  2944.   maximum = 0x3ff0;
    2945. 

  2945. }
    2946. 

  2946. 

  2947. void CLASS sony_arw_load_raw()
    2948. 

  2948. {
    2949. 

  2949.   ushort huff[32768];
    2950. 

  2950.   static const ushort tab[18] =
    2951. 

  2951.   { 0xf11,0xf10,0xe0f,0xd0e,0xc0d,0xb0c,0xa0b,0x90a,0x809,
    2952. 

  2952.     0x708,0x607,0x506,0x405,0x304,0x303,0x300,0x202,0x201 };
    2953. 

  2953.   int i, c, n, col, row, len, diff, sum=0;
    2954. 

  2954. 

  2955.   for (n=i=0; i < 18; i++)
    2956. 

  2956.     FORC(32768 >> (tab[i] >> 8)) huff[n++] = tab[i];
    2957. 

  2957. #ifdef LIBRAW_LIBRARY_BUILD
    2958. 

  2958.   LibRaw_byte_buffer *buf=NULL;
    2959. 

  2959.   if(data_size)
    2960. 

  2960.       buf = ifp->make_byte_buffer(data_size);
    2961. 

  2961.   else
    2962. 

  2962.       getbits(-1);
    2963. 

  2963.       
    2964. 

  2964.   LibRaw_bit_buffer bits;
    2965. 

  2965.   bits.reset();
    2966. 

  2966. #else
    2967. 

  2967.   getbits(-1);
    2968. 

  2968. #endif
    2969. 

  2969.   for (col = raw_width; col--; )
    2970. 

  2970.     for (row=0; row < raw_height+1; row+=2) {
    2971. 

  2971.       if (row == raw_height) row = 1;
    2972. 

  2972. #ifdef LIBRAW_LIBRARY_BUILD
    2973. 

  2973.       if(data_size)
    2974. 

  2974.           {
    2975. 

  2975.               len = bits._gethuff(buf,15,huff,zero_after_ff);
    2976. 

  2976.               diff = bits._getbits(buf,len,zero_after_ff);
    2977. 

  2977.           }
    2978. 

  2978.       else
    2979. 

  2979.           {
    2980. 

  2980.               len = getbithuff(15,huff);
    2981. 

  2981.               diff = getbits(len);
    2982. 

  2982.           }
    2983. 

  2983. #else
    2984. 

  2984.       len = getbithuff(15,huff);
    2985. 

  2985.       diff = getbits(len);
    2986. 

  2986. #endif
    2987. 

  2987.       if ((diff & (1 << (len-1))) == 0)
    2988. 

  2988. 	diff -= (1 << len) - 1;
    2989. 

  2989.       if ((sum += diff) >> 12) derror();
    2990. 

  2990. #ifndef LIBRAW_LIBRARY_BUILD
    2991. 

  2991.       if (row < height)
    2992. 

  2992.           {
    2993. 

  2993.               BAYER(row,col) = sum;
    2994. 

  2994.           }
    2995. 

  2995. #else
    2996. 

  2996.       RBAYER(row,col) = sum;
    2997. 

  2997. #endif
    2998. 

  2998.     }
    2999. 

  2999. #ifdef LIBRAW_LIBRARY_BUILD
    3000. 

  3000.   if(buf) delete buf;
    3001. 

  3001. #endif
    3002. 

  3002. }
    3003. 

  3003. 

  3004. void CLASS sony_arw2_load_raw()
    3005. 

  3005. {
    3006. 

  3006.   uchar *data, *dp;
    3007. 

  3007.   ushort pix[16];
    3008. 

  3008.   int row, col, val, max, min, imax, imin, sh, bit, i;
    3009. 

  3009. 

  3010.   data = (uchar *) malloc (raw_width);
    3011. 

  3011.   merror (data, "sony_arw2_load_raw()");
    3012. 

  3012.   for (row=0; row < height; row++) {
    3013. 

  3013.     fread (data, 1, raw_width, ifp);
    3014. 

  3014.     for (dp=data, col=0; col < raw_width-30; dp+=16) {
    3015. 

  3015.       max = 0x7ff & (val = sget4(dp));
    3016. 

  3016.       min = 0x7ff & val >> 11;
    3017. 

  3017.       imax = 0x0f & val >> 22;
    3018. 

  3018.       imin = 0x0f & val >> 26;
    3019. 

  3019.       for (sh=0; sh < 4 && 0x80 << sh <= max-min; sh++);
    3020. 

  3020.       for (bit=30, i=0; i < 16; i++)
    3021. 

  3021. 	if      (i == imax) pix[i] = max;
    3022. 

  3022. 	else if (i == imin) pix[i] = min;
    3023. 

  3023. 	else {
    3024. 

  3024. 	  pix[i] = ((sget2(dp+(bit >> 3)) >> (bit & 7) & 0x7f) << sh) + min;
    3025. 

  3025. 	  if (pix[i] > 0x7ff) pix[i] = 0x7ff;
    3026. 

  3026. 	  bit += 7;
    3027. 

  3027. 	}
    3028. 

  3028.       for (i=0; i < 16; i++, col+=2)
    3029. 

  3029. #ifdef LIBRAW_LIBRARY_BUILD
    3030. 

  3030. 	RBAYER(row,col) = curve[pix[i] << 1] >> 2;
    3031. 

  3031. #else
    3032. 

  3032. 	if (col < width) BAYER(row,col) = curve[pix[i] << 1] >> 2;
    3033. 

  3033. #endif
    3034. 

  3034.       col -= col & 1 ? 1:31;
    3035. 

  3035.     }
    3036. 

  3036.   }
    3037. 

  3037.   free (data);
    3038. 

  3038. }
    3039. 

  3039.  
    3040. 

  3040. #define HOLE(row) ((holes >> (((row) - raw_height) & 7)) & 1)
    3041. 

  3041. 

  3042. /* Kudos to Rich Taylor for figuring out SMaL's compression algorithm. */
    3043. 

  3043. void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
    3044. 

  3044. {
    3045. 

  3045.   uchar hist[3][13] = {
    3046. 

  3046.     { 7, 7, 0, 0, 63, 55, 47, 39, 31, 23, 15, 7, 0 },
    3047. 

  3047.     { 7, 7, 0, 0, 63, 55, 47, 39, 31, 23, 15, 7, 0 },
    3048. 

  3048.     { 3, 3, 0, 0, 63,     47,     31,     15,    0 } };
    3049. 

  3049.   int low, high=0xff, carry=0, nbits=8;
    3050. 

  3050.   int s, count, bin, next, i, sym[3];
    3051. 

  3051.   uchar diff, pred[]={0,0};
    3052. 

  3052.   ushort data=0, range=0;
    3053. 

  3053.   unsigned pix, row, col;
    3054. 

  3054. 

  3055.   fseek (ifp, seg[0][1]+1, SEEK_SET);
    3056. 

  3056.   getbits(-1);
    3057. 

  3057.   for (pix=seg[0][0]; pix < seg[1][0]; pix++) {
    3058. 

  3058.     for (s=0; s < 3; s++) {
    3059. 

  3059.       data = data << nbits | getbits(nbits);
    3060. 

  3060.       if (carry < 0)
    3061. 

  3061. 	carry = (nbits += carry+1) < 1 ? nbits-1 : 0;
    3062. 

  3062.       while (--nbits >= 0)
    3063. 

  3063. 	if ((data >> nbits & 0xff) == 0xff) break;
    3064. 

  3064.       if (nbits > 0)
    3065. 

  3065. 	  data = ((data & ((1 << (nbits-1)) - 1)) << 1) |
    3066. 

  3066. 	((data + (((data & (1 << (nbits-1)))) << 1)) & (-1 << nbits));
    3067. 

  3067.       if (nbits >= 0) {
    3068. 

  3068. 	data += getbits(1);
    3069. 

  3069. 	carry = nbits - 8;
    3070. 

  3070.       }
    3071. 

  3071.       count = ((((data-range+1) & 0xffff) << 2) - 1) / (high >> 4);
    3072. 

  3072.       for (bin=0; hist[s][bin+5] > count; bin++);
    3073. 

  3073. 		low = hist[s][bin+5] * (high >> 4) >> 2;
    3074. 

  3074.       if (bin) high = hist[s][bin+4] * (high >> 4) >> 2;
    3075. 

  3075.       high -= low;
    3076. 

  3076.       for (nbits=0; high << nbits < 128; nbits++);
    3077. 

  3077.       range = (range+low) << nbits;
    3078. 

  3078.       high <<= nbits;
    3079. 

  3079.       next = hist[s][1];
    3080. 

  3080.       if (++hist[s][2] > hist[s][3]) {
    3081. 

  3081. 	next = (next+1) & hist[s][0];
    3082. 

  3082. 	hist[s][3] = (hist[s][next+4] - hist[s][next+5]) >> 2;
    3083. 

  3083. 	hist[s][2] = 1;
    3084. 

  3084.       }
    3085. 

  3085.       if (hist[s][hist[s][1]+4] - hist[s][hist[s][1]+5] > 1) {
    3086. 

  3086. 	if (bin < hist[s][1])
    3087. 

  3087. 	  for (i=bin; i < hist[s][1]; i++) hist[s][i+5]--;
    3088. 

  3088. 	else if (next <= bin)
    3089. 

  3089. 	  for (i=hist[s][1]; i < bin; i++) hist[s][i+5]++;
    3090. 

  3090.       }
    3091. 

  3091.       hist[s][1] = next;
    3092. 

  3092.       sym[s] = bin;
    3093. 

  3093.     }
    3094. 

  3094.     diff = sym[2] << 5 | sym[1] << 2 | (sym[0] & 3);
    3095. 

  3095.     if (sym[0] & 4)
    3096. 

  3096.       diff = diff ? -diff : 0x80;
    3097. 

  3097.     if (ftell(ifp) + 12 >= seg[1][1])
    3098. 

  3098.       diff = 0;
    3099. 

  3099.     pred[pix & 1] += diff;
    3100. 

  3100. #ifndef LIBRAW_LIBRARY_BUILD
    3101. 

  3101.     row = pix / raw_width - top_margin;
    3102. 

  3102.     col = pix % raw_width - left_margin;
    3103. 

  3103.     if (row < height && col < width)
    3104. 

  3104.             BAYER(row,col) = pred[pix & 1];
    3105. 

  3105. #else
    3106. 

  3106.     row = pix / raw_width - top_margin;
    3107. 

  3107.     RBAYER(pix / raw_width, pix % raw_width) = pred[pix & 1];
    3108. 

  3108. #endif
    3109. 

  3109.     if (!(pix & 1) && HOLE(row)) pix += 2;
    3110. 

  3110.   }
    3111. 

  3111.   maximum = 0xff;
    3112. 

  3112. }
    3113. 

  3113. 

  3114. void CLASS smal_v6_load_raw()
    3115. 

  3115. {
    3116. 

  3116.   unsigned seg[2][2];
    3117. 

  3117. 

  3118.   fseek (ifp, 16, SEEK_SET);
    3119. 

  3119.   seg[0][0] = 0;
    3120. 

  3120.   seg[0][1] = get2();
    3121. 

  3121.   seg[1][0] = raw_width * raw_height;
    3122. 

  3122.   seg[1][1] = INT_MAX;
    3123. 

  3123.   smal_decode_segment (seg, 0);
    3124. 

  3124. }
    3125. 

  3125. 

  3126. int CLASS median4 (int *p)
    3127. 

  3127. {
    3128. 

  3128.   int min, max, sum, i;
    3129. 

  3129. 

  3130.   min = max = sum = p[0];
    3131. 

  3131.   for (i=1; i < 4; i++) {
    3132. 

  3132.     sum += p[i];
    3133. 

  3133.     if (min > p[i]) min = p[i];
    3134. 

  3134.     if (max < p[i]) max = p[i];
    3135. 

  3135.   }
    3136. 

  3136.   return (sum - min - max) >> 1;
    3137. 

  3137. }
    3138. 

  3138. 

  3139. void CLASS fill_holes (int holes)
    3140. 

  3140. {
    3141. 

  3141.   int row, col, val[4];
    3142. 

  3142. 

  3143.   for (row=2; row < height-2; row++) {
    3144. 

  3144.     if (!HOLE(row)) continue;
    3145. 

  3145.     for (col=1; col < width-1; col+=4) {
    3146. 

  3146.       val[0] = BAYER(row-1,col-1);
    3147. 

  3147.       val[1] = BAYER(row-1,col+1);
    3148. 

  3148.       val[2] = BAYER(row+1,col-1);
    3149. 

  3149.       val[3] = BAYER(row+1,col+1);
    3150. 

  3150.       BAYER(row,col) = median4(val);
    3151. 

  3151.     }
    3152. 

  3152.     for (col=2; col < width-2; col+=4)
    3153. 

  3153.       if (HOLE(row-2) || HOLE(row+2))
    3154. 

  3154. 	BAYER(row,col) = (BAYER(row,col-2) + BAYER(row,col+2)) >> 1;
    3155. 

  3155.       else {
    3156. 

  3156. 	val[0] = BAYER(row,col-2);
    3157. 

  3157. 	val[1] = BAYER(row,col+2);
    3158. 

  3158. 	val[2] = BAYER(row-2,col);
    3159. 

  3159. 	val[3] = BAYER(row+2,col);
    3160. 

  3160. 	BAYER(row,col) = median4(val);
    3161. 

  3161.       }
    3162. 

  3162.   }
    3163. 

  3163. }
    3164. 

  3164. 

  3165. void CLASS smal_v9_load_raw()
    3166. 

  3166. {
    3167. 

  3167.   unsigned seg[256][2], offset, nseg, holes, i;
    3168. 

  3168. 

  3169.   fseek (ifp, 67, SEEK_SET);
    3170. 

  3170.   offset = get4();
    3171. 

  3171.   nseg = fgetc(ifp);
    3172. 

  3172.   fseek (ifp, offset, SEEK_SET);
    3173. 

  3173.   for (i=0; i < nseg*2; i++)
    3174. 

  3174.     seg[0][i] = get4() + data_offset*(i & 1);
    3175. 

  3175.   fseek (ifp, 78, SEEK_SET);
    3176. 

  3176.   holes = fgetc(ifp);
    3177. 

  3177.   fseek (ifp, 88, SEEK_SET);
    3178. 

  3178.   seg[nseg][0] = raw_height * raw_width;
    3179. 

  3179.   seg[nseg][1] = get4() + data_offset;
    3180. 

  3180.   for (i=0; i < nseg; i++)
    3181. 

  3181.     smal_decode_segment (seg+i, holes);
    3182. 

  3182.   if (holes) fill_holes (holes);
    3183. 

  3183. }
    3184. 

  3184. 

  3185. void CLASS redcine_load_raw()
    3186. 

  3186. {
    3187. 

  3187. #ifndef NO_JASPER
    3188. 

  3188.   int c, row, col;
    3189. 

  3189.   jas_stream_t *in;
    3190. 

  3190.   jas_image_t *jimg;
    3191. 

  3191.   jas_matrix_t *jmat;
    3192. 

  3192.   jas_seqent_t *data;
    3193. 

  3193.   ushort *img, *pix;
    3194. 

  3194. 

  3195.   jas_init();
    3196. 

  3196. #ifndef LIBRAW_LIBRARY_BUILD
    3197. 

  3197.   in = jas_stream_fopen (ifname, "rb");
    3198. 

  3198. #else
    3199. 

  3199.   in = (jas_stream_t*)ifp->make_jas_stream();
    3200. 

  3200.   if(!in)
    3201. 

  3201.           throw LIBRAW_EXCEPTION_DECODE_JPEG2000;
    3202. 

  3202. #endif
    3203. 

  3203.   jas_stream_seek (in, data_offset+20, SEEK_SET);
    3204. 

  3204.   jimg = jas_image_decode (in, -1, 0);
    3205. 

  3205. #ifndef LIBRAW_LIBRARY_BUILD
    3206. 

  3206.   if (!jimg) longjmp (failure, 3);
    3207. 

  3207. #else
    3208. 

  3208.   if(!jimg)
    3209. 

  3209.       {
    3210. 

  3210.           jas_stream_close (in);
    3211. 

  3211.           throw LIBRAW_EXCEPTION_DECODE_JPEG2000;
    3212. 

  3212.       }
    3213. 

  3213. #endif
    3214. 

  3214.   jmat = jas_matrix_create (height/2, width/2);
    3215. 

  3215.   merror (jmat, "redcine_load_raw()");
    3216. 

  3216.   img = (ushort *) calloc ((height+2)*(width+2), 2);
    3217. 

  3217.   merror (img, "redcine_load_raw()");
    3218. 

  3218.   FORC4 {
    3219. 

  3219.     jas_image_readcmpt (jimg, c, 0, 0, width/2, height/2, jmat);
    3220. 

  3220.     data = jas_matrix_getref (jmat, 0, 0);
    3221. 

  3221.     for (row = c >> 1; row < height; row+=2)
    3222. 

  3222.       for (col = c & 1; col < width; col+=2)
    3223. 

  3223. 	img[(row+1)*(width+2)+col+1] = data[(row/2)*(width/2)+col/2];
    3224. 

  3224.   }
    3225. 

  3225.   for (col=1; col <= width; col++) {
    3226. 

  3226.     img[col] = img[2*(width+2)+col];
    3227. 

  3227.     img[(height+1)*(width+2)+col] = img[(height-1)*(width+2)+col];
    3228. 

  3228.   }
    3229. 

  3229.   for (row=0; row < height+2; row++) {
    3230. 

  3230.     img[row*(width+2)] = img[row*(width+2)+2];
    3231. 

  3231.     img[(row+1)*(width+2)-1] = img[(row+1)*(width+2)-3];
    3232. 

  3232.   }
    3233. 

  3233.   for (row=1; row <= height; row++) {
    3234. 

  3234.     pix = img + row*(width+2) + (col = 1 + (FC(row,1) & 1));
    3235. 

  3235.     for (   ; col <= width; col+=2, pix+=2) {
    3236. 

  3236.       c = (((pix[0] - 0x800) << 3) +
    3237. 

  3237. 	pix[-(width+2)] + pix[width+2] + pix[-1] + pix[1]) >> 2;
    3238. 

  3238.       pix[0] = LIM(c,0,4095);
    3239. 

  3239.     }
    3240. 

  3240.   }
    3241. 

  3241.   for (row=0; row < height; row++)
    3242. 

  3242.     for (col=0; col < width; col++)
    3243. 

  3243.       RBAYER(row,col) = curve[img[(row+1)*(width+2)+col+1]];
    3244. 

  3244.   free (img);
    3245. 

  3245.   jas_matrix_destroy (jmat);
    3246. 

  3246.   jas_image_destroy (jimg);
    3247. 

  3247.   jas_stream_close (in);
    3248. 

  3248. #endif
    3249. 

  3249. }
    3250. 

  3250. 

  3251. 

  3252. void CLASS gamma_curve (double pwr, double ts, int mode, int imax)
    3253. 

  3253. {
    3254. 

  3254.   int i;
    3255. 

  3255.   double g[6], bnd[2]={0,0}, r;
    3256. 

  3256. 

  3257.   g[0] = pwr;
    3258. 

  3258.   g[1] = ts;
    3259. 

  3259.   g[2] = g[3] = g[4] = 0;
    3260. 

  3260.   bnd[g[1] >= 1] = 1;
    3261. 

  3261.   if (g[1] && (g[1]-1)*(g[0]-1) <= 0) {
    3262. 

  3262.     for (i=0; i < 48; i++) {
    3263. 

  3263.       g[2] = (bnd[0] + bnd[1])/2;
    3264. 

  3264.       if (g[0]) bnd[(pow(g[2]/g[1],-g[0]) - 1)/g[0] - 1/g[2] > -1] = g[2];
    3265. 

  3265.       else	bnd[g[2]/exp(1-1/g[2]) < g[1]] = g[2];
    3266. 

  3266.     }
    3267. 

  3267.     g[3] = g[2] / g[1];
    3268. 

  3268.     if (g[0]) g[4] = g[2] * (1/g[0] - 1);
    3269. 

  3269.   }
    3270. 

  3270.   if (g[0]) g[5] = 1 / (g[1]*SQR(g[3])/2 - g[4]*(1 - g[3]) +
    3271. 

  3271. 		(1 - pow(g[3],1+g[0]))*(1 + g[4])/(1 + g[0])) - 1;
    3272. 

  3272.   else      g[5] = 1 / (g[1]*SQR(g[3])/2 + 1
    3273. 

  3273. 		- g[2] - g[3] -	g[2]*g[3]*(log(g[3]) - 1)) - 1;
    3274. 

  3274.   if (!mode--) {
    3275. 

  3275.     memcpy (gamm, g, sizeof gamm);
    3276. 

  3276.     return;
    3277. 

  3277.   }
    3278. 

  3278.   for (i=0; i < 0x10000; i++) {
    3279. 

  3279.     curve[i] = 0xffff;
    3280. 

  3280.     if ((r = (double) i / imax) < 1)
    3281. 

  3281.       curve[i] = 0x10000 * ( mode
    3282. 

  3282. 	? (r < g[3] ? r*g[1] : (g[0] ? pow( r,g[0])*(1+g[4])-g[4]    : log(r)*g[2]+1))
    3283. 

  3283. 	: (r < g[2] ? r/g[1] : (g[0] ? pow((r+g[4])/(1+g[4]),1/g[0]) : exp((r-1)/g[2]))));
    3284. 

  3284.   }
    3285. 

  3285. }
    3286. 

  3286. 

  3287. void CLASS pseudoinverse (double (*in)[3], double (*out)[3], int size)
    3288. 

  3288. {
    3289. 

  3289.   double work[3][6], num;
    3290. 

  3290.   int i, j, k;
    3291. 

  3291. 

  3292.   for (i=0; i < 3; i++) {
    3293. 

  3293.     for (j=0; j < 6; j++)
    3294. 

  3294.       work[i][j] = j == i+3;
    3295. 

  3295.     for (j=0; j < 3; j++)
    3296. 

  3296.       for (k=0; k < size; k++)
    3297. 

  3297. 	work[i][j] += in[k][i] * in[k][j];
    3298. 

  3298.   }
    3299. 

  3299.   for (i=0; i < 3; i++) {
    3300. 

  3300.     num = work[i][i];
    3301. 

  3301.     for (j=0; j < 6; j++)
    3302. 

  3302.       work[i][j] /= num;
    3303. 

  3303.     for (k=0; k < 3; k++) {
    3304. 

  3304.       if (k==i) continue;
    3305. 

  3305.       num = work[k][i];
    3306. 

  3306.       for (j=0; j < 6; j++)
    3307. 

  3307. 	work[k][j] -= work[i][j] * num;
    3308. 

  3308.     }
    3309. 

  3309.   }
    3310. 

  3310.   for (i=0; i < size; i++)
    3311. 

  3311.     for (j=0; j < 3; j++)
    3312. 

  3312.       for (out[i][j]=k=0; k < 3; k++)
    3313. 

  3313. 	out[i][j] += work[j][k+3] * in[i][k];
    3314. 

  3314. }
    3315. 

  3315. 

  3316. void CLASS cam_xyz_coeff (double cam_xyz[4][3])
    3317. 

  3317. {
    3318. 

  3318.   double cam_rgb[4][3], inverse[4][3], num;
    3319. 

  3319.   int i, j, k;
    3320. 

  3320. 

  3321.   for (i=0; i < colors; i++)		/* Multiply out XYZ colorspace */
    3322. 

  3322.     for (j=0; j < 3; j++)
    3323. 

  3323.       for (cam_rgb[i][j] = k=0; k < 3; k++)
    3324. 

  3324. 	cam_rgb[i][j] += cam_xyz[i][k] * xyz_rgb[k][j];
    3325. 

  3325. 

  3326.   for (i=0; i < colors; i++) {		/* Normalize cam_rgb so that */
    3327. 

  3327.     for (num=j=0; j < 3; j++)		/* cam_rgb * (1,1,1) is (1,1,1,1) */
    3328. 

  3328.       num += cam_rgb[i][j];
    3329. 

  3329.     for (j=0; j < 3; j++)
    3330. 

  3330.       cam_rgb[i][j] /= num;
    3331. 

  3331.     pre_mul[i] = 1 / num;
    3332. 

  3332.   }
    3333. 

  3333.   pseudoinverse (cam_rgb, inverse, colors);
    3334. 

  3334.   for (raw_color = i=0; i < 3; i++)
    3335. 

  3335.     for (j=0; j < colors; j++)
    3336. 

  3336.       rgb_cam[i][j] = inverse[j][i];
    3337. 

  3337. #ifdef LIBRAW_LIBRARY_BUILD
    3338. 

  3338.   color_flags.pre_mul_state = LIBRAW_COLORSTATE_CONST;
    3339. 

  3339.   color_flags.rgb_cam_state = LIBRAW_COLORSTATE_CONST;
    3340. 

  3340. #endif
    3341. 

  3341. }
    3342. 

  3342. 

  3343. #ifdef COLORCHECK
    3344. 

  3344. void CLASS colorcheck()
    3345. 

  3345. {
    3346. 

  3346. #define NSQ 24
    3347. 

  3347. // Coordinates of the GretagMacbeth ColorChecker squares
    3348. 

  3348. // width, height, 1st_column, 1st_row
    3349. 

  3349.   int cut[NSQ][4];			// you must set these
    3350. 

  3350. // ColorChecker Chart under 6500-kelvin illumination
    3351. 

  3351.   static const double gmb_xyY[NSQ][3] = {
    3352. 

  3352.     { 0.400, 0.350, 10.1 },		// Dark Skin
    3353. 

  3353.     { 0.377, 0.345, 35.8 },		// Light Skin
    3354. 

  3354.     { 0.247, 0.251, 19.3 },		// Blue Sky
    3355. 

  3355.     { 0.337, 0.422, 13.3 },		// Foliage
    3356. 

  3356.     { 0.265, 0.240, 24.3 },		// Blue Flower
    3357. 

  3357.     { 0.261, 0.343, 43.1 },		// Bluish Green
    3358. 

  3358.     { 0.506, 0.407, 30.1 },		// Orange
    3359. 

  3359.     { 0.211, 0.175, 12.0 },		// Purplish Blue
    3360. 

  3360.     { 0.453, 0.306, 19.8 },		// Moderate Red
    3361. 

  3361.     { 0.285, 0.202, 6.6 },		// Purple
    3362. 

  3362.     { 0.380, 0.489, 44.3 },		// Yellow Green
    3363. 

  3363.     { 0.473, 0.438, 43.1 },		// Orange Yellow
    3364. 

  3364.     { 0.187, 0.129, 6.1 },		// Blue
    3365. 

  3365.     { 0.305, 0.478, 23.4 },		// Green
    3366. 

  3366.     { 0.539, 0.313, 12.0 },		// Red
    3367. 

  3367.     { 0.448, 0.470, 59.1 },		// Yellow
    3368. 

  3368.     { 0.364, 0.233, 19.8 },		// Magenta
    3369. 

  3369.     { 0.196, 0.252, 19.8 },		// Cyan
    3370. 

  3370.     { 0.310, 0.316, 90.0 },		// White
    3371. 

  3371.     { 0.310, 0.316, 59.1 },		// Neutral 8
    3372. 

  3372.     { 0.310, 0.316, 36.2 },		// Neutral 6.5
    3373. 

  3373.     { 0.310, 0.316, 19.8 },		// Neutral 5
    3374. 

  3374.     { 0.310, 0.316, 9.0 },		// Neutral 3.5
    3375. 

  3375.     { 0.310, 0.316, 3.1 } };		// Black
    3376. 

  3376.   double gmb_cam[NSQ][4], gmb_xyz[NSQ][3];
    3377. 

  3377.   double inverse[NSQ][3], cam_xyz[4][3], num;
    3378. 

  3378.   int c, i, j, k, sq, row, col, count[4];
    3379. 

  3379. 

  3380.   memset (gmb_cam, 0, sizeof gmb_cam);
    3381. 

  3381.   for (sq=0; sq < NSQ; sq++) {
    3382. 

  3382.     FORCC count[c] = 0;
    3383. 

  3383.     for   (row=cut[sq][3]; row < cut[sq][3]+cut[sq][1]; row++)
    3384. 

  3384.       for (col=cut[sq][2]; col < cut[sq][2]+cut[sq][0]; col++) {
    3385. 

  3385. 	c = FC(row,col);
    3386. 

  3386. 	if (c >= colors) c -= 2;
    3387. 

  3387. 	gmb_cam[sq][c] += BAYER(row,col);
    3388. 

  3388. 	count[c]++;
    3389. 

  3389.       }
    3390. 

  3390.     FORCC gmb_cam[sq][c] = gmb_cam[sq][c]/count[c] - black;
    3391. 

  3391.     gmb_xyz[sq][0] = gmb_xyY[sq][2] * gmb_xyY[sq][0] / gmb_xyY[sq][1];
    3392. 

  3392.     gmb_xyz[sq][1] = gmb_xyY[sq][2];
    3393. 

  3393.     gmb_xyz[sq][2] = gmb_xyY[sq][2] *
    3394. 

  3394. 		(1 - gmb_xyY[sq][0] - gmb_xyY[sq][1]) / gmb_xyY[sq][1];
    3395. 

  3395.   }
    3396. 

  3396.   pseudoinverse (gmb_xyz, inverse, NSQ);
    3397. 

  3397.   for (i=0; i < colors; i++)
    3398. 

  3398.     for (j=0; j < 3; j++)
    3399. 

  3399.       for (cam_xyz[i][j] = k=0; k < NSQ; k++)
    3400. 

  3400. 	cam_xyz[i][j] += gmb_cam[k][i] * inverse[k][j];
    3401. 

  3401.   cam_xyz_coeff (cam_xyz);
    3402. 

  3402. #ifdef DCRAW_VERBOSE
    3403. 

  3403.   if (verbose) {
    3404. 

  3404.     printf ("    { \"%s %s\", %d,\n\t{", make, model, black);
    3405. 

  3405.     num = 10000 / (cam_xyz[1][0] + cam_xyz[1][1] + cam_xyz[1][2]);
    3406. 

  3406.     FORCC for (j=0; j < 3; j++)
    3407. 

  3407.       printf ("%c%d", (c | j) ? ',':' ', (int) (cam_xyz[c][j] * num + 0.5));
    3408. 

  3408.     puts (" } },");
    3409. 

  3409.   }
    3410. 

  3410. #endif
    3411. 

  3411. #undef NSQ
    3412. 

  3412. }
    3413. 

  3413. #endif
    3414. 

  3414. 

  3415. void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
    3416. 

  3416. {
    3417. 

  3417.   int i;
    3418. 

  3418.   for (i=0; i < sc; i++)
    3419. 

  3419.     temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
    3420. 

  3420.   for (; i+sc < size; i++)
    3421. 

  3421.     temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
    3422. 

  3422.   for (; i < size; i++)
    3423. 

  3423.     temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
    3424. 

  3424. }
    3425. 

  3425. 

  3426. #if !defined(LIBRAW_USE_OPENMP)
    3427. 

  3427. void CLASS wavelet_denoise()
    3428. 

  3428. {
    3429. 

  3429.   float *fimg=0, *temp, thold, mul[2], avg, diff;
    3430. 

  3430.   int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
    3431. 

  3431.   ushort *window[4];
    3432. 

  3432.   static const float noise[] =
    3433. 

  3433.   { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
    3434. 

  3434. 

  3435. #ifdef DCRAW_VERBOSE
    3436. 

  3436.   if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
    3437. 

  3437. #endif
    3438. 

  3438. 

  3439.   while (maximum << scale < 0x10000) scale++;
    3440. 

  3440.   maximum <<= --scale;
    3441. 

  3441.   black <<= scale;
    3442. 

  3442.   FORC4 cblack[c] <<= scale;
    3443. 

  3443.   if ((size = iheight*iwidth) < 0x15550000)
    3444. 

  3444.     fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
    3445. 

  3445.   merror (fimg, "wavelet_denoise()");
    3446. 

  3446.   temp = fimg + size*3;
    3447. 

  3447.   if ((nc = colors) == 3 && filters) nc++;
    3448. 

  3448.   FORC(nc) {			/* denoise R,G1,B,G3 individually */
    3449. 

  3449.     for (i=0; i < size; i++)
    3450. 

  3450.         fimg[i] = 256 * sqrt((double)(image[i][c] << scale));
    3451. 

  3451.     for (hpass=lev=0; lev < 5; lev++) {
    3452. 

  3452.       lpass = size*((lev & 1)+1);
    3453. 

  3453.       for (row=0; row < iheight; row++) {
    3454. 

  3454. 	hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
    3455. 

  3455. 	for (col=0; col < iwidth; col++)
    3456. 

  3456. 	  fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
    3457. 

  3457.       }
    3458. 

  3458.       for (col=0; col < iwidth; col++) {
    3459. 

  3459. 	hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
    3460. 

  3460. 	for (row=0; row < iheight; row++)
    3461. 

  3461. 	  fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
    3462. 

  3462.       }
    3463. 

  3463.       thold = threshold * noise[lev];
    3464. 

  3464.       for (i=0; i < size; i++) {
    3465. 

  3465. 	fimg[hpass+i] -= fimg[lpass+i];
    3466. 

  3466. 	if	(fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
    3467. 

  3467. 	else if (fimg[hpass+i] >  thold) fimg[hpass+i] -= thold;
    3468. 

  3468. 	else	 fimg[hpass+i] = 0;
    3469. 

  3469. 	if (hpass) fimg[i] += fimg[hpass+i];
    3470. 

  3470.       }
    3471. 

  3471.       hpass = lpass;
    3472. 

  3472.     }
    3473. 

  3473.     for (i=0; i < size; i++)
    3474. 

  3474.       image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
    3475. 

  3475.   }
    3476. 

  3476.   if (filters && colors == 3) {  /* pull G1 and G3 closer together */
    3477. 

  3477.     for (row=0; row < 2; row++) {
    3478. 

  3478.       mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
    3479. 

  3479.       blk[row] = cblack[FC(row,0) | 1];
    3480. 

  3480.     }
    3481. 

  3481.     for (i=0; i < 4; i++)
    3482. 

  3482.       window[i] = (ushort *) fimg + width*i;
    3483. 

  3483.     for (wlast=-1, row=1; row < height-1; row++) {
    3484. 

  3484.       while (wlast < row+1) {
    3485. 

  3485. 	for (wlast++, i=0; i < 4; i++)
    3486. 

  3486. 	  window[(i+3) & 3] = window[i];
    3487. 

  3487. 	for (col = FC(wlast,1) & 1; col < width; col+=2)
    3488. 

  3488. 	  window[2][col] = BAYER(wlast,col);
    3489. 

  3489.       }
    3490. 

  3490.       thold = threshold/512;
    3491. 

  3491.       for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
    3492. 

  3492. 	avg = ( window[0][col-1] + window[0][col+1] +
    3493. 

  3493. 		window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
    3494. 

  3494. 	      * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
    3495. 

  3495. 	avg = avg < 0 ? 0 : sqrt(avg);
    3496. 

  3496. 	diff = sqrt((double)(BAYER(row,col))) - avg;
    3497. 

  3497. 	if      (diff < -thold) diff += thold;
    3498. 

  3498. 	else if (diff >  thold) diff -= thold;
    3499. 

  3499. 	else diff = 0;
    3500. 

  3500. 	BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
    3501. 

  3501.       }
    3502. 

  3502.     }
    3503. 

  3503.   }
    3504. 

  3504.   free (fimg);
    3505. 

  3505. }
    3506. 

  3506. #else /* LIBRAW_USE_OPENMP */
    3507. 

  3507. void CLASS wavelet_denoise()
    3508. 

  3508. {
    3509. 

  3509.   float *fimg=0, *temp, thold, mul[2], avg, diff;
    3510. 

  3510.    int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
    3511. 

  3511.   ushort *window[4];
    3512. 

  3512.   static const float noise[] =
    3513. 

  3513.   { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
    3514. 

  3514. 

  3515. #ifdef DCRAW_VERBOSE
    3516. 

  3516.   if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
    3517. 

  3517. #endif
    3518. 

  3518. 

  3519.   while (maximum << scale < 0x10000) scale++;
    3520. 

  3520.   maximum <<= --scale;
    3521. 

  3521.   black <<= scale;
    3522. 

  3522.   FORC4 cblack[c] <<= scale;
    3523. 

  3523.   if ((size = iheight*iwidth) < 0x15550000)
    3524. 

  3524.     fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
    3525. 

  3525.   merror (fimg, "wavelet_denoise()");
    3526. 

  3526.   temp = fimg + size*3;
    3527. 

  3527.   if ((nc = colors) == 3 && filters) nc++;
    3528. 

  3528. #ifdef LIBRAW_LIBRARY_BUILD
    3529. 

  3529. #pragma omp parallel default(shared) private(i,col,row,thold,lev,lpass,hpass,temp,c) firstprivate(scale,size) 
    3530. 

  3530. #endif
    3531. 

  3531.   {
    3532. 

  3532.       temp = (float*)malloc( (iheight + iwidth) * sizeof *fimg);
    3533. 

  3533.     FORC(nc) {			/* denoise R,G1,B,G3 individually */
    3534. 

  3534. #ifdef LIBRAW_LIBRARY_BUILD
    3535. 

  3535. #pragma omp for
    3536. 

  3536. #endif
    3537. 

  3537.       for (i=0; i < size; i++)
    3538. 

  3538.         fimg[i] = 256 * sqrt((double)(image[i][c] << scale));
    3539. 

  3539.       for (hpass=lev=0; lev < 5; lev++) {
    3540. 

  3540. 	lpass = size*((lev & 1)+1);
    3541. 

  3541. #ifdef LIBRAW_LIBRARY_BUILD
    3542. 

  3542. #pragma omp for
    3543. 

  3543. #endif
    3544. 

  3544. 	for (row=0; row < iheight; row++) {
    3545. 

  3545. 	  hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
    3546. 

  3546. 	  for (col=0; col < iwidth; col++)
    3547. 

  3547. 	    fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
    3548. 

  3548. 	}
    3549. 

  3549. #ifdef LIBRAW_LIBRARY_BUILD
    3550. 

  3550. #pragma omp for
    3551. 

  3551. #endif
    3552. 

  3552. 	for (col=0; col < iwidth; col++) {
    3553. 

  3553. 	  hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
    3554. 

  3554. 	  for (row=0; row < iheight; row++)
    3555. 

  3555. 	    fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
    3556. 

  3556. 	}
    3557. 

  3557. 	thold = threshold * noise[lev];
    3558. 

  3558. #ifdef LIBRAW_LIBRARY_BUILD
    3559. 

  3559. #pragma omp for
    3560. 

  3560. #endif
    3561. 

  3561. 	for (i=0; i < size; i++) {
    3562. 

  3562. 	  fimg[hpass+i] -= fimg[lpass+i];
    3563. 

  3563. 	  if	(fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
    3564. 

  3564. 	  else if (fimg[hpass+i] >  thold) fimg[hpass+i] -= thold;
    3565. 

  3565. 	  else	 fimg[hpass+i] = 0;
    3566. 

  3566. 	  if (hpass) fimg[i] += fimg[hpass+i];
    3567. 

  3567. 	}
    3568. 

  3568. 	hpass = lpass;
    3569. 

  3569.       }
    3570. 

  3570. #ifdef LIBRAW_LIBRARY_BUILD
    3571. 

  3571. #pragma omp for
    3572. 

  3572. #endif
    3573. 

  3573.       for (i=0; i < size; i++)
    3574. 

  3574. 	image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
    3575. 

  3575.     }
    3576. 

  3576.     free(temp);
    3577. 

  3577.   } /* end omp parallel */
    3578. 

  3578. /* the following loops are hard to parallize, no idea yes,
    3579. 

  3579.  * problem is wlast which is carrying dependency
    3580. 

  3580.  * second part should be easyer, but did not yet get it right.
    3581. 

  3581.  */
    3582. 

  3582.   if (filters && colors == 3) {  /* pull G1 and G3 closer together */
    3583. 

  3583.    for (row=0; row < 2; row++){
    3584. 

  3584.       mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
    3585. 

  3585.       blk[row] = cblack[FC(row,0) | 1];
    3586. 

  3586.    }
    3587. 

  3587.     for (i=0; i < 4; i++)
    3588. 

  3588.       window[i] = (ushort *) fimg + width*i;
    3589. 

  3589.     for (wlast=-1, row=1; row < height-1; row++) {
    3590. 

  3590.       while (wlast < row+1) {
    3591. 

  3591. 	for (wlast++, i=0; i < 4; i++)
    3592. 

  3592. 	  window[(i+3) & 3] = window[i];
    3593. 

  3593. 	for (col = FC(wlast,1) & 1; col < width; col+=2)
    3594. 

  3594. 	  window[2][col] = BAYER(wlast,col);
    3595. 

  3595.       }
    3596. 

  3596.       thold = threshold/512;
    3597. 

  3597.       for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
    3598. 

  3598. 	avg = ( window[0][col-1] + window[0][col+1] +
    3599. 

  3599. 		window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
    3600. 

  3600. 	      * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
    3601. 

  3601. 	avg = avg < 0 ? 0 : sqrt(avg);
    3602. 

  3602. 	diff = sqrt((double)BAYER(row,col)) - avg;
    3603. 

  3603. 	if      (diff < -thold) diff += thold;
    3604. 

  3604. 	else if (diff >  thold) diff -= thold;
    3605. 

  3605. 	else diff = 0;
    3606. 

  3606. 	BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
    3607. 

  3607.       }
    3608. 

  3608.     }
    3609. 

  3609.   }
    3610. 

  3610.   free (fimg);
    3611. 

  3611. }
    3612. 

  3612. 

  3613. #endif
    3614. 

  3614. 

  3615. 

  3616. 

  3617. // green equilibration
    3618. 

  3618. void CLASS green_matching()
    3619. 

  3619. {
    3620. 

  3620.   int i,j;
    3621. 

  3621.   double m1,m2,c1,c2;
    3622. 

  3622.   int o1_1,o1_2,o1_3,o1_4;
    3623. 

  3623.   int o2_1,o2_2,o2_3,o2_4;
    3624. 

  3624.   ushort (*img)[4];
    3625. 

  3625.   const int margin = 3;
    3626. 

  3626.   int oj = 2, oi = 2;
    3627. 

  3627.   float f;
    3628. 

  3628.   const float thr = 0.01f;
    3629. 

  3629.   if(half_size || shrink) return;
    3630. 

  3630.   if(FC(oj, oi) != 3) oj++;
    3631. 

  3631.   if(FC(oj, oi) != 3) oi++;
    3632. 

  3632.   if(FC(oj, oi) != 3) oj--;
    3633. 

  3633. 

  3634.   img = (ushort (*)[4]) calloc (height*width, sizeof *image);
    3635. 

  3635.   merror (img, "green_matching()");
    3636. 

  3636.   memcpy(img,image,height*width*sizeof *image);
    3637. 

  3637. 

  3638.   for(j=oj;j<height-margin;j+=2)
    3639. 

  3639.     for(i=oi;i<width-margin;i+=2){
    3640. 

  3640.       o1_1=img[(j-1)*width+i-1][1];
    3641. 

  3641.       o1_2=img[(j-1)*width+i+1][1];
    3642. 

  3642.       o1_3=img[(j+1)*width+i-1][1];
    3643. 

  3643.       o1_4=img[(j+1)*width+i+1][1];
    3644. 

  3644.       o2_1=img[(j-2)*width+i][3];
    3645. 

  3645.       o2_2=img[(j+2)*width+i][3];
    3646. 

  3646.       o2_3=img[j*width+i-2][3];
    3647. 

  3647.       o2_4=img[j*width+i+2][3];
    3648. 

  3648. 

  3649.       m1=(o1_1+o1_2+o1_3+o1_4)/4.0;
    3650. 

  3650.       m2=(o2_1+o2_2+o2_3+o2_4)/4.0;
    3651. 

  3651. 

  3652.       c1=(abs(o1_1-o1_2)+abs(o1_1-o1_3)+abs(o1_1-o1_4)+abs(o1_2-o1_3)+abs(o1_3-o1_4)+abs(o1_2-o1_4))/6.0;
    3653. 

  3653.       c2=(abs(o2_1-o2_2)+abs(o2_1-o2_3)+abs(o2_1-o2_4)+abs(o2_2-o2_3)+abs(o2_3-o2_4)+abs(o2_2-o2_4))/6.0;
    3654. 

  3654.       if((img[j*width+i][3]<maximum*0.95)&&(c1<maximum*thr)&&(c2<maximum*thr))
    3655. 

  3655.       {
    3656. 

  3656.         f = image[j*width+i][3]*m1/m2;
    3657. 

  3657.         image[j*width+i][3]=f>0xffff?0xffff:f;
    3658. 

  3658.       }
    3659. 

  3659.     }
    3660. 

  3660.   free(img);
    3661. 

  3661. }
    3662. 

  3662. 

  3663. 

  3664. void CLASS scale_colors()
    3665. 

  3665. {
    3666. 

  3666.   unsigned bottom, right, size, row, col, ur, uc, x, y, c, sum[8];
    3667. 

  3667.   int val, dark, sat,i;
    3668. 

  3668.   double dsum[8], dmin, dmax;
    3669. 

  3669.   float scale_mul[4], fr, fc;
    3670. 

  3670.   ushort *img=0, *pix;
    3671. 

  3671. 

  3672. #ifdef LIBRAW_LIBRARY_BUILD
    3673. 

  3673.   RUN_CALLBACK(LIBRAW_PROGRESS_SCALE_COLORS,0,2);
    3674. 

  3674. #endif
    3675. 

  3675. 

  3676.   FORC4 cblack[c] += black;
    3677. 

  3677.   if (user_mul[0])
    3678. 

  3678.     memcpy (pre_mul, user_mul, sizeof pre_mul);
    3679. 

  3679.   if (use_auto_wb || (use_camera_wb && cam_mul[0] == -1)) {
    3680. 

  3680.     memset (dsum, 0, sizeof dsum);
    3681. 

  3681.     bottom = MIN (greybox[1]+greybox[3], height);
    3682. 

  3682.     right  = MIN (greybox[0]+greybox[2], width);
    3683. 

  3683.     for (row=greybox[1]; row < bottom; row += 8)
    3684. 

  3684.       for (col=greybox[0]; col < right; col += 8) {
    3685. 

  3685. 	memset (sum, 0, sizeof sum);
    3686. 

  3686. 	for (y=row; y < row+8 && y < bottom; y++)
    3687. 

  3687. 	  for (x=col; x < col+8 && x < right; x++)
    3688. 

  3688. 	    FORC4 {
    3689. 

  3689. 	      if (filters) {
    3690. 

  3690. 		c = FC(y,x);
    3691. 

  3691. 		val = BAYER(y,x);
    3692. 

  3692. 	      } else
    3693. 

  3693. 		val = image[y*width+x][c];
    3694. 

  3694. 	      if (val > maximum-25) goto skip_block;
    3695. 

  3695. 	      if ((val -= cblack[c]) < 0) val = 0;
    3696. 

  3696. 	      sum[c] += val;
    3697. 

  3697. 	      sum[c+4]++;
    3698. 

  3698. 	      if (filters) break;
    3699. 

  3699. 	    }
    3700. 

  3700. 	FORC(8) dsum[c] += sum[c];
    3701. 

  3701. skip_block: ;
    3702. 

  3702.       }
    3703. 

  3703.     FORC4 if (dsum[c]) pre_mul[c] = dsum[c+4] / dsum[c];
    3704. 

  3704. #ifdef LIBRAW_LIBRARY_BUILD
    3705. 

  3705.     color_flags.pre_mul_state = LIBRAW_COLORSTATE_CALCULATED;
    3706. 

  3706. #endif
    3707. 

  3707.   }
    3708. 

  3708.   if (use_camera_wb && cam_mul[0] != -1) {
    3709. 

  3709.     memset (sum, 0, sizeof sum);
    3710. 

  3710.     for (row=0; row < 8; row++)
    3711. 

  3711.       for (col=0; col < 8; col++) {
    3712. 

  3712. 	c = FC(row,col);
    3713. 

  3713. 	if ((val = white[row][col] - cblack[c]) > 0)
    3714. 

  3714. 	  sum[c] += val;
    3715. 

  3715. 	sum[c+4]++;
    3716. 

  3716.       }
    3717. 

  3717.     if (sum[0] && sum[1] && sum[2] && sum[3])
    3718. 

  3718.         {
    3719. 

  3719.             FORC4 pre_mul[c] = (float) sum[c+4] / sum[c];
    3720. 

  3720. #ifdef LIBRAW_LIBRARY_BUILD
    3721. 

  3721.             color_flags.pre_mul_state = LIBRAW_COLORSTATE_CALCULATED;
    3722. 

  3722. #endif
    3723. 

  3723.         }
    3724. 

  3724.     else if (cam_mul[0] && cam_mul[2])
    3725. 

  3725.         {
    3726. 

  3726.             memcpy (pre_mul, cam_mul, sizeof pre_mul);
    3727. 

  3727. #ifdef LIBRAW_LIBRARY_BUILD
    3728. 

  3728.             color_flags.pre_mul_state =color_flags.pre_mul_state;
    3729. 

  3729. #endif
    3730. 

  3730.         }
    3731. 

  3731.     else
    3732. 

  3732.         {
    3733. 

  3733. #ifdef LIBRAW_LIBRARY_BUILD
    3734. 

  3734.             imgdata.process_warnings |= LIBRAW_WARN_BAD_CAMERA_WB;
    3735. 

  3735. #endif
    3736. 

  3736. #ifdef DCRAW_VERBOSE
    3737. 

  3737.             fprintf (stderr,_("%s: Cannot use camera white balance.\n"), ifname);
    3738. 

  3738. #endif
    3739. 

  3739.         }
    3740. 

  3740.   }
    3741. 

  3741.   if (pre_mul[3] == 0) pre_mul[3] = colors < 4 ? pre_mul[1] : 1;
    3742. 

  3742.   dark = black;
    3743. 

  3743.   sat = maximum;
    3744. 

  3744.   if (threshold) wavelet_denoise();
    3745. 

  3745.   maximum -= black;
    3746. 

  3746.   for (dmin=DBL_MAX, dmax=c=0; c < 4; c++) {
    3747. 

  3747.     if (dmin > pre_mul[c])
    3748. 

  3748. 	dmin = pre_mul[c];
    3749. 

  3749.     if (dmax < pre_mul[c])
    3750. 

  3750. 	dmax = pre_mul[c];
    3751. 

  3751.   }
    3752. 

  3752.   if (!highlight) dmax = dmin;
    3753. 

  3753.   FORC4 scale_mul[c] = (pre_mul[c] /= dmax) * 65535.0 / maximum;
    3754. 

  3754. #ifdef DCRAW_VERBOSE
    3755. 

  3755.   if (verbose) {
    3756. 

  3756.     fprintf (stderr,
    3757. 

  3757.       _("Scaling with darkness %d, saturation %d, and\nmultipliers"), dark, sat);
    3758. 

  3758.     FORC4 fprintf (stderr, " %f", pre_mul[c]);
    3759. 

  3759.     fputc ('\n', stderr);
    3760. 

  3760.   }
    3761. 

  3761. #endif
    3762. 

  3762. 

  3763.   size = iheight*iwidth;
    3764. 

  3764. #if defined(LIBRAW_USE_OPENMP)
    3765. 

  3765. #pragma omp parallel for private(val) default(shared)
    3766. 

  3766. #endif
    3767. 

  3767.   for (i=0; i < size*4; i++) {
    3768. 

  3768.     val = image[0][i];
    3769. 

  3769.     if (!val) continue;
    3770. 

  3770.     val -= cblack[i & 3];
    3771. 

  3771.     val *= scale_mul[i & 3];
    3772. 

  3772.     image[0][i] = CLIP(val);
    3773. 

  3773.   }
    3774. 

  3774.   if ((aber[0] != 1 || aber[2] != 1) && colors == 3) {
    3775. 

  3775. #ifdef DCRAW_VERBOSE
    3776. 

  3776.     if (verbose)
    3777. 

  3777.       fprintf (stderr,_("Correcting chromatic aberration...\n"));
    3778. 

  3778. #endif
    3779. 

  3779.     for (c=0; c < 4; c+=2) {
    3780. 

  3780.       if (aber[c] == 1) continue;
    3781. 

  3781.       img = (ushort *) malloc (size * sizeof *img);
    3782. 

  3782.       merror (img, "scale_colors()");
    3783. 

  3783.       for (i=0; i < size; i++)
    3784. 

  3784. 	img[i] = image[i][c];
    3785. 

  3785.       for (row=0; row < iheight; row++) {
    3786. 

  3786. 	ur = fr = (row - iheight*0.5) * aber[c] + iheight*0.5;
    3787. 

  3787. 	if (ur > iheight-2) continue;
    3788. 

  3788. 	fr -= ur;
    3789. 

  3789. 	for (col=0; col < iwidth; col++) {
    3790. 

  3790. 	  uc = fc = (col - iwidth*0.5) * aber[c] + iwidth*0.5;
    3791. 

  3791. 	  if (uc > iwidth-2) continue;
    3792. 

  3792. 	  fc -= uc;
    3793. 

  3793. 	  pix = img + ur*iwidth + uc;
    3794. 

  3794. 	  image[row*iwidth+col][c] =
    3795. 

  3795. 	    (pix[     0]*(1-fc) + pix[       1]*fc) * (1-fr) +
    3796. 

  3796. 	    (pix[iwidth]*(1-fc) + pix[iwidth+1]*fc) * fr;
    3797. 

  3797. 	}
    3798. 

  3798.       }
    3799. 

  3799.       free(img);
    3800. 

  3800.     }
    3801. 

  3801.   }
    3802. 

  3802. #ifdef LIBRAW_LIBRARY_BUILD
    3803. 

  3803.   RUN_CALLBACK(LIBRAW_PROGRESS_SCALE_COLORS,1,2);
    3804. 

  3804. #endif
    3805. 

  3805. }
    3806. 

  3806. 

  3807. void CLASS pre_interpolate()
    3808. 

  3808. {
    3809. 

  3809.   ushort (*img)[4];
    3810. 

  3810.   int row, col, c;
    3811. 

  3811. 

  3812. #ifdef LIBRAW_LIBRARY_BUILD
    3813. 

  3813.   RUN_CALLBACK(LIBRAW_PROGRESS_PRE_INTERPOLATE,0,2);
    3814. 

  3814. #endif
    3815. 

  3815.   if (shrink) {
    3816. 

  3816.     if (half_size) {
    3817. 

  3817.       height = iheight;
    3818. 

  3818.       width  = iwidth;
    3819. 

  3819.     } else {
    3820. 

  3820.       img = (ushort (*)[4]) calloc (height*width, sizeof *img);
    3821. 

  3821.       merror (img, "pre_interpolate()");
    3822. 

  3822.       for (row=0; row < height; row++)
    3823. 

  3823. 	for (col=0; col < width; col++) {
    3824. 

  3824. 	  c = fc(row,col);
    3825. 

  3825. 	  img[row*width+col][c] = image[(row >> 1)*iwidth+(col >> 1)][c];
    3826. 

  3826. 	}
    3827. 

  3827.       free (image);
    3828. 

  3828.       image = img;
    3829. 

  3829.       shrink = 0;
    3830. 

  3830.     }
    3831. 

  3831.   }
    3832. 

  3832.   if (filters && colors == 3) {
    3833. 

  3833.     if (four_color_rgb && colors++)
    3834. 

  3834.       mix_green = !half_size;
    3835. 

  3835.     else {
    3836. 

  3836.       for (row = FC(1,0) >> 1; row < height; row+=2)
    3837. 

  3837. 	for (col = FC(row,1) & 1; col < width; col+=2)
    3838. 

  3838. 	  image[row*width+col][1] = image[row*width+col][3];
    3839. 

  3839.       filters &= ~((filters & 0x55555555) << 1);
    3840. 

  3840.     }
    3841. 

  3841.   }
    3842. 

  3842.   if (half_size) filters = 0;
    3843. 

  3843. #ifdef LIBRAW_LIBRARY_BUILD
    3844. 

  3844.   RUN_CALLBACK(LIBRAW_PROGRESS_PRE_INTERPOLATE,1,2);
    3845. 

  3845. #endif
    3846. 

  3846. }
    3847. 

  3847. 

  3848. void CLASS border_interpolate (int border)
    3849. 

  3849. {
    3850. 

  3850.   unsigned row, col, y, x, f, c, sum[8];
    3851. 

  3851. 

  3852.   for (row=0; row < height; row++)
    3853. 

  3853.     for (col=0; col < width; col++) {
    3854. 

  3854.       if (col==border && row >= border && row < height-border)
    3855. 

  3855. 	col = width-border;
    3856. 

  3856.       memset (sum, 0, sizeof sum);
    3857. 

  3857.       for (y=row-1; y != row+2; y++)
    3858. 

  3858. 	for (x=col-1; x != col+2; x++)
    3859. 

  3859. 	  if (y < height && x < width) {
    3860. 

  3860. 	    f = fc(y,x);
    3861. 

  3861. 	    sum[f] += image[y*width+x][f];
    3862. 

  3862. 	    sum[f+4]++;
    3863. 

  3863. 	  }
    3864. 

  3864.       f = fc(row,col);
    3865. 

  3865.       FORCC if (c != f && sum[c+4])
    3866. 

  3866. 	image[row*width+col][c] = sum[c] / sum[c+4];
    3867. 

  3867.     }
    3868. 

  3868. }
    3869. 

  3869. 

  3870. void CLASS lin_interpolate()
    3871. 

  3871. {
    3872. 

  3872.   int code[16][16][32], *ip, sum[4];
    3873. 

  3873.   int c, i, x, y, row, col, shift, color;
    3874. 

  3874.   ushort *pix;
    3875. 

  3875. 

  3876. #ifdef DCRAW_VERBOSE
    3877. 

  3877.   if (verbose) fprintf (stderr,_("Bilinear interpolation...\n"));
    3878. 

  3878. #endif
    3879. 

  3879. 

  3880. #ifdef LIBRAW_LIBRARY_BUILD
    3881. 

  3881.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,0,3);
    3882. 

  3882. #endif
    3883. 

  3883.   border_interpolate(1);
    3884. 

  3884.   for (row=0; row < 16; row++)
    3885. 

  3885.     for (col=0; col < 16; col++) {
    3886. 

  3886.       ip = code[row][col];
    3887. 

  3887.       memset (sum, 0, sizeof sum);
    3888. 

  3888.       for (y=-1; y <= 1; y++)
    3889. 

  3889. 	for (x=-1; x <= 1; x++) {
    3890. 

  3890. 	  shift = (y==0) + (x==0);
    3891. 

  3891. 	  if (shift == 2) continue;
    3892. 

  3892. 	  color = fc(row+y,col+x);
    3893. 

  3893. 	  *ip++ = (width*y + x)*4 + color;
    3894. 

  3894. 	  *ip++ = shift;
    3895. 

  3895. 	  *ip++ = color;
    3896. 

  3896. 	  sum[color] += 1 << shift;
    3897. 

  3897. 	}
    3898. 

  3898.       FORCC
    3899. 

  3899. 	if (c != fc(row,col)) {
    3900. 

  3900. 	  *ip++ = c;
    3901. 

  3901. 	  *ip++ = 256 / sum[c];
    3902. 

  3902. 	}
    3903. 

  3903.     }
    3904. 

  3904. #ifdef LIBRAW_LIBRARY_BUILD
    3905. 

  3905.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,1,3);
    3906. 

  3906. #endif
    3907. 

  3907.   for (row=1; row < height-1; row++)
    3908. 

  3908.     for (col=1; col < width-1; col++) {
    3909. 

  3909.       pix = image[row*width+col];
    3910. 

  3910.       ip = code[row & 15][col & 15];
    3911. 

  3911.       memset (sum, 0, sizeof sum);
    3912. 

  3912.       for (i=8; i--; ip+=3)
    3913. 

  3913. 	sum[ip[2]] += pix[ip[0]] << ip[1];
    3914. 

  3914.       for (i=colors; --i; ip+=2)
    3915. 

  3915. 	pix[ip[0]] = sum[ip[0]] * ip[1] >> 8;
    3916. 

  3916.     }
    3917. 

  3917. #ifdef LIBRAW_LIBRARY_BUILD
    3918. 

  3918.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,2,3);
    3919. 

  3919. #endif
    3920. 

  3920. }
    3921. 

  3921. 

  3922. /*
    3923. 

  3923.    This algorithm is officially called:
    3924. 

    3925. 

  3925.    "Interpolation using a Threshold-based variable number of gradients"
    3926. 

    3927. 

  3927.    described in http://scien.stanford.edu/pages/labsite/1999/psych221/projects/99/tingchen/algodep/vargra.html
    3928. 

    3929. 

  3929.    I've extended the basic idea to work with non-Bayer filter arrays.
    3930. 

  3930.    Gradients are numbered clockwise from NW=0 to W=7.
    3931. 

  3931.  */
    3932. 

  3932. void CLASS vng_interpolate()
    3933. 

  3933. {
    3934. 

  3934.   static const signed short *cp, terms[] = {
    3935. 

  3935.     -2,-2,+0,-1,0,0x01, -2,-2,+0,+0,1,0x01, -2,-1,-1,+0,0,0x01,
    3936. 

  3936.     -2,-1,+0,-1,0,0x02, -2,-1,+0,+0,0,0x03, -2,-1,+0,+1,1,0x01,
    3937. 

  3937.     -2,+0,+0,-1,0,0x06, -2,+0,+0,+0,1,0x02, -2,+0,+0,+1,0,0x03,
    3938. 

  3938.     -2,+1,-1,+0,0,0x04, -2,+1,+0,-1,1,0x04, -2,+1,+0,+0,0,0x06,
    3939. 

  3939.     -2,+1,+0,+1,0,0x02, -2,+2,+0,+0,1,0x04, -2,+2,+0,+1,0,0x04,
    3940. 

  3940.     -1,-2,-1,+0,0,0x80, -1,-2,+0,-1,0,0x01, -1,-2,+1,-1,0,0x01,
    3941. 

  3941.     -1,-2,+1,+0,1,0x01, -1,-1,-1,+1,0,0x88, -1,-1,+1,-2,0,0x40,
    3942. 

  3942.     -1,-1,+1,-1,0,0x22, -1,-1,+1,+0,0,0x33, -1,-1,+1,+1,1,0x11,
    3943. 

  3943.     -1,+0,-1,+2,0,0x08, -1,+0,+0,-1,0,0x44, -1,+0,+0,+1,0,0x11,
    3944. 

  3944.     -1,+0,+1,-2,1,0x40, -1,+0,+1,-1,0,0x66, -1,+0,+1,+0,1,0x22,
    3945. 

  3945.     -1,+0,+1,+1,0,0x33, -1,+0,+1,+2,1,0x10, -1,+1,+1,-1,1,0x44,
    3946. 

  3946.     -1,+1,+1,+0,0,0x66, -1,+1,+1,+1,0,0x22, -1,+1,+1,+2,0,0x10,
    3947. 

  3947.     -1,+2,+0,+1,0,0x04, -1,+2,+1,+0,1,0x04, -1,+2,+1,+1,0,0x04,
    3948. 

  3948.     +0,-2,+0,+0,1,0x80, +0,-1,+0,+1,1,0x88, +0,-1,+1,-2,0,0x40,
    3949. 

  3949.     +0,-1,+1,+0,0,0x11, +0,-1,+2,-2,0,0x40, +0,-1,+2,-1,0,0x20,
    3950. 

  3950.     +0,-1,+2,+0,0,0x30, +0,-1,+2,+1,1,0x10, +0,+0,+0,+2,1,0x08,
    3951. 

  3951.     +0,+0,+2,-2,1,0x40, +0,+0,+2,-1,0,0x60, +0,+0,+2,+0,1,0x20,
    3952. 

  3952.     +0,+0,+2,+1,0,0x30, +0,+0,+2,+2,1,0x10, +0,+1,+1,+0,0,0x44,
    3953. 

  3953.     +0,+1,+1,+2,0,0x10, +0,+1,+2,-1,1,0x40, +0,+1,+2,+0,0,0x60,
    3954. 

  3954.     +0,+1,+2,+1,0,0x20, +0,+1,+2,+2,0,0x10, +1,-2,+1,+0,0,0x80,
    3955. 

  3955.     +1,-1,+1,+1,0,0x88, +1,+0,+1,+2,0,0x08, +1,+0,+2,-1,0,0x40,
    3956. 

  3956.     +1,+0,+2,+1,0,0x10
    3957. 

  3957.   }, chood[] = { -1,-1, -1,0, -1,+1, 0,+1, +1,+1, +1,0, +1,-1, 0,-1 };
    3958. 

  3958.   ushort (*brow[5])[4], *pix;
    3959. 

  3959.   int prow=7, pcol=1, *ip, *code[16][16], gval[8], gmin, gmax, sum[4];
    3960. 

  3960.   int row, col, x, y, x1, x2, y1, y2, t, weight, grads, color, diag;
    3961. 

  3961.   int g, diff, thold, num, c;
    3962. 

  3962.   lin_interpolate();
    3963. 

  3963. #ifdef DCRAW_VERBOSE
    3964. 

  3964.   if (verbose) fprintf (stderr,_("VNG interpolation...\n"));
    3965. 

  3965. #endif
    3966. 

  3966. 

  3967.   if (filters == 1) prow = pcol = 15;
    3968. 

  3968.   ip = (int *) calloc ((prow+1)*(pcol+1), 1280);
    3969. 

  3969.   merror (ip, "vng_interpolate()");
    3970. 

  3970.   for (row=0; row <= prow; row++)		/* Precalculate for VNG */
    3971. 

  3971.     for (col=0; col <= pcol; col++) {
    3972. 

  3972.       code[row][col] = ip;
    3973. 

  3973.       for (cp=terms, t=0; t < 64; t++) {
    3974. 

  3974. 	y1 = *cp++;  x1 = *cp++;
    3975. 

  3975. 	y2 = *cp++;  x2 = *cp++;
    3976. 

  3976. 	weight = *cp++;
    3977. 

  3977. 	grads = *cp++;
    3978. 

  3978. 	color = fc(row+y1,col+x1);
    3979. 

  3979. 	if (fc(row+y2,col+x2) != color) continue;
    3980. 

  3980. 	diag = (fc(row,col+1) == color && fc(row+1,col) == color) ? 2:1;
    3981. 

  3981. 	if (abs(y1-y2) == diag && abs(x1-x2) == diag) continue;
    3982. 

  3982. 	*ip++ = (y1*width + x1)*4 + color;
    3983. 

  3983. 	*ip++ = (y2*width + x2)*4 + color;
    3984. 

  3984. 	*ip++ = weight;
    3985. 

  3985. 	for (g=0; g < 8; g++)
    3986. 

  3986. 	  if (grads & 1<<g) *ip++ = g;
    3987. 

  3987. 	*ip++ = -1;
    3988. 

  3988.       }
    3989. 

  3989.       *ip++ = INT_MAX;
    3990. 

  3990.       for (cp=chood, g=0; g < 8; g++) {
    3991. 

  3991. 	y = *cp++;  x = *cp++;
    3992. 

  3992. 	*ip++ = (y*width + x) * 4;
    3993. 

  3993. 	color = fc(row,col);
    3994. 

  3994. 	if (fc(row+y,col+x) != color && fc(row+y*2,col+x*2) == color)
    3995. 

  3995. 	  *ip++ = (y*width + x) * 8 + color;
    3996. 

  3996. 	else
    3997. 

  3997. 	  *ip++ = 0;
    3998. 

  3998.       }
    3999. 

  3999.     }
    4000. 

  4000.   brow[4] = (ushort (*)[4]) calloc (width*3, sizeof **brow);
    4001. 

  4001.   merror (brow[4], "vng_interpolate()");
    4002. 

  4002.   for (row=0; row < 3; row++)
    4003. 

  4003.     brow[row] = brow[4] + row*width;
    4004. 

  4004.   for (row=2; row < height-2; row++) {		/* Do VNG interpolation */
    4005. 

  4005. #ifdef LIBRAW_LIBRARY_BUILD
    4006. 

  4006.       if(!((row-2)%256))RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,(row-2)/256+1,((height-3)/256)+1);
    4007. 

  4007. #endif
    4008. 

  4008.     for (col=2; col < width-2; col++) {
    4009. 

  4009.       pix = image[row*width+col];
    4010. 

  4010.       ip = code[row & prow][col & pcol];
    4011. 

  4011.       memset (gval, 0, sizeof gval);
    4012. 

  4012.       while ((g = ip[0]) != INT_MAX) {		/* Calculate gradients */
    4013. 

  4013. 	diff = ABS(pix[g] - pix[ip[1]]) << ip[2];
    4014. 

  4014. 	gval[ip[3]] += diff;
    4015. 

  4015. 	ip += 5;
    4016. 

  4016. 	if ((g = ip[-1]) == -1) continue;
    4017. 

  4017. 	gval[g] += diff;
    4018. 

  4018. 	while ((g = *ip++) != -1)
    4019. 

  4019. 	  gval[g] += diff;
    4020. 

  4020.       }
    4021. 

  4021.       ip++;
    4022. 

  4022.       gmin = gmax = gval[0];			/* Choose a threshold */
    4023. 

  4023.       for (g=1; g < 8; g++) {
    4024. 

  4024. 	if (gmin > gval[g]) gmin = gval[g];
    4025. 

  4025. 	if (gmax < gval[g]) gmax = gval[g];
    4026. 

  4026.       }
    4027. 

  4027.       if (gmax == 0) {
    4028. 

  4028. 	memcpy (brow[2][col], pix, sizeof *image);
    4029. 

  4029. 	continue;
    4030. 

  4030.       }
    4031. 

  4031.       thold = gmin + (gmax >> 1);
    4032. 

  4032.       memset (sum, 0, sizeof sum);
    4033. 

  4033.       color = fc(row,col);
    4034. 

  4034.       for (num=g=0; g < 8; g++,ip+=2) {		/* Average the neighbors */
    4035. 

  4035. 	if (gval[g] <= thold) {
    4036. 

  4036. 	  FORCC
    4037. 

  4037. 	    if (c == color && ip[1])
    4038. 

  4038. 	      sum[c] += (pix[c] + pix[ip[1]]) >> 1;
    4039. 

  4039. 	    else
    4040. 

  4040. 	      sum[c] += pix[ip[0] + c];
    4041. 

  4041. 	  num++;
    4042. 

  4042. 	}
    4043. 

  4043.       }
    4044. 

  4044.       FORCC {					/* Save to buffer */
    4045. 

  4045. 	t = pix[color];
    4046. 

  4046. 	if (c != color)
    4047. 

  4047. 	  t += (sum[c] - sum[color]) / num;
    4048. 

  4048. 	brow[2][col][c] = CLIP(t);
    4049. 

  4049.       }
    4050. 

  4050.     }
    4051. 

  4051.     if (row > 3)				/* Write buffer to image */
    4052. 

  4052.       memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image);
    4053. 

  4053.     for (g=0; g < 4; g++)
    4054. 

  4054.       brow[(g-1) & 3] = brow[g];
    4055. 

  4055.   }
    4056. 

  4056.   memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image);
    4057. 

  4057.   memcpy (image[(row-1)*width+2], brow[1]+2, (width-4)*sizeof *image);
    4058. 

  4058.   free (brow[4]);
    4059. 

  4059.   free (code[0][0]);
    4060. 

  4060. }
    4061. 

  4061. 

  4062. /*
    4063. 

  4063.    Patterned Pixel Grouping Interpolation by Alain Desbiolles
    4064. 

  4064. */
    4065. 

  4065. void CLASS ppg_interpolate()
    4066. 

  4066. {
    4067. 

  4067.   int dir[5] = { 1, width, -1, -width, 1 };
    4068. 

  4068.   int row, col, diff[2], guess[2], c, d, i;
    4069. 

  4069.   ushort (*pix)[4];
    4070. 

  4070. 

  4071.   border_interpolate(3);
    4072. 

  4072. #ifdef DCRAW_VERBOSE
    4073. 

  4073.   if (verbose) fprintf (stderr,_("PPG interpolation...\n"));
    4074. 

  4074. #endif
    4075. 

  4075. 

  4076. /*  Fill in the green layer with gradients and pattern recognition: */
    4077. 

  4077. #ifdef LIBRAW_LIBRARY_BUILD
    4078. 

  4078.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,0,3);
    4079. 

  4079. #ifdef LIBRAW_USE_OPENMP
    4080. 

  4080. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    4081. 

  4081. #endif
    4082. 

  4082. #endif
    4083. 

  4083.   for (row=3; row < height-3; row++)
    4084. 

  4084.     for (col=3+(FC(row,3) & 1), c=FC(row,col); col < width-3; col+=2) {
    4085. 

  4085.       pix = image + row*width+col;
    4086. 

  4086.       for (i=0; (d=dir[i]) > 0; i++) {
    4087. 

  4087. 	guess[i] = (pix[-d][1] + pix[0][c] + pix[d][1]) * 2
    4088. 

  4088. 		      - pix[-2*d][c] - pix[2*d][c];
    4089. 

  4089. 	diff[i] = ( ABS(pix[-2*d][c] - pix[ 0][c]) +
    4090. 

  4090. 		    ABS(pix[ 2*d][c] - pix[ 0][c]) +
    4091. 

  4091. 		    ABS(pix[  -d][1] - pix[ d][1]) ) * 3 +
    4092. 

  4092. 		  ( ABS(pix[ 3*d][1] - pix[ d][1]) +
    4093. 

  4093. 		    ABS(pix[-3*d][1] - pix[-d][1]) ) * 2;
    4094. 

  4094.       }
    4095. 

  4095.       d = dir[i = diff[0] > diff[1]];
    4096. 

  4096.       pix[0][1] = ULIM(guess[i] >> 2, pix[d][1], pix[-d][1]);
    4097. 

  4097.     }
    4098. 

  4098. /*  Calculate red and blue for each green pixel:		*/
    4099. 

  4099. #ifdef LIBRAW_LIBRARY_BUILD
    4100. 

  4100.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,1,3);
    4101. 

  4101. #ifdef LIBRAW_USE_OPENMP
    4102. 

  4102. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    4103. 

  4103. #endif
    4104. 

  4104. #endif
    4105. 

  4105.   for (row=1; row < height-1; row++)
    4106. 

  4106.     for (col=1+(FC(row,2) & 1), c=FC(row,col+1); col < width-1; col+=2) {
    4107. 

  4107.       pix = image + row*width+col;
    4108. 

  4108.       for (i=0; (d=dir[i]) > 0; c=2-c, i++)
    4109. 

  4109. 	pix[0][c] = CLIP((pix[-d][c] + pix[d][c] + 2*pix[0][1]
    4110. 

  4110. 			- pix[-d][1] - pix[d][1]) >> 1);
    4111. 

  4111.     }
    4112. 

  4112. /*  Calculate blue for red pixels and vice versa:		*/
    4113. 

  4113. #ifdef LIBRAW_LIBRARY_BUILD
    4114. 

  4114.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,2,3);
    4115. 

  4115. #ifdef LIBRAW_USE_OPENMP
    4116. 

  4116. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    4117. 

  4117. #endif
    4118. 

  4118. #endif
    4119. 

  4119.   for (row=1; row < height-1; row++)
    4120. 

  4120.     for (col=1+(FC(row,1) & 1), c=2-FC(row,col); col < width-1; col+=2) {
    4121. 

  4121.       pix = image + row*width+col;
    4122. 

  4122.       for (i=0; (d=dir[i]+dir[i+1]) > 0; i++) {
    4123. 

  4123. 	diff[i] = ABS(pix[-d][c] - pix[d][c]) +
    4124. 

  4124. 		  ABS(pix[-d][1] - pix[0][1]) +
    4125. 

  4125. 		  ABS(pix[ d][1] - pix[0][1]);
    4126. 

  4126. 	guess[i] = pix[-d][c] + pix[d][c] + 2*pix[0][1]
    4127. 

  4127. 		 - pix[-d][1] - pix[d][1];
    4128. 

  4128.       }
    4129. 

  4129.       if (diff[0] != diff[1])
    4130. 

  4130. 	pix[0][c] = CLIP(guess[diff[0] > diff[1]] >> 1);
    4131. 

  4131.       else
    4132. 

  4132. 	pix[0][c] = CLIP((guess[0]+guess[1]) >> 2);
    4133. 

  4133.     }
    4134. 

  4134. }
    4135. 

  4135. 

  4136. /*
    4137. 

  4137.    Adaptive Homogeneity-Directed interpolation is based on
    4138. 

  4138.    the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
    4139. 

  4139.  */
    4140. 

  4140. #define TS 256		/* Tile Size */
    4141. 

  4141. static float dcraw_cbrt[0x10000] = {-1.0f};
    4142. 

  4142. 

  4143. static inline float calc_64cbrt(float f)
    4144. 

  4144. {
    4145. 

  4145.   unsigned u;
    4146. 

  4146.   static float lower = dcraw_cbrt[0];
    4147. 

  4147.   static float upper = dcraw_cbrt[0xffff];
    4148. 

  4148. 

  4149.   if (f <= 0) {
    4150. 

  4150.     return lower;
    4151. 

  4151.   }
    4152. 

  4152. 

  4153.   u = (unsigned) f;
    4154. 

  4154.   if (u >= 0xffff) {
    4155. 

  4155.     return upper;
    4156. 

  4156.   }
    4157. 

  4157.   return dcraw_cbrt[u];
    4158. 

  4158. }
    4159. 

  4159. void CLASS ahd_interpolate_green_h_and_v(int top, int left, ushort (*out_rgb)[TS][TS][3])
    4160. 

  4160. {
    4161. 

  4161.   int row, col;
    4162. 

  4162.   int c, val;
    4163. 

  4163.   ushort (*pix)[4];
    4164. 

  4164.   const int rowlimit = MIN(top+TS, height-2);
    4165. 

  4165.   const int collimit = MIN(left+TS, width-2);
    4166. 

  4166. 

  4167.   for (row = top; row < rowlimit; row++) {
    4168. 

  4168.     col = left + (FC(row,left) & 1);
    4169. 

  4169.     for (c = FC(row,col); col < collimit; col+=2) {
    4170. 

  4170.       pix = image + row*width+col;
    4171. 

  4171.       val = ((pix[-1][1] + pix[0][c] + pix[1][1]) * 2
    4172. 

  4172.             - pix[-2][c] - pix[2][c]) >> 2;
    4173. 

  4173.       out_rgb[0][row-top][col-left][1] = ULIM(val,pix[-1][1],pix[1][1]);
    4174. 

  4174.       val = ((pix[-width][1] + pix[0][c] + pix[width][1]) * 2
    4175. 

  4175.             - pix[-2*width][c] - pix[2*width][c]) >> 2;
    4176. 

  4176.       out_rgb[1][row-top][col-left][1] = ULIM(val,pix[-width][1],pix[width][1]);
    4177. 

  4177.     }
    4178. 

  4178.   }
    4179. 

  4179. }
    4180. 

  4180. void CLASS ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(int top, int left, ushort (*inout_rgb)[TS][3], short (*out_lab)[TS][3], const float (&xyz_cam)[3][4])
    4181. 

  4181. {
    4182. 

  4182.   unsigned row, col;
    4183. 

  4183.   int c, val;
    4184. 

  4184.   ushort (*pix)[4];
    4185. 

  4185.   ushort (*rix)[3];
    4186. 

  4186.   short (*lix)[3];
    4187. 

  4187.   float xyz[3];
    4188. 

  4188.   const unsigned num_pix_per_row = 4*width;
    4189. 

  4189.   const unsigned rowlimit = MIN(top+TS-1, height-3);
    4190. 

  4190.   const unsigned collimit = MIN(left+TS-1, width-3);
    4191. 

  4191.   ushort *pix_above;
    4192. 

  4192.   ushort *pix_below;
    4193. 

  4193.   int t1, t2;
    4194. 

  4194. 

  4195.   for (row = top+1; row < rowlimit; row++) {
    4196. 

  4196.     pix = image + row*width + left;
    4197. 

  4197.     rix = &inout_rgb[row-top][0];
    4198. 

  4198.     lix = &out_lab[row-top][0];
    4199. 

  4199. 

  4200.     for (col = left+1; col < collimit; col++) {
    4201. 

  4201.       pix++;
    4202. 

  4202.       pix_above = &pix[0][0] - num_pix_per_row;
    4203. 

  4203.       pix_below = &pix[0][0] + num_pix_per_row;
    4204. 

  4204.       rix++;
    4205. 

  4205.       lix++;
    4206. 

  4206. 

  4207.       c = 2 - FC(row, col);
    4208. 

  4208. 

  4209.       if (c == 1) {
    4210. 

  4210.         c = FC(row+1,col);
    4211. 

  4211. 	t1 = 2-c;
    4212. 

  4212.         val = pix[0][1] + (( pix[-1][t1] + pix[1][t1]
    4213. 

  4213.               - rix[-1][1] - rix[1][1] ) >> 1);
    4214. 

  4214.         rix[0][t1] = CLIP(val);
    4215. 

  4215.         val = pix[0][1] + (( pix_above[c] + pix_below[c]
    4216. 

  4216.               - rix[-TS][1] - rix[TS][1] ) >> 1);
    4217. 

  4217.       } else {
    4218. 

  4218. 	t1 = -4+c; /* -4+c: pixel of color c to the left */
    4219. 

  4219. 	t2 = 4+c; /* 4+c: pixel of color c to the right */
    4220. 

  4220.         val = rix[0][1] + (( pix_above[t1] + pix_above[t2]
    4221. 

  4221.               + pix_below[t1] + pix_below[t2]
    4222. 

  4222.               - rix[-TS-1][1] - rix[-TS+1][1]
    4223. 

  4223.               - rix[+TS-1][1] - rix[+TS+1][1] + 1) >> 2);
    4224. 

  4224.       }
    4225. 

  4225.       rix[0][c] = CLIP(val);
    4226. 

  4226.       c = FC(row,col);
    4227. 

  4227.       rix[0][c] = pix[0][c];
    4228. 

  4228.       xyz[0] = xyz[1] = xyz[2] = 0.5;
    4229. 

  4229.       FORC3 {
    4230. 

  4230. 	/*
    4231. 

  4231. 	 * Technically this ought to be FORCC, but the rest of
    4232. 

  4232. 	 * ahd_interpolate() assumes 3 colors so let's help the compiler.
    4233. 

  4233. 	 */
    4234. 

  4234.         xyz[0] += xyz_cam[0][c] * rix[0][c];
    4235. 

  4235.         xyz[1] += xyz_cam[1][c] * rix[0][c];
    4236. 

  4236.         xyz[2] += xyz_cam[2][c] * rix[0][c];
    4237. 

  4237.       }
    4238. 

  4238.       FORC3 {
    4239. 

  4239. 	xyz[c] = calc_64cbrt(xyz[c]);
    4240. 

  4240.       }
    4241. 

  4241.       lix[0][0] = (116 * xyz[1] - 16);
    4242. 

  4242.       lix[0][1] = 500 * (xyz[0] - xyz[1]);
    4243. 

  4243.       lix[0][2] = 200 * (xyz[1] - xyz[2]);
    4244. 

  4244.     }
    4245. 

  4245.   }
    4246. 

  4246. }
    4247. 

  4247. void CLASS ahd_interpolate_r_and_b_and_convert_to_cielab(int top, int left, ushort (*inout_rgb)[TS][TS][3], short (*out_lab)[TS][TS][3], const float (&xyz_cam)[3][4])
    4248. 

  4248. {
    4249. 

  4249.   int direction;
    4250. 

  4250.   for (direction = 0; direction < 2; direction++) {
    4251. 

  4251.     ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(top, left, inout_rgb[direction], out_lab[direction], xyz_cam);
    4252. 

  4252.   }
    4253. 

  4253. }
    4254. 

  4254. void CLASS ahd_interpolate_build_homogeneity_map(int top, int left, short (*lab)[TS][TS][3], char (*out_homogeneity_map)[TS][2])
    4255. 

  4255. {
    4256. 

  4256.   int row, col;
    4257. 

  4257.   int tr, tc;
    4258. 

  4258.   int direction;
    4259. 

  4259.   int i;
    4260. 

  4260.   short (*lix)[3];
    4261. 

  4261.   short (*lixs[2])[3];
    4262. 

  4262.   short *adjacent_lix;
    4263. 

  4263.   unsigned ldiff[2][4], abdiff[2][4], leps, abeps;
    4264. 

  4264.   static const int dir[4] = { -1, 1, -TS, TS };
    4265. 

  4265.   const int rowlimit = MIN(top+TS-2, height-4);
    4266. 

  4266.   const int collimit = MIN(left+TS-2, width-4);
    4267. 

  4267.   int homogeneity;
    4268. 

  4268.   char (*homogeneity_map_p)[2];
    4269. 

  4269. 

  4270.   memset (out_homogeneity_map, 0, 2*TS*TS);
    4271. 

  4271. 

  4272.   for (row=top+2; row < rowlimit; row++) {
    4273. 

  4273.     tr = row-top;
    4274. 

  4274.     homogeneity_map_p = &out_homogeneity_map[tr][1];
    4275. 

  4275.     for (direction=0; direction < 2; direction++) {
    4276. 

  4276.       lixs[direction] = &lab[direction][tr][1];
    4277. 

  4277.     }
    4278. 

  4278. 

  4279.     for (col=left+2; col < collimit; col++) {
    4280. 

  4280.       tc = col-left;
    4281. 

  4281.       homogeneity_map_p++;
    4282. 

  4282. 

  4283.       for (direction=0; direction < 2; direction++) {
    4284. 

  4284.         lix = ++lixs[direction];
    4285. 

  4285.         for (i=0; i < 4; i++) {
    4286. 

  4286. 	  adjacent_lix = lix[dir[i]];
    4287. 

  4287.           ldiff[direction][i] = ABS(lix[0][0]-adjacent_lix[0]);
    4288. 

  4288.           abdiff[direction][i] = SQR(lix[0][1]-adjacent_lix[1])
    4289. 

  4289.             + SQR(lix[0][2]-adjacent_lix[2]);
    4290. 

  4290.         }
    4291. 

  4291.       }
    4292. 

  4292.       leps = MIN(MAX(ldiff[0][0],ldiff[0][1]),
    4293. 

  4293.           MAX(ldiff[1][2],ldiff[1][3]));
    4294. 

  4294.       abeps = MIN(MAX(abdiff[0][0],abdiff[0][1]),
    4295. 

  4295.           MAX(abdiff[1][2],abdiff[1][3]));
    4296. 

  4296.       for (direction=0; direction < 2; direction++) {
    4297. 

  4297. 	homogeneity = 0;
    4298. 

  4298.         for (i=0; i < 4; i++) {
    4299. 

  4299.           if (ldiff[direction][i] <= leps && abdiff[direction][i] <= abeps) {
    4300. 

  4300. 	    homogeneity++;
    4301. 

  4301. 	  }
    4302. 

  4302. 	}
    4303. 

  4303. 	homogeneity_map_p[0][direction] = homogeneity;
    4304. 

  4304.       }
    4305. 

  4305.     }
    4306. 

  4306.   }
    4307. 

  4307. }
    4308. 

  4308. void CLASS ahd_interpolate_combine_homogeneous_pixels(int top, int left, ushort (*rgb)[TS][TS][3], char (*homogeneity_map)[TS][2])
    4309. 

  4309. {
    4310. 

  4310.   int row, col;
    4311. 

  4311.   int tr, tc;
    4312. 

  4312.   int i, j;
    4313. 

  4313.   int direction;
    4314. 

  4314.   int hm[2];
    4315. 

  4315.   int c;
    4316. 

  4316.   const int rowlimit = MIN(top+TS-3, height-5);
    4317. 

  4317.   const int collimit = MIN(left+TS-3, width-5);
    4318. 

  4318. 

  4319.   ushort (*pix)[4];
    4320. 

  4320.   ushort (*rix[2])[3];
    4321. 

  4321. 

  4322.   for (row=top+3; row < rowlimit; row++) {
    4323. 

  4323.     tr = row-top;
    4324. 

  4324.     pix = &image[row*width+left+2];
    4325. 

  4325.     for (direction = 0; direction < 2; direction++) {
    4326. 

  4326.       rix[direction] = &rgb[direction][tr][2];
    4327. 

  4327.     }
    4328. 

  4328. 

  4329.     for (col=left+3; col < collimit; col++) {
    4330. 

  4330.       tc = col-left;
    4331. 

  4331.       pix++;
    4332. 

  4332.       for (direction = 0; direction < 2; direction++) {
    4333. 

  4333.         rix[direction]++;
    4334. 

  4334.       }
    4335. 

  4335. 

  4336.       for (direction=0; direction < 2; direction++) {
    4337. 

  4337.         hm[direction] = 0;
    4338. 

  4338.         for (i=tr-1; i <= tr+1; i++) {
    4339. 

  4339.           for (j=tc-1; j <= tc+1; j++) {
    4340. 

  4340.             hm[direction] += homogeneity_map[i][j][direction];
    4341. 

  4341.           }
    4342. 

  4342.         }
    4343. 

  4343.       }
    4344. 

  4344.       if (hm[0] != hm[1]) {
    4345. 

  4345.         memcpy(pix[0], rix[hm[1] > hm[0]][0], 3 * sizeof(ushort));
    4346. 

  4346.       } else {
    4347. 

  4347.         FORC3 {
    4348. 

  4348.           pix[0][c] = (rix[0][0][c] + rix[1][0][c]) >> 1;
    4349. 

  4349.         }
    4350. 

  4350.       }
    4351. 

  4351.     }
    4352. 

  4352.   }
    4353. 

  4353. }
    4354. 

  4354. void CLASS ahd_interpolate()
    4355. 

  4355. {
    4356. 

  4356.   int i, j, k, top, left;
    4357. 

  4357.   float xyz_cam[3][4],r;
    4358. 

  4358.   char *buffer;
    4359. 

  4359.   ushort (*rgb)[TS][TS][3];
    4360. 

  4360.   short (*lab)[TS][TS][3];
    4361. 

  4361.   char (*homo)[TS][2];
    4362. 

  4362.   int terminate_flag = 0;
    4363. 

  4363. 

  4364.   if(dcraw_cbrt[0]<-0.1){
    4365. 

  4365.       for (i=0x10000-1; i >=0; i--) {
    4366. 

  4366.           r = i / 65535.0;
    4367. 

  4367.           dcraw_cbrt[i] = 64.0*(r > 0.008856 ? pow((double)r,1/3.0) : 7.787*r + 16/116.0);
    4368. 

  4368.       }
    4369. 

  4369.   }
    4370. 

  4370. 

  4371. #ifdef DCRAW_VERBOSE
    4372. 

  4372.   if (verbose) fprintf (stderr,_("AHD interpolation...\n"));
    4373. 

  4373. #endif
    4374. 

  4374. 

  4375.   for (i=0; i < 3; i++) {
    4376. 

  4376.     for (j=0; j < colors; j++) {
    4377. 

  4377.       xyz_cam[i][j] = 0;
    4378. 

  4378.       for (k=0; k < 3; k++) {
    4379. 

  4379.         xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
    4380. 

  4380.       }
    4381. 

  4381.     }
    4382. 

  4382.   }
    4383. 

  4383. 

  4384.   border_interpolate(5);
    4385. 

  4385. 

  4386. #ifdef LIBRAW_LIBRARY_BUILD
    4387. 

  4387. #ifdef LIBRAW_USE_OPENMP
    4388. 

  4388. #pragma omp parallel private(buffer,rgb,lab,homo,top,left,i,j,k) shared(xyz_cam,terminate_flag)
    4389. 

  4389. #endif
    4390. 

  4390. #endif
    4391. 

  4391.   {
    4392. 

  4392.     buffer = (char *) malloc (26*TS*TS);		/* 1664 kB */
    4393. 

  4393.     merror (buffer, "ahd_interpolate()");
    4394. 

  4394.     rgb  = (ushort(*)[TS][TS][3]) buffer;
    4395. 

  4395.     lab  = (short (*)[TS][TS][3])(buffer + 12*TS*TS);
    4396. 

  4396.     homo = (char  (*)[TS][2])    (buffer + 24*TS*TS);
    4397. 

  4397. 

  4398. #ifdef LIBRAW_LIBRARY_BUILD
    4399. 

  4399. #ifdef LIBRAW_USE_OPENMP
    4400. 

  4400. #pragma omp for schedule(dynamic)
    4401. 

  4401. #endif
    4402. 

  4402. #endif
    4403. 

  4403.     for (top=2; top < height-5; top += TS-6){
    4404. 

  4404. #ifdef LIBRAW_LIBRARY_BUILD
    4405. 

  4405. #ifdef LIBRAW_USE_OPENMP
    4406. 

  4406.         if(0== omp_get_thread_num())
    4407. 

  4407. #endif
    4408. 

  4408.            if(callbacks.progress_cb) {                                     
    4409. 

  4409.                int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,LIBRAW_PROGRESS_INTERPOLATE,top-2,height-7);
    4410. 

  4410.                if(rr)
    4411. 

  4411.                    terminate_flag = 1;
    4412. 

  4412.            }
    4413. 

  4413. #endif
    4414. 

  4414.         for (left=2; !terminate_flag && (left < width-5); left += TS-6) {
    4415. 

  4415.             ahd_interpolate_green_h_and_v(top, left, rgb);
    4416. 

  4416.             ahd_interpolate_r_and_b_and_convert_to_cielab(top, left, rgb, lab, xyz_cam);
    4417. 

  4417.             ahd_interpolate_build_homogeneity_map(top, left, lab, homo);
    4418. 

  4418.             ahd_interpolate_combine_homogeneous_pixels(top, left, rgb, homo);
    4419. 

  4419.       }
    4420. 

  4420.     }
    4421. 

  4421.     free (buffer);
    4422. 

  4422.   }
    4423. 

  4423. #ifdef LIBRAW_LIBRARY_BUILD 
    4424. 

  4424.   if(terminate_flag)
    4425. 

  4425.       throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
    4426. 

  4426. #endif
    4427. 

  4427. }
    4428. 

  4428. 

  4429. 

  4430. 

  4431. #undef TS
    4432. 

  4432. 

  4433. void CLASS median_filter()
    4434. 

  4434. {
    4435. 

  4435.   ushort (*pix)[4];
    4436. 

  4436.   int pass, c, i, j, k, med[9];
    4437. 

  4437.   static const uchar opt[] =	/* Optimal 9-element median search */
    4438. 

  4438.   { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
    4439. 

  4439.     0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
    4440. 

  4440. 

  4441.   for (pass=1; pass <= med_passes; pass++) {
    4442. 

  4442. #ifdef LIBRAW_LIBRARY_BUILD
    4443. 

  4443.       RUN_CALLBACK(LIBRAW_PROGRESS_MEDIAN_FILTER,pass-1,med_passes);
    4444. 

  4444. #endif
    4445. 

  4445. #ifdef DCRAW_VERBOSE
    4446. 

  4446.     if (verbose)
    4447. 

  4447.       fprintf (stderr,_("Median filter pass %d...\n"), pass);
    4448. 

  4448. #endif
    4449. 

  4449.     for (c=0; c < 3; c+=2) {
    4450. 

  4450.       for (pix = image; pix < image+width*height; pix++)
    4451. 

  4451. 	pix[0][3] = pix[0][c];
    4452. 

  4452.       for (pix = image+width; pix < image+width*(height-1); pix++) {
    4453. 

  4453. 	if ((pix-image+1) % width < 2) continue;
    4454. 

  4454. 	for (k=0, i = -width; i <= width; i += width)
    4455. 

  4455. 	  for (j = i-1; j <= i+1; j++)
    4456. 

  4456. 	    med[k++] = pix[j][3] - pix[j][1];
    4457. 

  4457. 	for (i=0; i < sizeof opt; i+=2)
    4458. 

  4458. 	  if     (med[opt[i]] > med[opt[i+1]])
    4459. 

  4459. 	    SWAP (med[opt[i]] , med[opt[i+1]]);
    4460. 

  4460. 	pix[0][c] = CLIP(med[4] + pix[0][1]);
    4461. 

  4461.       }
    4462. 

  4462.     }
    4463. 

  4463.   }
    4464. 

  4464. }
    4465. 

  4465. 

  4466. void CLASS blend_highlights()
    4467. 

  4467. {
    4468. 

  4468.   int clip=INT_MAX, row, col, c, i, j;
    4469. 

  4469.   static const float trans[2][4][4] =
    4470. 

  4470.   { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
    4471. 

  4471.     { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
    4472. 

  4472.   static const float itrans[2][4][4] =
    4473. 

  4473.   { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
    4474. 

  4474.     { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
    4475. 

  4475.   float cam[2][4], lab[2][4], sum[2], chratio;
    4476. 

  4476. 

  4477.   if ((unsigned) (colors-3) > 1) return;
    4478. 

  4478. #ifdef DCRAW_VERBOSE
    4479. 

  4479.   if (verbose) fprintf (stderr,_("Blending highlights...\n"));
    4480. 

  4480. #endif
    4481. 

  4481.   FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
    4482. 

  4482. #ifdef LIBRAW_LIBRARY_BUILD
    4483. 

  4483.   RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,0,2);
    4484. 

  4484. #endif
    4485. 

  4485.   for (row=0; row < height; row++)
    4486. 

  4486.     for (col=0; col < width; col++) {
    4487. 

  4487.       FORCC if (image[row*width+col][c] > clip) break;
    4488. 

  4488.       if (c == colors) continue;
    4489. 

  4489.       FORCC {
    4490. 

  4490. 	cam[0][c] = image[row*width+col][c];
    4491. 

  4491. 	cam[1][c] = MIN(cam[0][c],clip);
    4492. 

  4492.       }
    4493. 

  4493.       for (i=0; i < 2; i++) {
    4494. 

  4494. 	FORCC for (lab[i][c]=j=0; j < colors; j++)
    4495. 

  4495. 	  lab[i][c] += trans[colors-3][c][j] * cam[i][j];
    4496. 

  4496. 	for (sum[i]=0,c=1; c < colors; c++)
    4497. 

  4497. 	  sum[i] += SQR(lab[i][c]);
    4498. 

  4498.       }
    4499. 

  4499.       chratio = sqrt(sum[1]/sum[0]);
    4500. 

  4500.       for (c=1; c < colors; c++)
    4501. 

  4501. 	lab[0][c] *= chratio;
    4502. 

  4502.       FORCC for (cam[0][c]=j=0; j < colors; j++)
    4503. 

  4503. 	cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
    4504. 

  4504.       FORCC image[row*width+col][c] = cam[0][c] / colors;
    4505. 

  4505.     }
    4506. 

  4506. #ifdef LIBRAW_LIBRARY_BUILD
    4507. 

  4507.   RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,1,2);
    4508. 

  4508. #endif
    4509. 

  4509. }
    4510. 

  4510. 

  4511. #define SCALE (4 >> shrink)
    4512. 

  4512. void CLASS recover_highlights()
    4513. 

  4513. {
    4514. 

  4514.   float *map, sum, wgt, grow;
    4515. 

  4515.   int hsat[4], count, spread, change, val, i;
    4516. 

  4516.   unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
    4517. 

  4517.   ushort *pixel;
    4518. 

  4518.   static const signed char dir[8][2] =
    4519. 

  4519.     { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
    4520. 

  4520. 

  4521. #ifdef DCRAW_VERBOSE
    4522. 

  4522.   if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
    4523. 

  4523. #endif
    4524. 

  4524. 

  4525.   grow = pow (2.0, 4.0-highlight);
    4526. 

  4526.   FORCC hsat[c] = 32000 * pre_mul[c];
    4527. 

  4527.   for (kc=0, c=1; c < colors; c++)
    4528. 

  4528.     if (pre_mul[kc] < pre_mul[c]) kc = c;
    4529. 

  4529.   high = height / SCALE;
    4530. 

  4530.   wide =  width / SCALE;
    4531. 

  4531.   map = (float *) calloc (high*wide, sizeof *map);
    4532. 

  4532.   merror (map, "recover_highlights()");
    4533. 

  4533.   FORCC if (c != kc) {
    4534. 

  4534. #ifdef LIBRAW_LIBRARY_BUILD
    4535. 

  4535.       RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,c-1,colors-1);
    4536. 

  4536. #endif
    4537. 

  4537.     memset (map, 0, high*wide*sizeof *map);
    4538. 

  4538.     for (mrow=0; mrow < high; mrow++)
    4539. 

  4539.       for (mcol=0; mcol < wide; mcol++) {
    4540. 

  4540. 	sum = wgt = count = 0;
    4541. 

  4541. 	for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
    4542. 

  4542. 	  for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
    4543. 

  4543. 	    pixel = image[row*width+col];
    4544. 

  4544. 	    if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
    4545. 

  4545. 	      sum += pixel[c];
    4546. 

  4546. 	      wgt += pixel[kc];
    4547. 

  4547. 	      count++;
    4548. 

  4548. 	    }
    4549. 

  4549. 	  }
    4550. 

  4550. 	if (count == SCALE*SCALE)
    4551. 

  4551. 	  map[mrow*wide+mcol] = sum / wgt;
    4552. 

  4552.       }
    4553. 

  4553.     for (spread = 32/grow; spread--; ) {
    4554. 

  4554.       for (mrow=0; mrow < high; mrow++)
    4555. 

  4555. 	for (mcol=0; mcol < wide; mcol++) {
    4556. 

  4556. 	  if (map[mrow*wide+mcol]) continue;
    4557. 

  4557. 	  sum = count = 0;
    4558. 

  4558. 	  for (d=0; d < 8; d++) {
    4559. 

  4559. 	    y = mrow + dir[d][0];
    4560. 

  4560. 	    x = mcol + dir[d][1];
    4561. 

  4561. 	    if (y < high && x < wide && map[y*wide+x] > 0) {
    4562. 

  4562. 	      sum  += (1 + (d & 1)) * map[y*wide+x];
    4563. 

  4563. 	      count += 1 + (d & 1);
    4564. 

  4564. 	    }
    4565. 

  4565. 	  }
    4566. 

  4566. 	  if (count > 3)
    4567. 

  4567. 	    map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
    4568. 

  4568. 	}
    4569. 

  4569.       for (change=i=0; i < high*wide; i++)
    4570. 

  4570. 	if (map[i] < 0) {
    4571. 

  4571. 	  map[i] = -map[i];
    4572. 

  4572. 	  change = 1;
    4573. 

  4573. 	}
    4574. 

  4574.       if (!change) break;
    4575. 

  4575.     }
    4576. 

  4576.     for (i=0; i < high*wide; i++)
    4577. 

  4577.       if (map[i] == 0) map[i] = 1;
    4578. 

  4578.     for (mrow=0; mrow < high; mrow++)
    4579. 

  4579.       for (mcol=0; mcol < wide; mcol++) {
    4580. 

  4580. 	for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
    4581. 

  4581. 	  for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
    4582. 

  4582. 	    pixel = image[row*width+col];
    4583. 

  4583. 	    if (pixel[c] / hsat[c] > 1) {
    4584. 

  4584. 	      val = pixel[kc] * map[mrow*wide+mcol];
    4585. 

  4585. 	      if (pixel[c] < val) pixel[c] = CLIP(val);
    4586. 

  4586. 	    }
    4587. 

  4587. 	  }
    4588. 

  4588.       }
    4589. 

  4589.   }
    4590. 

  4590.   free (map);
    4591. 

  4591. }
    4592. 

  4592. #undef SCALE
    4593. 

  4593. 

  4594. void CLASS tiff_get (unsigned base,
    4595. 

  4595. 	unsigned *tag, unsigned *type, unsigned *len, unsigned *save)
    4596. 

  4596. {
    4597. 

  4597.   *tag  = get2();
    4598. 

  4598.   *type = get2();
    4599. 

  4599.   *len  = get4();
    4600. 

  4600.   *save = ftell(ifp) + 4;
    4601. 

  4601.   if (*len * ("11124811248488"[*type < 14 ? *type:0]-'0') > 4)
    4602. 

  4602.     fseek (ifp, get4()+base, SEEK_SET);
    4603. 

  4603. }
    4604. 

  4604. 

  4605. void CLASS parse_thumb_note (int base, unsigned toff, unsigned tlen)
    4606. 

  4606. {
    4607. 

  4607.   unsigned entries, tag, type, len, save;
    4608. 

  4608. 

  4609.   entries = get2();
    4610. 

  4610.   while (entries--) {
    4611. 

  4611.     tiff_get (base, &tag, &type, &len, &save);
    4612. 

  4612.     if (tag == toff) thumb_offset = get4()+base;
    4613. 

  4613.     if (tag == tlen) thumb_length = get4();
    4614. 

  4614.     fseek (ifp, save, SEEK_SET);
    4615. 

  4615.   }
    4616. 

  4616. }
    4617. 

  4617. 

  4618. void CLASS parse_makernote (int base, int uptag)
    4619. 

  4619. {
    4620. 

  4620.   static const uchar xlat[2][256] = {
    4621. 

  4621.   { 0xc1,0xbf,0x6d,0x0d,0x59,0xc5,0x13,0x9d,0x83,0x61,0x6b,0x4f,0xc7,0x7f,0x3d,0x3d,
    4622. 

  4622.     0x53,0x59,0xe3,0xc7,0xe9,0x2f,0x95,0xa7,0x95,0x1f,0xdf,0x7f,0x2b,0x29,0xc7,0x0d,
    4623. 

  4623.     0xdf,0x07,0xef,0x71,0x89,0x3d,0x13,0x3d,0x3b,0x13,0xfb,0x0d,0x89,0xc1,0x65,0x1f,
    4624. 

  4624.     0xb3,0x0d,0x6b,0x29,0xe3,0xfb,0xef,0xa3,0x6b,0x47,0x7f,0x95,0x35,0xa7,0x47,0x4f,
    4625. 

  4625.     0xc7,0xf1,0x59,0x95,0x35,0x11,0x29,0x61,0xf1,0x3d,0xb3,0x2b,0x0d,0x43,0x89,0xc1,
    4626. 

  4626.     0x9d,0x9d,0x89,0x65,0xf1,0xe9,0xdf,0xbf,0x3d,0x7f,0x53,0x97,0xe5,0xe9,0x95,0x17,
    4627. 

  4627.     0x1d,0x3d,0x8b,0xfb,0xc7,0xe3,0x67,0xa7,0x07,0xf1,0x71,0xa7,0x53,0xb5,0x29,0x89,
    4628. 

  4628.     0xe5,0x2b,0xa7,0x17,0x29,0xe9,0x4f,0xc5,0x65,0x6d,0x6b,0xef,0x0d,0x89,0x49,0x2f,
    4629. 

  4629.     0xb3,0x43,0x53,0x65,0x1d,0x49,0xa3,0x13,0x89,0x59,0xef,0x6b,0xef,0x65,0x1d,0x0b,
    4630. 

  4630.     0x59,0x13,0xe3,0x4f,0x9d,0xb3,0x29,0x43,0x2b,0x07,0x1d,0x95,0x59,0x59,0x47,0xfb,
    4631. 

  4631.     0xe5,0xe9,0x61,0x47,0x2f,0x35,0x7f,0x17,0x7f,0xef,0x7f,0x95,0x95,0x71,0xd3,0xa3,
    4632. 

  4632.     0x0b,0x71,0xa3,0xad,0x0b,0x3b,0xb5,0xfb,0xa3,0xbf,0x4f,0x83,0x1d,0xad,0xe9,0x2f,
    4633. 

  4633.     0x71,0x65,0xa3,0xe5,0x07,0x35,0x3d,0x0d,0xb5,0xe9,0xe5,0x47,0x3b,0x9d,0xef,0x35,
    4634. 

  4634.     0xa3,0xbf,0xb3,0xdf,0x53,0xd3,0x97,0x53,0x49,0x71,0x07,0x35,0x61,0x71,0x2f,0x43,
    4635. 

  4635.     0x2f,0x11,0xdf,0x17,0x97,0xfb,0x95,0x3b,0x7f,0x6b,0xd3,0x25,0xbf,0xad,0xc7,0xc5,
    4636. 

  4636.     0xc5,0xb5,0x8b,0xef,0x2f,0xd3,0x07,0x6b,0x25,0x49,0x95,0x25,0x49,0x6d,0x71,0xc7 },
    4637. 

  4637.   { 0xa7,0xbc,0xc9,0xad,0x91,0xdf,0x85,0xe5,0xd4,0x78,0xd5,0x17,0x46,0x7c,0x29,0x4c,
    4638. 

  4638.     0x4d,0x03,0xe9,0x25,0x68,0x11,0x86,0xb3,0xbd,0xf7,0x6f,0x61,0x22,0xa2,0x26,0x34,
    4639. 

  4639.     0x2a,0xbe,0x1e,0x46,0x14,0x68,0x9d,0x44,0x18,0xc2,0x40,0xf4,0x7e,0x5f,0x1b,0xad,
    4640. 

  4640.     0x0b,0x94,0xb6,0x67,0xb4,0x0b,0xe1,0xea,0x95,0x9c,0x66,0xdc,0xe7,0x5d,0x6c,0x05,
    4641. 

  4641.     0xda,0xd5,0xdf,0x7a,0xef,0xf6,0xdb,0x1f,0x82,0x4c,0xc0,0x68,0x47,0xa1,0xbd,0xee,
    4642. 

  4642.     0x39,0x50,0x56,0x4a,0xdd,0xdf,0xa5,0xf8,0xc6,0xda,0xca,0x90,0xca,0x01,0x42,0x9d,
    4643. 

  4643.     0x8b,0x0c,0x73,0x43,0x75,0x05,0x94,0xde,0x24,0xb3,0x80,0x34,0xe5,0x2c,0xdc,0x9b,
    4644. 

  4644.     0x3f,0xca,0x33,0x45,0xd0,0xdb,0x5f,0xf5,0x52,0xc3,0x21,0xda,0xe2,0x22,0x72,0x6b,
    4645. 

  4645.     0x3e,0xd0,0x5b,0xa8,0x87,0x8c,0x06,0x5d,0x0f,0xdd,0x09,0x19,0x93,0xd0,0xb9,0xfc,
    4646. 

  4646.     0x8b,0x0f,0x84,0x60,0x33,0x1c,0x9b,0x45,0xf1,0xf0,0xa3,0x94,0x3a,0x12,0x77,0x33,
    4647. 

  4647.     0x4d,0x44,0x78,0x28,0x3c,0x9e,0xfd,0x65,0x57,0x16,0x94,0x6b,0xfb,0x59,0xd0,0xc8,
    4648. 

  4648.     0x22,0x36,0xdb,0xd2,0x63,0x98,0x43,0xa1,0x04,0x87,0x86,0xf7,0xa6,0x26,0xbb,0xd6,
    4649. 

  4649.     0x59,0x4d,0xbf,0x6a,0x2e,0xaa,0x2b,0xef,0xe6,0x78,0xb6,0x4e,0xe0,0x2f,0xdc,0x7c,
    4650. 

  4650.     0xbe,0x57,0x19,0x32,0x7e,0x2a,0xd0,0xb8,0xba,0x29,0x00,0x3c,0x52,0x7d,0xa8,0x49,
    4651. 

  4651.     0x3b,0x2d,0xeb,0x25,0x49,0xfa,0xa3,0xaa,0x39,0xa7,0xc5,0xa7,0x50,0x11,0x36,0xfb,
    4652. 

  4652.     0xc6,0x67,0x4a,0xf5,0xa5,0x12,0x65,0x7e,0xb0,0xdf,0xaf,0x4e,0xb3,0x61,0x7f,0x2f } };
    4653. 

  4653.   unsigned offset=0, entries, tag, type, len, save, c;
    4654. 

  4654.   unsigned ver97=0, serial=0, i, wbi=0, wb[4]={0,0,0,0};
    4655. 

  4655.   uchar buf97[324], ci, cj, ck;
    4656. 

  4656.   short morder, sorder=order;
    4657. 

  4657.   char buf[10];
    4658. 

  4658. /*
    4659. 

  4659.    The MakerNote might have its own TIFF header (possibly with
    4660. 

  4660.    its own byte-order!), or it might just be a table.
    4661. 

  4661.  */
    4662. 

  4662.   if (!strcmp(make,"Nokia")) return;
    4663. 

  4663.   fread (buf, 1, 10, ifp);
    4664. 

  4664.   if (!strncmp (buf,"KDK" ,3) ||	/* these aren't TIFF tables */
    4665. 

  4665.       !strncmp (buf,"VER" ,3) ||
    4666. 

  4666.       !strncmp (buf,"IIII",4) ||
    4667. 

  4667.       !strncmp (buf,"MMMM",4)) return;
    4668. 

  4668.   if (!strncmp (buf,"KC"  ,2) ||	/* Konica KD-400Z, KD-510Z */
    4669. 

  4669.       !strncmp (buf,"MLY" ,3)) {	/* Minolta DiMAGE G series */
    4670. 

  4670.     order = 0x4d4d;
    4671. 

  4671.     while ((i=ftell(ifp)) < data_offset && i < 16384) {
    4672. 

  4672.       wb[0] = wb[2];  wb[2] = wb[1];  wb[1] = wb[3];
    4673. 

  4673.       wb[3] = get2();
    4674. 

  4674.       if (wb[1] == 256 && wb[3] == 256 &&
    4675. 

  4675. 	  wb[0] > 256 && wb[0] < 640 && wb[2] > 256 && wb[2] < 640)
    4676. 

  4676. 	FORC4 cam_mul[c] = wb[c];
    4677. 

  4677. #ifdef LIBRAW_LIBRARY_BUILD
    4678. 

  4678.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4679. 

  4679. #endif
    4680. 

  4680.     }
    4681. 

  4681.     goto quit;
    4682. 

  4682.   }
    4683. 

  4683.   if (!strcmp (buf,"Nikon")) {
    4684. 

  4684.     base = ftell(ifp);
    4685. 

  4685.     order = get2();
    4686. 

  4686.     if (get2() != 42) goto quit;
    4687. 

  4687.     offset = get4();
    4688. 

  4688.     fseek (ifp, offset-8, SEEK_CUR);
    4689. 

  4689.   } else if (!strcmp (buf,"OLYMPUS")) {
    4690. 

  4690.     base = ftell(ifp)-10;
    4691. 

  4691.     fseek (ifp, -2, SEEK_CUR);
    4692. 

  4692.     order = get2();  get2();
    4693. 

  4693.   } else if (!strncmp (buf,"SONY",4) ||
    4694. 

  4694. 	     !strcmp  (buf,"Panasonic")) {
    4695. 

  4695.     goto nf;
    4696. 

  4696.   } else if (!strncmp (buf,"FUJIFILM",8)) {
    4697. 

  4697.     base = ftell(ifp)-10;
    4698. 

  4698. nf: order = 0x4949;
    4699. 

  4699.     fseek (ifp,  2, SEEK_CUR);
    4700. 

  4700.   } else if (!strcmp (buf,"OLYMP") ||
    4701. 

  4701. 	     !strcmp (buf,"LEICA") ||
    4702. 

  4702. 	     !strcmp (buf,"Ricoh") ||
    4703. 

  4703. 	     !strcmp (buf,"EPSON"))
    4704. 

  4704.     fseek (ifp, -2, SEEK_CUR);
    4705. 

  4705.   else if (!strcmp (buf,"AOC") ||
    4706. 

  4706. 	   !strcmp (buf,"QVC"))
    4707. 

  4707.     fseek (ifp, -4, SEEK_CUR);
    4708. 

  4708.   else {
    4709. 

  4709.     fseek (ifp, -10, SEEK_CUR);
    4710. 

  4710.     if (!strncmp(make,"SAMSUNG",7))
    4711. 

  4711.       base = ftell(ifp);
    4712. 

  4712.   }
    4713. 

  4713.   entries = get2();
    4714. 

  4714.   if (entries > 1000) return;
    4715. 

  4715.   morder = order;
    4716. 

  4716.   while (entries--) {
    4717. 

  4717.     order = morder;
    4718. 

  4718.     tiff_get (base, &tag, &type, &len, &save);
    4719. 

  4719.     tag |= uptag << 16;
    4720. 

  4720.     if (tag == 2 && strstr(make,"NIKON") && !iso_speed)
    4721. 

  4721.       iso_speed = (get2(),get2());
    4722. 

  4722.     if (tag == 4 && len > 26 && len < 35) {
    4723. 

  4723.       if ((i=(get4(),get2())) != 0x7fff && !iso_speed)
    4724. 

  4724. 	iso_speed = 50 * pow (2.0, i/32.0 - 4);
    4725. 

  4725.       if ((i=(get2(),get2())) != 0x7fff && !aperture)
    4726. 

  4726. 	aperture = pow (2.0, i/64.0);
    4727. 

  4727.       if ((i=get2()) != 0xffff && !shutter)
    4728. 

  4728. 	shutter = pow (2.0, (short) i/-32.0);
    4729. 

  4729.       wbi = (get2(),get2());
    4730. 

  4730.       shot_order = (get2(),get2());
    4731. 

  4731.     }
    4732. 

  4732.     if ((tag == 4 || tag == 0x114) && !strncmp(make,"KONICA",6)) {
    4733. 

  4733.       fseek (ifp, tag == 4 ? 140:160, SEEK_CUR);
    4734. 

  4734.       switch (get2()) {
    4735. 

  4735. 	case 72:  flip = 0;  break;
    4736. 

  4736. 	case 76:  flip = 6;  break;
    4737. 

  4737. 	case 82:  flip = 5;  break;
    4738. 

  4738.       }
    4739. 

  4739.     }
    4740. 

  4740.     if (tag == 7 && type == 2 && len > 20)
    4741. 

  4741.       fgets (model2, 64, ifp);
    4742. 

  4742.     if (tag == 8 && type == 4)
    4743. 

  4743.       shot_order = get4();
    4744. 

  4744.     if (tag == 9 && !strcmp(make,"Canon"))
    4745. 

  4745.       fread (artist, 64, 1, ifp);
    4746. 

  4746.     if (tag == 0xc && len == 4) {
    4747. 

  4747.       cam_mul[0] = getreal(type);
    4748. 

  4748.       cam_mul[2] = getreal(type);
    4749. 

  4749. #ifdef LIBRAW_LIBRARY_BUILD
    4750. 

  4750.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4751. 

  4751. #endif
    4752. 

  4752.     }
    4753. 

  4753.     if (tag == 0xd && type == 7 && get2() == 0xaaaa) {
    4754. 

  4754.       fread (buf97, 1, sizeof buf97, ifp);
    4755. 

  4755.       char *pp = (char*)memmem ((char*)buf97, sizeof buf97,(char*)"\xbb\xbb",2);
    4756. 

  4756.       i = ((uchar*)pp  - buf97) + 10;
    4757. 

  4757.       if (i < 70 && buf97[i] < 3)
    4758. 

  4758. 	flip = "065"[buf97[i]]-'0';
    4759. 

  4759.     }
    4760. 

  4760.     if (tag == 0x10 && type == 4)
    4761. 

  4761.       unique_id = get4();
    4762. 

  4762.     if (tag == 0x11 && is_raw && !strncmp(make,"NIKON",5)) {
    4763. 

  4763.       fseek (ifp, get4()+base, SEEK_SET);
    4764. 

  4764.       parse_tiff_ifd (base);
    4765. 

  4765.     }
    4766. 

  4766.     if (tag == 0x14 && type == 7) {
    4767. 

  4767.       if (len == 2560) {
    4768. 

  4768. 	fseek (ifp, 1248, SEEK_CUR);
    4769. 

  4769. 	goto get2_256;
    4770. 

  4770.       }
    4771. 

  4771.       fread (buf, 1, 10, ifp);
    4772. 

  4772.       if (!strncmp(buf,"NRW ",4)) {
    4773. 

  4773. 	fseek (ifp, strcmp(buf+4,"0100") ? 46:1546, SEEK_CUR);
    4774. 

  4774. 	cam_mul[0] = get4() << 2;
    4775. 

  4775. 	cam_mul[1] = get4() + get4();
    4776. 

  4776. 	cam_mul[2] = get4() << 2;
    4777. 

  4777.       }
    4778. 

  4778.     }
    4779. 

  4779.     if (tag == 0x15 && type == 2 && is_raw)
    4780. 

  4780.       fread (model, 64, 1, ifp);
    4781. 

  4781.     if (strstr(make,"PENTAX")) {
    4782. 

  4782.       if (tag == 0x1b) tag = 0x1018;
    4783. 

  4783.       if (tag == 0x1c) tag = 0x1017;
    4784. 

  4784.     }
    4785. 

  4785.     if (tag == 0x1d)
    4786. 

  4786.       while ((c = fgetc(ifp)) && c != EOF)
    4787. 

  4787. 	serial = serial*10 + (isdigit(c) ? c - '0' : c % 10);
    4788. 

  4788.     if (tag == 0x81 && type == 4) {
    4789. 

  4789.       data_offset = get4();
    4790. 

  4790.       fseek (ifp, data_offset + 41, SEEK_SET);
    4791. 

  4791.       raw_height = get2() * 2;
    4792. 

  4792.       raw_width  = get2();
    4793. 

  4793.       filters = 0x61616161;
    4794. 

  4794.     }
    4795. 

  4795.     if (tag == 0x29 && type == 1) {
    4796. 

  4796.       c = wbi < 18 ? "012347800000005896"[wbi]-'0' : 0;
    4797. 

  4797.       fseek (ifp, 8 + c*32, SEEK_CUR);
    4798. 

  4798.       FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get4();
    4799. 

  4799. #ifdef LIBRAW_LIBRARY_BUILD
    4800. 

  4800.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4801. 

  4801. #endif
    4802. 

  4802.     }
    4803. 

  4803.     if ((tag == 0x81  && type == 7) ||
    4804. 

  4804. 	(tag == 0x100 && type == 7) ||
    4805. 

  4805. 	(tag == 0x280 && type == 1)) {
    4806. 

  4806.       thumb_offset = ftell(ifp);
    4807. 

  4807.       thumb_length = len;
    4808. 

  4808.     }
    4809. 

  4809.     if (tag == 0x88 && type == 4 && (thumb_offset = get4()))
    4810. 

  4810.       thumb_offset += base;
    4811. 

  4811.     if (tag == 0x89 && type == 4)
    4812. 

  4812.       thumb_length = get4();
    4813. 

  4813.     if (tag == 0x8c || tag == 0x96)
    4814. 

  4814.       meta_offset = ftell(ifp);
    4815. 

  4815.     if (tag == 0x97) {
    4816. 

  4816.       for (i=0; i < 4; i++)
    4817. 

  4817. 	ver97 = ver97 * 10 + fgetc(ifp)-'0';
    4818. 

  4818.       switch (ver97) {
    4819. 

  4819. 	case 100:
    4820. 

  4820. 	  fseek (ifp, 68, SEEK_CUR);
    4821. 

  4821. 	  FORC4 cam_mul[(c >> 1) | ((c & 1) << 1)] = get2();
    4822. 

  4822. #ifdef LIBRAW_LIBRARY_BUILD
    4823. 

  4823.           color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4824. 

  4824. #endif
    4825. 

  4825. 	  break;
    4826. 

  4826. 	case 102:
    4827. 

  4827. 	  fseek (ifp, 6, SEEK_CUR);
    4828. 

  4828. 	  goto get2_rggb;
    4829. 

  4829. 	case 103:
    4830. 

  4830. 	  fseek (ifp, 16, SEEK_CUR);
    4831. 

  4831. 	  FORC4 cam_mul[c] = get2();
    4832. 

  4832. #ifdef LIBRAW_LIBRARY_BUILD
    4833. 

  4833.           color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4834. 

  4834. #endif
    4835. 

  4835.       }
    4836. 

  4836.       if (ver97 >= 200) {
    4837. 

  4837. 	if (ver97 != 205) fseek (ifp, 280, SEEK_CUR);
    4838. 

  4838. 	fread (buf97, 324, 1, ifp);
    4839. 

  4839.       }
    4840. 

  4840.     }
    4841. 

  4841.     if (tag == 0xa1 && type == 7) {
    4842. 

  4842.       order = 0x4949;
    4843. 

  4843.       fseek (ifp, 140, SEEK_CUR);
    4844. 

  4844.       FORC3 cam_mul[c] = get4();
    4845. 

  4845.     }
    4846. 

  4846.     if (tag == 0xa4 && type == 3) {
    4847. 

  4847.       fseek (ifp, wbi*48, SEEK_CUR);
    4848. 

  4848.       FORC3 cam_mul[c] = get2();
    4849. 

  4849. #ifdef LIBRAW_LIBRARY_BUILD
    4850. 

  4850.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4851. 

  4851. #endif
    4852. 

  4852.     }
    4853. 

  4853.     if (tag == 0xa7 && (unsigned) (ver97-200) < 17) {
    4854. 

  4854.       ci = xlat[0][serial & 0xff];
    4855. 

  4855.       cj = xlat[1][fgetc(ifp)^fgetc(ifp)^fgetc(ifp)^fgetc(ifp)];
    4856. 

  4856.       ck = 0x60;
    4857. 

  4857.       for (i=0; i < 324; i++)
    4858. 

  4858. 	buf97[i] ^= (cj += ci * ck++);
    4859. 

  4859.       i = "66666>666;6A;:;55"[ver97-200] - '0';
    4860. 

  4860.       FORC4 cam_mul[c ^ (c >> 1) ^ (i & 1)] =
    4861. 

  4861. 	sget2 (buf97 + (i & -2) + c*2);
    4862. 

  4862. #ifdef LIBRAW_LIBRARY_BUILD
    4863. 

  4863.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4864. 

  4864. #endif
    4865. 

  4865.     }
    4866. 

  4866.     if (tag == 0x200 && len == 3)
    4867. 

  4867.       shot_order = (get4(),get4());
    4868. 

  4868.     if (tag == 0x200 && len == 4)
    4869. 

  4869.       FORC4 cblack[c ^ c >> 1] = get2();
    4870. 

  4870.     if (tag == 0x201 && len == 4)
    4871. 

  4871.       goto get2_rggb;
    4872. 

  4872.     if (tag == 0x220 && type == 7)
    4873. 

  4873.       meta_offset = ftell(ifp);
    4874. 

  4874.     if (tag == 0x401 && type == 4 && len == 4)
    4875. 

  4875.       FORC4 cblack[c ^ c >> 1] = get4();
    4876. 

  4876.     if (tag == 0xe01) {		/* Nikon Capture Note */
    4877. 

  4877.       order = 0x4949;
    4878. 

  4878.       fseek (ifp, 22, SEEK_CUR);
    4879. 

  4879.       for (offset=22; offset+22 < len; offset += 22+i) {
    4880. 

  4880. 	tag = get4();
    4881. 

  4881. 	fseek (ifp, 14, SEEK_CUR);
    4882. 

  4882. 	i = get4()-4;
    4883. 

  4883. 	if (tag == 0x76a43207) flip = get2();
    4884. 

  4884. 	else fseek (ifp, i, SEEK_CUR);
    4885. 

  4885.       }
    4886. 

  4886.     }
    4887. 

  4887.     if (tag == 0xe80 && len == 256 && type == 7) {
    4888. 

  4888.       fseek (ifp, 48, SEEK_CUR);
    4889. 

  4889.       cam_mul[0] = get2() * 508 * 1.078 / 0x10000;
    4890. 

  4890.       cam_mul[2] = get2() * 382 * 1.173 / 0x10000;
    4891. 

  4891. #ifdef LIBRAW_LIBRARY_BUILD
    4892. 

  4892.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4893. 

  4893. #endif
    4894. 

  4894.     }
    4895. 

  4895.     if (tag == 0xf00 && type == 7) {
    4896. 

  4896.       if (len == 614)
    4897. 

  4897. 	fseek (ifp, 176, SEEK_CUR);
    4898. 

  4898.       else if (len == 734 || len == 1502)
    4899. 

  4899. 	fseek (ifp, 148, SEEK_CUR);
    4900. 

  4900.       else goto next;
    4901. 

  4901.       goto get2_256;
    4902. 

  4902.     }
    4903. 

  4903.     if ((tag == 0x1011 && len == 9) || tag == 0x20400200)
    4904. 

  4904.         {
    4905. 

  4905.       for (i=0; i < 3; i++)
    4906. 

  4906. 	FORC3 cmatrix[i][c] = ((short) get2()) / 256.0;
    4907. 

  4907. #ifdef LIBRAW_LIBRARY_BUILD
    4908. 

  4908.       color_flags.cmatrix_state = LIBRAW_COLORSTATE_LOADED;
    4909. 

  4909. #endif
    4910. 

  4910.         }
    4911. 

  4911.     if ((tag == 0x1012 || tag == 0x20400600) && len == 4)
    4912. 

  4912.       FORC4 cblack[c ^ c >> 1] = get2();
    4913. 

  4913.     if (tag == 0x1017 || tag == 0x20400100)
    4914. 

  4914.         {
    4915. 

  4915.       cam_mul[0] = get2() / 256.0;
    4916. 

  4916. #ifdef LIBRAW_LIBRARY_BUILD
    4917. 

  4917.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4918. 

  4918. #endif
    4919. 

  4919.         }
    4920. 

  4920.     if (tag == 0x1018 || tag == 0x20400100)
    4921. 

  4921.         {
    4922. 

  4922.       cam_mul[2] = get2() / 256.0;
    4923. 

  4923. #ifdef LIBRAW_LIBRARY_BUILD
    4924. 

  4924.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4925. 

  4925. #endif
    4926. 

  4926.         }
    4927. 

  4927.     if (tag == 0x2011 && len == 2) {
    4928. 

  4928. get2_256:
    4929. 

  4929.       order = 0x4d4d;
    4930. 

  4930.       cam_mul[0] = get2() / 256.0;
    4931. 

  4931.       cam_mul[2] = get2() / 256.0;
    4932. 

  4932. #ifdef LIBRAW_LIBRARY_BUILD
    4933. 

  4933.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4934. 

  4934. #endif
    4935. 

  4935.     }
    4936. 

  4936.     if ((tag | 0x70) == 0x2070 && type == 4)
    4937. 

  4937.       fseek (ifp, get4()+base, SEEK_SET);
    4938. 

  4938.     if (tag == 0x2010 && type != 7)
    4939. 

  4939.       load_raw = &CLASS olympus_load_raw;
    4940. 

  4940.     if (tag == 0x2020)
    4941. 

  4941.       parse_thumb_note (base, 257, 258);
    4942. 

  4942.     if (tag == 0x2040)
    4943. 

  4943.       parse_makernote (base, 0x2040);
    4944. 

  4944.     if (tag == 0xb028) {
    4945. 

  4945.       fseek (ifp, get4()+base, SEEK_SET);
    4946. 

  4946.       parse_thumb_note (base, 136, 137);
    4947. 

  4947.     }
    4948. 

  4948.     if (tag == 0x4001 && len > 500) {
    4949. 

  4949.       i = len == 582 ? 50 : len == 653 ? 68 : len == 5120 ? 142 : 126;
    4950. 

  4950.       fseek (ifp, i, SEEK_CUR);
    4951. 

  4951. get2_rggb:
    4952. 

  4952.       FORC4 cam_mul[c ^ (c >> 1)] = get2();
    4953. 

  4953. #ifdef LIBRAW_LIBRARY_BUILD
    4954. 

  4954.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    4955. 

  4955. #endif
    4956. 

  4956.       fseek (ifp, 22, SEEK_CUR);
    4957. 

  4957.       FORC4 sraw_mul[c ^ (c >> 1)] = get2();
    4958. 

  4958.     }
    4959. 

  4959.     if (tag == 0xa021)
    4960. 

  4960.       FORC4 cam_mul[c ^ (c >> 1)] = get4();
    4961. 

  4961.     if (tag == 0xa028)
    4962. 

  4962.       FORC4 cam_mul[c ^ (c >> 1)] -= get4();
    4963. 

  4963. next:
    4964. 

  4964.     fseek (ifp, save, SEEK_SET);
    4965. 

  4965.   }
    4966. 

  4966. quit:
    4967. 

  4967.   order = sorder;
    4968. 

  4968. }
    4969. 

  4969. 

  4970. /*
    4971. 

  4971.    Since the TIFF DateTime string has no timezone information,
    4972. 

  4972.    assume that the camera's clock was set to Universal Time.
    4973. 

  4973.  */
    4974. 

  4974. void CLASS get_timestamp (int reversed)
    4975. 

  4975. {
    4976. 

  4976.   struct tm t;
    4977. 

  4977.   char str[20];
    4978. 

  4978.   int i;
    4979. 

  4979. 

  4980.   str[19] = 0;
    4981. 

  4981.   if (reversed)
    4982. 

  4982.     for (i=19; i--; ) str[i] = fgetc(ifp);
    4983. 

  4983.   else
    4984. 

  4984.     fread (str, 19, 1, ifp);
    4985. 

  4985.   memset (&t, 0, sizeof t);
    4986. 

  4986.   if (sscanf (str, "%d:%d:%d %d:%d:%d", &t.tm_year, &t.tm_mon,
    4987. 

  4987. 	&t.tm_mday, &t.tm_hour, &t.tm_min, &t.tm_sec) != 6)
    4988. 

  4988.     return;
    4989. 

  4989.   t.tm_year -= 1900;
    4990. 

  4990.   t.tm_mon -= 1;
    4991. 

  4991.   t.tm_isdst = -1;
    4992. 

  4992.   if (mktime(&t) > 0)
    4993. 

  4993.     timestamp = mktime(&t);
    4994. 

  4994. }
    4995. 

  4995. 

  4996. void CLASS parse_exif (int base)
    4997. 

  4997. {
    4998. 

  4998.   unsigned kodak, entries, tag, type, len, save, c;
    4999. 

  4999.   double expo;
    5000. 

  5000. 

  5001.   kodak = !strncmp(make,"EASTMAN",7) && tiff_nifds < 3;
    5002. 

  5002.   entries = get2();
    5003. 

  5003.   while (entries--) {
    5004. 

  5004.     tiff_get (base, &tag, &type, &len, &save);
    5005. 

  5005.     switch (tag) {
    5006. 

  5006.       case 33434:  shutter = getreal(type);		break;
    5007. 

  5007.       case 33437:  aperture = getreal(type);		break;
    5008. 

  5008.       case 34855:  iso_speed = get2();			break;
    5009. 

  5009.       case 36867:
    5010. 

  5010.       case 36868:  get_timestamp(0);			break;
    5011. 

  5011.       case 37377:  if ((expo = -getreal(type)) < 128)
    5012. 

  5012. 		     shutter = pow (2.0, expo);		break;
    5013. 

  5013.       case 37378:  aperture = pow (2.0, getreal(type)/2);	break;
    5014. 

  5014.       case 37386:  focal_len = getreal(type);		break;
    5015. 

  5015.       case 37500:  parse_makernote (base, 0);		break;
    5016. 

  5016.       case 40962:  if (kodak) raw_width  = get4();	break;
    5017. 

  5017.       case 40963:  if (kodak) raw_height = get4();	break;
    5018. 

  5018.       case 41730:
    5019. 

  5019. 	if (get4() == 0x20002)
    5020. 

  5020. 	  for (exif_cfa=c=0; c < 8; c+=2)
    5021. 

  5021. 	    exif_cfa |= fgetc(ifp) * 0x01010101 << c;
    5022. 

  5022.     }
    5023. 

  5023.     fseek (ifp, save, SEEK_SET);
    5024. 

  5024.   }
    5025. 

  5025. }
    5026. 

  5026. 

  5027. void CLASS parse_gps (int base)
    5028. 

  5028. {
    5029. 

  5029.   unsigned entries, tag, type, len, save, c;
    5030. 

  5030. 

  5031.   entries = get2();
    5032. 

  5032.   while (entries--) {
    5033. 

  5033.     tiff_get (base, &tag, &type, &len, &save);
    5034. 

  5034.     switch (tag) {
    5035. 

  5035.       case 1: case 3: case 5:
    5036. 

  5036. 	gpsdata[29+tag/2] = getc(ifp);			break;
    5037. 

  5037.       case 2: case 4: case 7:
    5038. 

  5038. 	FORC(6) gpsdata[tag/3*6+c] = get4();		break;
    5039. 

  5039.       case 6:
    5040. 

  5040. 	FORC(2) gpsdata[18+c] = get4();			break;
    5041. 

  5041.       case 18: case 29:
    5042. 

  5042. 	fgets ((char *) (gpsdata+14+tag/3), MIN(len,12), ifp);
    5043. 

  5043.     }
    5044. 

  5044.     fseek (ifp, save, SEEK_SET);
    5045. 

  5045.   }
    5046. 

  5046. }
    5047. 

  5047. 

  5048. void CLASS romm_coeff (float romm_cam[3][3])
    5049. 

  5049. {
    5050. 

  5050.   static const float rgb_romm[3][3] =	/* ROMM == Kodak ProPhoto */
    5051. 

  5051.   { {  2.034193, -0.727420, -0.306766 },
    5052. 

  5052.     { -0.228811,  1.231729, -0.002922 },
    5053. 

  5053.     { -0.008565, -0.153273,  1.161839 } };
    5054. 

  5054.   int i, j, k;
    5055. 

  5055. 

  5056.   for (i=0; i < 3; i++)
    5057. 

  5057.     for (j=0; j < 3; j++)
    5058. 

  5058.       for (cmatrix[i][j] = k=0; k < 3; k++)
    5059. 

  5059. 	cmatrix[i][j] += rgb_romm[i][k] * romm_cam[k][j];
    5060. 

  5060. #ifdef LIBRAW_LIBRARY_BUILD
    5061. 

  5061.   color_flags.cmatrix_state = LIBRAW_COLORSTATE_CALCULATED;
    5062. 

  5062. #endif
    5063. 

  5063. }
    5064. 

  5064. 

  5065. void CLASS parse_mos (int offset)
    5066. 

  5066. {
    5067. 

  5067.   char data[40];
    5068. 

  5068.   int skip, from, i, c, neut[4], planes=0, frot=0;
    5069. 

  5069.   static const char *mod[] =
    5070. 

  5070.   { "","DCB2","Volare","Cantare","CMost","Valeo 6","Valeo 11","Valeo 22",
    5071. 

  5071.     "Valeo 11p","Valeo 17","","Aptus 17","Aptus 22","Aptus 75","Aptus 65",
    5072. 

  5072.     "Aptus 54S","Aptus 65S","Aptus 75S","AFi 5","AFi 6","AFi 7",
    5073. 

  5073.     "AFi-II 7","","","AFi-II 6","","","AFi-II 10","AFi-II 5"
    5074. 

  5074.     "","","","","","AFi-II 10R","AFi-II 8","","AFi-II 12"};
    5075. 

  5075. 

  5076.   float romm_cam[3][3];
    5077. 

  5077. 

  5078.   fseek (ifp, offset, SEEK_SET);
    5079. 

  5079.   while (1) {
    5080. 

  5080.     if (get4() != 0x504b5453) break;
    5081. 

  5081.     get4();
    5082. 

  5082.     fread (data, 1, 40, ifp);
    5083. 

  5083.     skip = get4();
    5084. 

  5084.     from = ftell(ifp);
    5085. 

  5085.     if (!strcmp(data,"JPEG_preview_data")) {
    5086. 

  5086.       thumb_offset = from;
    5087. 

  5087.       thumb_length = skip;
    5088. 

  5088.     }
    5089. 

  5089.     if (!strcmp(data,"icc_camera_profile")) {
    5090. 

  5090.       profile_offset = from;
    5091. 

  5091.       profile_length = skip;
    5092. 

  5092.     }
    5093. 

  5093.     if (!strcmp(data,"ShootObj_back_type")) {
    5094. 

  5094.       fscanf (ifp, "%d", &i);
    5095. 

  5095.       if ((unsigned) i < sizeof mod / sizeof (*mod))
    5096. 

  5096. 	strcpy (model, mod[i]);
    5097. 

  5097.     }
    5098. 

  5098.     if (!strcmp(data,"icc_camera_to_tone_matrix")) {
    5099. 

  5099.       for (i=0; i < 9; i++)
    5100. 

  5100. 	romm_cam[0][i] = int_to_float(get4());
    5101. 

  5101.       romm_coeff (romm_cam);
    5102. 

  5102.     }
    5103. 

  5103.     if (!strcmp(data,"CaptProf_color_matrix")) {
    5104. 

  5104.       for (i=0; i < 9; i++)
    5105. 

  5105. 	fscanf (ifp, "%f", &romm_cam[0][i]);
    5106. 

  5106.       romm_coeff (romm_cam);
    5107. 

  5107.     }
    5108. 

  5108.     if (!strcmp(data,"CaptProf_number_of_planes"))
    5109. 

  5109.       fscanf (ifp, "%d", &planes);
    5110. 

  5110.     if (!strcmp(data,"CaptProf_raw_data_rotation"))
    5111. 

  5111.       fscanf (ifp, "%d", &flip);
    5112. 

  5112.     if (!strcmp(data,"CaptProf_mosaic_pattern"))
    5113. 

  5113.       FORC4 {
    5114. 

  5114. 	fscanf (ifp, "%d", &i);
    5115. 

  5115. 	if (i == 1) frot = c ^ (c >> 1);
    5116. 

  5116.       }
    5117. 

  5117.     if (!strcmp(data,"ImgProf_rotation_angle")) {
    5118. 

  5118.       fscanf (ifp, "%d", &i);
    5119. 

  5119.       flip = i - flip;
    5120. 

  5120.     }
    5121. 

  5121.     if (!strcmp(data,"NeutObj_neutrals") && !cam_mul[0]) {
    5122. 

  5122.       FORC4 fscanf (ifp, "%d", neut+c);
    5123. 

  5123.       FORC3 cam_mul[c] = (float) neut[0] / neut[c+1];
    5124. 

  5124. #ifdef LIBRAW_LIBRARY_BUILD
    5125. 

  5125.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5126. 

  5126. #endif
    5127. 

  5127.     }
    5128. 

  5128.     if (!strcmp(data,"Rows_data"))
    5129. 

  5129.       load_flags = get4();
    5130. 

  5130.     parse_mos (from);
    5131. 

  5131.     fseek (ifp, skip+from, SEEK_SET);
    5132. 

  5132.   }
    5133. 

  5133.   if (planes)
    5134. 

  5134.     filters = (planes == 1) * 0x01010101 *
    5135. 

  5135. 	(uchar) "\x94\x61\x16\x49"[(flip/90 + frot) & 3];
    5136. 

  5136. }
    5137. 

  5137. 

  5138. void CLASS linear_table (unsigned len)
    5139. 

  5139. {
    5140. 

  5140.   int i;
    5141. 

  5141.   if (len > 0x1000) len = 0x1000;
    5142. 

  5142.   read_shorts (curve, len);
    5143. 

  5143. #ifdef LIBRAW_LIBRARY_BUILD
    5144. 

  5144.   color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    5145. 

  5145. #endif
    5146. 

  5146.   for (i=len; i < 0x1000; i++)
    5147. 

  5147.     curve[i] = curve[i-1];
    5148. 

  5148.   maximum = curve[0xfff];
    5149. 

  5149. }
    5150. 

  5150. 

  5151. void CLASS parse_kodak_ifd (int base)
    5152. 

  5152. {
    5153. 

  5153.   unsigned entries, tag, type, len, save;
    5154. 

  5154.   int i, c, wbi=-2, wbtemp=6500;
    5155. 

  5155.   float mul[3]={1,1,1}, num;
    5156. 

  5156.   static const int wbtag[] = { 64037,64040,64039,64041,-1,-1,64042 };
    5157. 

  5157. 

  5158.   entries = get2();
    5159. 

  5159.   if (entries > 1024) return;
    5160. 

  5160.   while (entries--) {
    5161. 

  5161.     tiff_get (base, &tag, &type, &len, &save);
    5162. 

  5162.     if (tag == 1020) wbi = getint(type);
    5163. 

  5163.     if (tag == 1021 && len == 72) {		/* WB set in software */
    5164. 

  5164.       fseek (ifp, 40, SEEK_CUR);
    5165. 

  5165.       FORC3 cam_mul[c] = 2048.0 / get2();
    5166. 

  5166. #ifdef LIBRAW_LIBRARY_BUILD
    5167. 

  5167.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5168. 

  5168. #endif
    5169. 

  5169.       wbi = -2;
    5170. 

  5170.     }
    5171. 

  5171.     if (tag == 2118) wbtemp = getint(type);
    5172. 

  5172.     if (tag == 2130 + wbi)
    5173. 

  5173.       FORC3 mul[c] = getreal(type);
    5174. 

  5174.     if (tag == 2140 + wbi && wbi >= 0)
    5175. 

  5175.         {
    5176. 

  5176.       FORC3 {
    5177. 

  5177. 	for (num=i=0; i < 4; i++)
    5178. 

  5178. 	  num += getreal(type) * pow (wbtemp/100.0, i);
    5179. 

  5179. 	cam_mul[c] = 2048 / (num * mul[c]);
    5180. 

  5180.       }
    5181. 

  5181. #ifdef LIBRAW_LIBRARY_BUILD
    5182. 

  5182.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5183. 

  5183. #endif
    5184. 

  5184.         }
    5185. 

  5185.     if (tag == 2317) linear_table (len);
    5186. 

  5186.     if (tag == 6020) iso_speed = getint(type);
    5187. 

  5187.     if (tag == 64013) wbi = fgetc(ifp);
    5188. 

  5188.     if ((unsigned) wbi < 7 && tag == wbtag[wbi])
    5189. 

  5189.       FORC3 cam_mul[c] = get4();
    5190. 

  5190.     if (tag == 64019) width = getint(type);
    5191. 

  5191.     if (tag == 64020) height = (getint(type)+1) & -2;
    5192. 

  5192.     fseek (ifp, save, SEEK_SET);
    5193. 

  5193.   }
    5194. 

  5194. }
    5195. 

  5195. 

  5196. int CLASS parse_tiff_ifd (int base)
    5197. 

  5197. {
    5198. 

  5198.   unsigned entries, tag, type, len, plen=16, save;
    5199. 

  5199.   int ifd, use_cm=0, cfa, i, j, c, ima_len=0;
    5200. 

  5200.   int blrr=1, blrc=1, dblack[] = { 0,0,0,0 };
    5201. 

  5201.   char software[64], *cbuf, *cp;
    5202. 

  5202.   uchar cfa_pat[16], cfa_pc[] = { 0,1,2,3 }, tab[256];
    5203. 

  5203.   double cc[4][4], cm[4][3], cam_xyz[4][3], num;
    5204. 

  5204.   double ab[]={ 1,1,1,1 }, asn[] = { 0,0,0,0 }, xyz[] = { 1,1,1 };
    5205. 

  5205.   unsigned sony_curve[] = { 0,0,0,0,0,4095 };
    5206. 

  5206.   unsigned *buf, sony_offset=0, sony_length=0, sony_key=0;
    5207. 

  5207.   struct jhead jh;
    5208. 

  5208. #ifndef LIBRAW_LIBRARY_BUILD
    5209. 

  5209.   FILE *sfp;
    5210. 

  5210. #endif
    5211. 

  5211. 

  5212.   if (tiff_nifds >= sizeof tiff_ifd / sizeof tiff_ifd[0])
    5213. 

  5213.     return 1;
    5214. 

  5214.   ifd = tiff_nifds++;
    5215. 

  5215.   for (j=0; j < 4; j++)
    5216. 

  5216.     for (i=0; i < 4; i++)
    5217. 

  5217.       cc[j][i] = i == j;
    5218. 

  5218.   entries = get2();
    5219. 

  5219.   if (entries > 512) return 1;
    5220. 

  5220.   while (entries--) {
    5221. 

  5221.     tiff_get (base, &tag, &type, &len, &save);
    5222. 

  5222.     switch (tag) {
    5223. 

  5223.       case 5:   width  = get2();  break;
    5224. 

  5224.       case 6:   height = get2();  break;
    5225. 

  5225.       case 7:   width += get2();  break;
    5226. 

  5226.       case 9:  filters = get2();  break;
    5227. 

  5227.       case 17: case 18:
    5228. 

  5228. 	if (type == 3 && len == 1)
    5229. 

  5229.             {
    5230. 

  5230. 	  cam_mul[(tag-17)*2] = get2() / 256.0;
    5231. 

  5231. #ifdef LIBRAW_LIBRARY_BUILD
    5232. 

  5232.           color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5233. 

  5233. #endif
    5234. 

  5234.             }
    5235. 

  5235. 	break;
    5236. 

  5236.       case 23:
    5237. 

  5237. 	if (type == 3) iso_speed = get2();
    5238. 

  5238. 	break;
    5239. 

  5239.       case 36: case 37: case 38:
    5240. 

  5240. 	cam_mul[tag-0x24] = get2();
    5241. 

  5241. 	break;
    5242. 

  5242.       case 39:
    5243. 

  5243. 	if (len < 50 || cam_mul[0]) break;
    5244. 

  5244. 	fseek (ifp, 12, SEEK_CUR);
    5245. 

  5245. 	FORC3 cam_mul[c] = get2();
    5246. 

  5246. #ifdef LIBRAW_LIBRARY_BUILD
    5247. 

  5247.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5248. 

  5248. #endif
    5249. 

  5249. 	break;
    5250. 

  5250.       case 46:
    5251. 

  5251. 	if (type != 7 || fgetc(ifp) != 0xff || fgetc(ifp) != 0xd8) break;
    5252. 

  5252. 	thumb_offset = ftell(ifp) - 2;
    5253. 

  5253. 	thumb_length = len;
    5254. 

  5254. 	break;
    5255. 

  5255.       case 61440:			/* Fuji HS10 table */
    5256. 

  5256. 	parse_tiff_ifd (base);
    5257. 

  5257. 	break;
    5258. 

  5258.       case 2: case 256: case 61441:	/* ImageWidth */
    5259. 

  5259. 	tiff_ifd[ifd].t_width = getint(type);
    5260. 

  5260. 	break;
    5261. 

  5261.       case 3: case 257: case 61442:	/* ImageHeight */
    5262. 

  5262. 	tiff_ifd[ifd].t_height = getint(type);
    5263. 

  5263. 	break;
    5264. 

  5264.       case 258:				/* BitsPerSample */
    5265. 

  5265.       case 61443:
    5266. 

  5266. 	tiff_ifd[ifd].samples = len & 7;
    5267. 

  5267. 	tiff_ifd[ifd].bps = getint(type);
    5268. 

  5268. 	break;
    5269. 

  5269.       case 61446:
    5270. 

  5270. 	raw_height = 0;
    5271. 

  5271. 	load_raw = &CLASS packed_load_raw;
    5272. 

  5272. 	load_flags = get4() && (filters=0x16161616) ? 24:80;
    5273. 

  5273. 	break;
    5274. 

  5274.       case 259:				/* Compression */
    5275. 

  5275. 	tiff_ifd[ifd].comp = get2();
    5276. 

  5276. 	break;
    5277. 

  5277.       case 262:				/* PhotometricInterpretation */
    5278. 

  5278. 	tiff_ifd[ifd].phint = get2();
    5279. 

  5279. 	break;
    5280. 

  5280.       case 270:				/* ImageDescription */
    5281. 

  5281. 	fread (desc, 512, 1, ifp);
    5282. 

  5282. 	break;
    5283. 

  5283.       case 271:				/* Make */
    5284. 

  5284. 	fgets (make, 64, ifp);
    5285. 

  5285. 	break;
    5286. 

  5286.       case 272:				/* Model */
    5287. 

  5287. 	fgets (model, 64, ifp);
    5288. 

  5288. 	break;
    5289. 

  5289.       case 280:				/* Panasonic RW2 offset */
    5290. 

  5290. 	if (type != 4) break;
    5291. 

  5291. 	load_raw = &CLASS panasonic_load_raw;
    5292. 

  5292. 	load_flags = 0x2008;
    5293. 

  5293.       case 273:				/* StripOffset */
    5294. 

  5294.       case 513:				/* JpegIFOffset */
    5295. 

  5295.       case 61447:
    5296. 

  5296. 	tiff_ifd[ifd].offset = get4()+base;
    5297. 

  5297. 	if (!tiff_ifd[ifd].bps && tiff_ifd[ifd].offset > 0) {
    5298. 

  5298. 	  fseek (ifp, tiff_ifd[ifd].offset, SEEK_SET);
    5299. 

  5299. 	  if (ljpeg_start (&jh, 1)) {
    5300. 

  5300. 	    tiff_ifd[ifd].comp    = 6;
    5301. 

  5301. 	    tiff_ifd[ifd].t_width   = jh.wide;
    5302. 

  5302. 	    tiff_ifd[ifd].t_height  = jh.high;
    5303. 

  5303. 	    tiff_ifd[ifd].bps     = jh.bits;
    5304. 

  5304. 	    tiff_ifd[ifd].samples = jh.clrs;
    5305. 

  5305. 	    if (!(jh.sraw || (jh.clrs & 1)))
    5306. 

  5306. 	      tiff_ifd[ifd].t_width *= jh.clrs;
    5307. 

  5307. 	    i = order;
    5308. 

  5308. 	    parse_tiff (tiff_ifd[ifd].offset + 12);
    5309. 

  5309. 	    order = i;
    5310. 

  5310. 	  }
    5311. 

  5311. 	}
    5312. 

  5312. 	break;
    5313. 

  5313.       case 274:				/* Orientation */
    5314. 

  5314. 	tiff_ifd[ifd].t_flip = "50132467"[get2() & 7]-'0';
    5315. 

  5315. 	break;
    5316. 

  5316.       case 277:				/* SamplesPerPixel */
    5317. 

  5317. 	tiff_ifd[ifd].samples = getint(type) & 7;
    5318. 

  5318. 	break;
    5319. 

  5319.       case 279:				/* StripByteCounts */
    5320. 

  5320.       case 514:
    5321. 

  5321.       case 61448:
    5322. 

  5322. 	tiff_ifd[ifd].bytes = get4();
    5323. 

  5323. 	break;
    5324. 

  5324.       case 61454:
    5325. 

  5325. 	FORC3 cam_mul[(4-c) % 3] = getint(type);
    5326. 

  5326. 	break;
    5327. 

  5327.       case 305:  case 11:		/* Software */
    5328. 

  5328. 	fgets (software, 64, ifp);
    5329. 

  5329. 	if (!strncmp(software,"Adobe",5) ||
    5330. 

  5330. 	    !strncmp(software,"dcraw",5) ||
    5331. 

  5331. 	    !strncmp(software,"UFRaw",5) ||
    5332. 

  5332. 	    !strncmp(software,"Bibble",6) ||
    5333. 

  5333. 	    !strncmp(software,"Nikon Scan",10) ||
    5334. 

  5334. 	    !strcmp (software,"Digital Photo Professional"))
    5335. 

  5335. 	  is_raw = 0;
    5336. 

  5336. 	break;
    5337. 

  5337.       case 306:				/* DateTime */
    5338. 

  5338. 	get_timestamp(0);
    5339. 

  5339. 	break;
    5340. 

  5340.       case 315:				/* Artist */
    5341. 

  5341. 	fread (artist, 64, 1, ifp);
    5342. 

  5342. 	break;
    5343. 

  5343.       case 322:				/* TileWidth */
    5344. 

  5344. 	tile_width = getint(type);
    5345. 

  5345. 	break;
    5346. 

  5346.       case 323:				/* TileLength */
    5347. 

  5347. 	tile_length = getint(type);
    5348. 

  5348. 	break;
    5349. 

  5349.       case 324:				/* TileOffsets */
    5350. 

  5350. 	tiff_ifd[ifd].offset = len > 1 ? ftell(ifp) : get4();
    5351. 

  5351. 	if (len == 4) {
    5352. 

  5352. 	  load_raw = &CLASS sinar_4shot_load_raw;
    5353. 

  5353. 	  is_raw = 5;
    5354. 

  5354. 	}
    5355. 

  5355. 	break;
    5356. 

  5356. #ifdef LIBRAW_LIBRARY_BUILD
    5357. 

  5357.       case 325:				/* TileByteCount */
    5358. 

  5358.           tiff_ifd[ifd].tile_maxbytes = 0;
    5359. 

  5359.           for(int jj=0;jj<len;jj++)
    5360. 

  5360.               {
    5361. 

  5361.                   int s = get4();
    5362. 

  5362.                   if(s > tiff_ifd[ifd].tile_maxbytes) tiff_ifd[ifd].tile_maxbytes=s;
    5363. 

  5363.               }
    5364. 

  5364. 	break;
    5365. 

  5365. #endif
    5366. 

  5366.       case 330:				/* SubIFDs */
    5367. 

  5367. 	if (!strcmp(model,"DSLR-A100") && tiff_ifd[ifd].t_width == 3872) {
    5368. 

  5368. 	  load_raw = &CLASS sony_arw_load_raw;
    5369. 

  5369. 	  data_offset = get4()+base;
    5370. 

  5370. 	  ifd++;  break;
    5371. 

  5371. 	}
    5372. 

  5372. 	while (len--) {
    5373. 

  5373. 	  i = ftell(ifp);
    5374. 

  5374. 	  fseek (ifp, get4()+base, SEEK_SET);
    5375. 

  5375. 	  if (parse_tiff_ifd (base)) break;
    5376. 

  5376. 	  fseek (ifp, i+4, SEEK_SET);
    5377. 

  5377. 	}
    5378. 

  5378. 	break;
    5379. 

  5379.       case 400:
    5380. 

  5380. 	strcpy (make, "Sarnoff");
    5381. 

  5381. 	maximum = 0xfff;
    5382. 

  5382. 	break;
    5383. 

  5383.       case 28688:
    5384. 

  5384. 	FORC4 sony_curve[c+1] = get2() >> 2 & 0xfff;
    5385. 

  5385. 	for (i=0; i < 5; i++)
    5386. 

  5386. 	  for (j = sony_curve[i]+1; j <= sony_curve[i+1]; j++)
    5387. 

  5387. 	    curve[j] = curve[j-1] + (1 << i);
    5388. 

  5388. #ifdef LIBRAW_LIBRARY_BUILD
    5389. 

  5389.         color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    5390. 

  5390. #endif
    5391. 

  5391. 	break;
    5392. 

  5392.       case 29184: sony_offset = get4();  break;
    5393. 

  5393.       case 29185: sony_length = get4();  break;
    5394. 

  5394.       case 29217: sony_key    = get4();  break;
    5395. 

  5395.       case 29264:
    5396. 

  5396. 	parse_minolta (ftell(ifp));
    5397. 

  5397. 	raw_width = 0;
    5398. 

  5398. 	break;
    5399. 

  5399.       case 29443:
    5400. 

  5400. 	FORC4 cam_mul[c ^ (c < 2)] = get2();
    5401. 

  5401. #ifdef LIBRAW_LIBRARY_BUILD
    5402. 

  5402.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5403. 

  5403. #endif
    5404. 

  5404. 	break;
    5405. 

  5405.       case 29459:
    5406. 

  5406.        FORC4 cam_mul[c] = get2();
    5407. 

  5407.        i = (cam_mul[1] == 1024 && cam_mul[2] == 1024) << 1;
    5408. 

  5408.        SWAP (cam_mul[i],cam_mul[i+1])
    5409. 

  5409. #ifdef LIBRAW_LIBRARY_BUILD
    5410. 

  5410.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5411. 

  5411. #endif
    5412. 

  5412. 	break;
    5413. 

  5413.       case 33405:			/* Model2 */
    5414. 

  5414. 	fgets (model2, 64, ifp);
    5415. 

  5415. 	break;
    5416. 

  5416.       case 33422:			/* CFAPattern */
    5417. 

  5417.       case 64777:			/* Kodak P-series */
    5418. 

  5418. 	if ((plen=len) > 16) plen = 16;
    5419. 

  5419. 	fread (cfa_pat, 1, plen, ifp);
    5420. 

  5420. 	for (colors=cfa=i=0; i < plen; i++) {
    5421. 

  5421. 	  colors += !(cfa & (1 << cfa_pat[i]));
    5422. 

  5422. 	  cfa |= 1 << cfa_pat[i];
    5423. 

  5423. 	}
    5424. 

  5424. 	if (cfa == 070) memcpy (cfa_pc,"\003\004\005",3);	/* CMY */
    5425. 

  5425. 	if (cfa == 072) memcpy (cfa_pc,"\005\003\004\001",4);	/* GMCY */
    5426. 

  5426. 	goto guess_cfa_pc;
    5427. 

  5427.       case 33424:
    5428. 

  5428.       case 65024:
    5429. 

  5429. 	fseek (ifp, get4()+base, SEEK_SET);
    5430. 

  5430. 	parse_kodak_ifd (base);
    5431. 

  5431. 	break;
    5432. 

  5432.       case 33434:			/* ExposureTime */
    5433. 

  5433. 	shutter = getreal(type);
    5434. 

  5434. 	break;
    5435. 

  5435.       case 33437:			/* FNumber */
    5436. 

  5436. 	aperture = getreal(type);
    5437. 

  5437. 	break;
    5438. 

  5438.       case 34306:			/* Leaf white balance */
    5439. 

  5439. 	FORC4 cam_mul[c ^ 1] = 4096.0 / get2();
    5440. 

  5440. #ifdef LIBRAW_LIBRARY_BUILD
    5441. 

  5441.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5442. 

  5442. #endif
    5443. 

  5443. 	break;
    5444. 

  5444.       case 34307:			/* Leaf CatchLight color matrix */
    5445. 

  5445. 	fread (software, 1, 7, ifp);
    5446. 

  5446. 	if (strncmp(software,"MATRIX",6)) break;
    5447. 

  5447. 	colors = 4;
    5448. 

  5448. 	for (raw_color = i=0; i < 3; i++) {
    5449. 

  5449. 	  FORC4 fscanf (ifp, "%f", &rgb_cam[i][c^1]);
    5450. 

  5450. 	  if (!use_camera_wb) continue;
    5451. 

  5451. 	  num = 0;
    5452. 

  5452. 	  FORC4 num += rgb_cam[i][c];
    5453. 

  5453. 	  FORC4 rgb_cam[i][c] /= num;
    5454. 

  5454. #ifdef LIBRAW_LIBRARY_BUILD
    5455. 

  5455.           color_flags.rgb_cam_state = LIBRAW_COLORSTATE_LOADED;
    5456. 

  5456. #endif
    5457. 

  5457. 	}
    5458. 

  5458. 	break;
    5459. 

  5459.       case 34310:			/* Leaf metadata */
    5460. 

  5460. 	parse_mos (ftell(ifp));
    5461. 

  5461.       case 34303:
    5462. 

  5462. 	strcpy (make, "Leaf");
    5463. 

  5463. 	break;
    5464. 

  5464.       case 34665:			/* EXIF tag */
    5465. 

  5465. 	fseek (ifp, get4()+base, SEEK_SET);
    5466. 

  5466. 	parse_exif (base);
    5467. 

  5467. 	break;
    5468. 

  5468.       case 34853:			/* GPSInfo tag */
    5469. 

  5469. 	fseek (ifp, get4()+base, SEEK_SET);
    5470. 

  5470. 	parse_gps (base);
    5471. 

  5471. 	break;
    5472. 

  5472.       case 34675:			/* InterColorProfile */
    5473. 

  5473.       case 50831:			/* AsShotICCProfile */
    5474. 

  5474. 	profile_offset = ftell(ifp);
    5475. 

  5475. 	profile_length = len;
    5476. 

  5476. 	break;
    5477. 

  5477.       case 37122:			/* CompressedBitsPerPixel */
    5478. 

  5478. 	kodak_cbpp = get4();
    5479. 

  5479. 	break;
    5480. 

  5480.       case 37386:			/* FocalLength */
    5481. 

  5481. 	focal_len = getreal(type);
    5482. 

  5482. 	break;
    5483. 

  5483.       case 37393:			/* ImageNumber */
    5484. 

  5484. 	shot_order = getint(type);
    5485. 

  5485. 	break;
    5486. 

  5486.       case 37400:			/* old Kodak KDC tag */
    5487. 

  5487. 	for (raw_color = i=0; i < 3; i++) {
    5488. 

  5488. 	  getreal(type);
    5489. 

  5489. 	  FORC3 rgb_cam[i][c] = getreal(type);
    5490. 

  5490. 	}
    5491. 

  5491. #ifdef LIBRAW_LIBRARY_BUILD
    5492. 

  5492.         color_flags.rgb_cam_state = LIBRAW_COLORSTATE_LOADED;
    5493. 

  5493. #endif
    5494. 

  5494. 	break;
    5495. 

  5495.       case 46275:			/* Imacon tags */
    5496. 

  5496. 	strcpy (make, "Imacon");
    5497. 

  5497. 	data_offset = ftell(ifp);
    5498. 

  5498. 	ima_len = len;
    5499. 

  5499. 	break;
    5500. 

  5500.       case 46279:
    5501. 

  5501. 	if (!ima_len) break;
    5502. 

  5502. 	fseek (ifp, 78, SEEK_CUR);
    5503. 

  5503. 	raw_width  = get4();
    5504. 

  5504. 	raw_height = get4();
    5505. 

  5505. 	left_margin = get4() & 7;
    5506. 

  5506. 	width = raw_width - left_margin - (get4() & 7);
    5507. 

  5507. 	top_margin = get4() & 7;
    5508. 

  5508. 	height = raw_height - top_margin - (get4() & 7);
    5509. 

  5509. 	if (raw_width == 7262) {
    5510. 

  5510. 	  height = 5444;
    5511. 

  5511. 	  width  = 7244;
    5512. 

  5512. 	  left_margin = 7;
    5513. 

  5513. 	}
    5514. 

  5514. 	fseek (ifp, 52, SEEK_CUR);
    5515. 

  5515. 	FORC3 cam_mul[c] = getreal(11);
    5516. 

  5516. #ifdef LIBRAW_LIBRARY_BUILD
    5517. 

  5517.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5518. 

  5518. #endif
    5519. 

  5519. 	fseek (ifp, 114, SEEK_CUR);
    5520. 

  5520. 	flip = (get2() >> 7) * 90;
    5521. 

  5521. 	if (width * height * 6 == ima_len) {
    5522. 

  5522. 	  if (flip % 180 == 90) SWAP(width,height);
    5523. 

  5523. 	  filters = flip = 0;
    5524. 

  5524. 	}
    5525. 

  5525. 	sprintf (model, "Ixpress %d-Mp", height*width/1000000);
    5526. 

  5526. 	load_raw = &CLASS imacon_full_load_raw;
    5527. 

  5527. 	if (filters) {
    5528. 

  5528. 	  if (left_margin & 1) filters = 0x61616161;
    5529. 

  5529. 	  load_raw = &CLASS unpacked_load_raw;
    5530. 

  5530. 	}
    5531. 

  5531. 	maximum = 0xffff;
    5532. 

  5532. 	break;
    5533. 

  5533.       case 50454:			/* Sinar tag */
    5534. 

  5534.       case 50455:
    5535. 

  5535. 	if (!(cbuf = (char *) malloc(len))) break;
    5536. 

  5536. 	fread (cbuf, 1, len, ifp);
    5537. 

  5537. 	for (cp = cbuf-1; cp && cp < cbuf+len; cp = strchr(cp,'\n'))
    5538. 

  5538. 	  if (!strncmp (++cp,"Neutral ",8))
    5539. 

  5539.               {
    5540. 

  5540. 	    sscanf (cp+8, "%f %f %f", cam_mul, cam_mul+1, cam_mul+2);
    5541. 

  5541. #ifdef LIBRAW_LIBRARY_BUILD
    5542. 

  5542.             color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5543. 

  5543. #endif
    5544. 

  5544.               }
    5545. 

  5545. 	free (cbuf);
    5546. 

  5546. 	break;
    5547. 

  5547.       case 50458:
    5548. 

  5548. 	if (!make[0]) strcpy (make, "Hasselblad");
    5549. 

  5549. 	break;
    5550. 

  5550.       case 50459:			/* Hasselblad tag */
    5551. 

  5551. 	i = order;
    5552. 

  5552. 	j = ftell(ifp);
    5553. 

  5553. 	c = tiff_nifds;
    5554. 

  5554. 	order = get2();
    5555. 

  5555. 	fseek (ifp, j+(get2(),get4()), SEEK_SET);
    5556. 

  5556. 	parse_tiff_ifd (j);
    5557. 

  5557. 	maximum = 0xffff;
    5558. 

  5558. 	tiff_nifds = c;
    5559. 

  5559. 	order = i;
    5560. 

  5560. 	break;
    5561. 

  5561.       case 50706:			/* DNGVersion */
    5562. 

  5562. 	FORC4 dng_version = (dng_version << 8) + fgetc(ifp);
    5563. 

  5563. 	if (!make[0]) strcpy (make, "DNG");
    5564. 

  5564. 	is_raw = 1;
    5565. 

  5565. 	break;
    5566. 

  5566.       case 50710:			/* CFAPlaneColor */
    5567. 

  5567. 	if (len > 4) len = 4;
    5568. 

  5568. 	colors = len;
    5569. 

  5569. 	fread (cfa_pc, 1, colors, ifp);
    5570. 

  5570. guess_cfa_pc:
    5571. 

  5571. 	FORCC tab[cfa_pc[c]] = c;
    5572. 

  5572. 	cdesc[c] = 0;
    5573. 

  5573. 	for (i=16; i--; )
    5574. 

  5574. 	  filters = filters << 2 | tab[cfa_pat[i % plen]];
    5575. 

  5575. 	break;
    5576. 

  5576.       case 50711:			/* CFALayout */
    5577. 

  5577. 	if (get2() == 2) {
    5578. 

  5578. 	  fuji_width = 1;
    5579. 

  5579. 	  filters = 0x49494949;
    5580. 

  5580. 	}
    5581. 

  5581. 	break;
    5582. 

  5582.       case 291:
    5583. 

  5583.       case 50712:			/* LinearizationTable */
    5584. 

  5584. 	linear_table (len);
    5585. 

  5585. 	break;
    5586. 

  5586.       case 50713:			/* BlackLevelRepeatDim */
    5587. 

  5587. 	blrr = get2();
    5588. 

  5588. 	blrc = get2();
    5589. 

  5589. 	break;
    5590. 

  5590.       case 61450:
    5591. 

  5591. 	blrr = blrc = 2;
    5592. 

  5592.       case 50714:			/* BlackLevel */
    5593. 

  5593. 	black = getreal(type);
    5594. 

  5594. 	if (!filters || !~filters) break;
    5595. 

  5595. 	dblack[0] = black;
    5596. 

  5596. 	dblack[1] = (blrc == 2) ? getreal(type):dblack[0];
    5597. 

  5597. 	dblack[2] = (blrr == 2) ? getreal(type):dblack[0];
    5598. 

  5598. 	dblack[3] = (blrc == 2 && blrr == 2) ? getreal(type):dblack[1];
    5599. 

  5599. 	if (colors == 3)
    5600. 

  5600. 	  filters |= ((filters >> 2 & 0x22222222) |
    5601. 

  5601. 		      (filters << 2 & 0x88888888)) & filters << 1;
    5602. 

  5602. 	FORC4 cblack[filters >> (c << 1) & 3] = dblack[c];
    5603. 

  5603. 	black = 0;
    5604. 

  5604. 	break;
    5605. 

  5605.       case 50715:			/* BlackLevelDeltaH */
    5606. 

  5606.       case 50716:			/* BlackLevelDeltaV */
    5607. 

  5607. 	for (num=i=0; i < len; i++)
    5608. 

  5608. 	  num += getreal(type);
    5609. 

  5609. 	black += num/len + 0.5;
    5610. 

  5610. 	break;
    5611. 

  5611.       case 50717:			/* WhiteLevel */
    5612. 

  5612. 	maximum = getint(type);
    5613. 

  5613. 	break;
    5614. 

  5614.       case 50718:			/* DefaultScale */
    5615. 

  5615. 	pixel_aspect  = getreal(type);
    5616. 

  5616. 	pixel_aspect /= getreal(type);
    5617. 

  5617. 	break;
    5618. 

  5618.       case 50721:			/* ColorMatrix1 */
    5619. 

  5619.       case 50722:			/* ColorMatrix2 */
    5620. 

  5620. 	FORCC for (j=0; j < 3; j++)
    5621. 

  5621. 	  cm[c][j] = getreal(type);
    5622. 

  5622. 	use_cm = 1;
    5623. 

  5623. 	break;
    5624. 

  5624.       case 50723:			/* CameraCalibration1 */
    5625. 

  5625.       case 50724:			/* CameraCalibration2 */
    5626. 

  5626. 	for (i=0; i < colors; i++)
    5627. 

  5627. 	  FORCC cc[i][c] = getreal(type);
    5628. 

  5628. 	break;
    5629. 

  5629.       case 50727:			/* AnalogBalance */
    5630. 

  5630. 	FORCC ab[c] = getreal(type);
    5631. 

  5631. 	break;
    5632. 

  5632.       case 50728:			/* AsShotNeutral */
    5633. 

  5633. 	FORCC asn[c] = getreal(type);
    5634. 

  5634. 	break;
    5635. 

  5635.       case 50729:			/* AsShotWhiteXY */
    5636. 

  5636. 	xyz[0] = getreal(type);
    5637. 

  5637. 	xyz[1] = getreal(type);
    5638. 

  5638. 	xyz[2] = 1 - xyz[0] - xyz[1];
    5639. 

  5639. 	FORC3 xyz[c] /= d65_white[c];
    5640. 

  5640. 	break;
    5641. 

  5641.       case 50740:			/* DNGPrivateData */
    5642. 

  5642. 	if (dng_version) break;
    5643. 

  5643. 	parse_minolta (j = get4()+base);
    5644. 

  5644. 	fseek (ifp, j, SEEK_SET);
    5645. 

  5645. 	parse_tiff_ifd (base);
    5646. 

  5646. 	break;
    5647. 

  5647.       case 50752:
    5648. 

  5648. 	read_shorts (cr2_slice, 3);
    5649. 

  5649. 	break;
    5650. 

  5650.       case 50829:			/* ActiveArea */
    5651. 

  5651. 	top_margin = getint(type);
    5652. 

  5652. 	left_margin = getint(type);
    5653. 

  5653. 	height = getint(type) - top_margin;
    5654. 

  5654. 	width = getint(type) - left_margin;
    5655. 

  5655. 	break;
    5656. 

  5656.       case 64772:			/* Kodak P-series */
    5657. 

  5657. 	if (len < 13) break;
    5658. 

  5658. 	fseek (ifp, 16, SEEK_CUR);
    5659. 

  5659. 	data_offset = get4();
    5660. 

  5660. 	fseek (ifp, 28, SEEK_CUR);
    5661. 

  5661. 	data_offset += get4();
    5662. 

  5662. 	load_raw = &CLASS packed_load_raw;
    5663. 

  5663. 	break;
    5664. 

  5664.       case 65026:
    5665. 

  5665. 	if (type == 2) fgets (model2, 64, ifp);
    5666. 

  5666.     }
    5667. 

  5667.     fseek (ifp, save, SEEK_SET);
    5668. 

  5668.   }
    5669. 

  5669.   if (sony_length && (buf = (unsigned *) malloc(sony_length))) {
    5670. 

  5670.     fseek (ifp, sony_offset, SEEK_SET);
    5671. 

  5671.     fread (buf, sony_length, 1, ifp);
    5672. 

  5672.     sony_decrypt (buf, sony_length/4, 1, sony_key);
    5673. 

  5673. #ifndef LIBRAW_LIBRARY_BUILD
    5674. 

  5674.     sfp = ifp;
    5675. 

  5675.     if ((ifp = tmpfile())) {
    5676. 

  5676.       fwrite (buf, sony_length, 1, ifp);
    5677. 

  5677.       fseek (ifp, 0, SEEK_SET);
    5678. 

  5678.       parse_tiff_ifd (-sony_offset);
    5679. 

  5679.       fclose (ifp);
    5680. 

  5680.     }
    5681. 

  5681.     ifp = sfp;
    5682. 

  5682. #else
    5683. 

  5683.     if( !ifp->tempbuffer_open(buf,sony_length))
    5684. 

  5684.         {
    5685. 

  5685.             parse_tiff_ifd(-sony_offset);
    5686. 

  5686.             ifp->tempbuffer_close();
    5687. 

  5687.         }
    5688. 

  5688. #endif
    5689. 

  5689.     free (buf);
    5690. 

  5690.   }
    5691. 

  5691.   for (i=0; i < colors; i++)
    5692. 

  5692.     FORCC cc[i][c] *= ab[i];
    5693. 

  5693.   if (use_cm) {
    5694. 

  5694.     FORCC for (i=0; i < 3; i++)
    5695. 

  5695.       for (cam_xyz[c][i]=j=0; j < colors; j++)
    5696. 

  5696. 	cam_xyz[c][i] += cc[c][j] * cm[j][i] * xyz[i];
    5697. 

  5697.     cam_xyz_coeff (cam_xyz);
    5698. 

  5698.   }
    5699. 

  5699.   if (asn[0]) {
    5700. 

  5700.     cam_mul[3] = 0;
    5701. 

  5701.     FORCC cam_mul[c] = 1 / asn[c];
    5702. 

  5702. #ifdef LIBRAW_LIBRARY_BUILD
    5703. 

  5703.     color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5704. 

  5704. #endif
    5705. 

  5705.   }
    5706. 

  5706.   if (!use_cm)
    5707. 

  5707.       {
    5708. 

  5708.     FORCC pre_mul[c] /= cc[c][c];
    5709. 

  5709. #ifdef LIBRAW_LIBRARY_BUILD
    5710. 

  5710.     color_flags.pre_mul_state = LIBRAW_COLORSTATE_LOADED;
    5711. 

  5711. #endif
    5712. 

  5712.       }
    5713. 

  5713. 

  5714.   return 0;
    5715. 

  5715. }
    5716. 

  5716. 

  5717. int CLASS parse_tiff (int base)
    5718. 

  5718. {
    5719. 

  5719.   int doff;
    5720. 

  5720. 

  5721.   fseek (ifp, base, SEEK_SET);
    5722. 

  5722.   order = get2();
    5723. 

  5723.   if (order != 0x4949 && order != 0x4d4d) return 0;
    5724. 

  5724.   get2();
    5725. 

  5725.   while ((doff = get4())) {
    5726. 

  5726.     fseek (ifp, doff+base, SEEK_SET);
    5727. 

  5727.     if (parse_tiff_ifd (base)) break;
    5728. 

  5728.   }
    5729. 

  5729.   return 1;
    5730. 

  5730. }
    5731. 

  5731. 

  5732. void CLASS apply_tiff()
    5733. 

  5733. {
    5734. 

  5734.   int max_samp=0, raw=-1, thm=-1, i,max_bps=0;
    5735. 

  5735.   struct jhead jh;
    5736. 

  5736. 

  5737.   thumb_misc = 16;
    5738. 

  5738.   if (thumb_offset) {
    5739. 

  5739.     fseek (ifp, thumb_offset, SEEK_SET);
    5740. 

  5740.     if (ljpeg_start (&jh, 1)) {
    5741. 

  5741.       thumb_misc   = jh.bits;
    5742. 

  5742.       thumb_width  = jh.wide;
    5743. 

  5743.       thumb_height = jh.high;
    5744. 

  5744.     }
    5745. 

  5745.   }
    5746. 

  5746.   for (i=0; i < tiff_nifds; i++) {
    5747. 

  5747.     if (max_samp < tiff_ifd[i].samples)
    5748. 

  5748. 	max_samp = tiff_ifd[i].samples;
    5749. 

  5749.     if (max_samp > 3) max_samp = 3;
    5750. 

  5750.     if (max_bps < tiff_ifd[i].bps)
    5751. 

  5751.         max_bps = tiff_ifd[i].bps;
    5752. 

  5752.     if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3) &&
    5753. 

  5753. 	(tiff_ifd[i].t_width | tiff_ifd[i].t_height) < 0x10000 &&
    5754. 

  5754. 	tiff_ifd[i].t_width*tiff_ifd[i].t_height > raw_width*raw_height) {
    5755. 

  5755.       raw_width     = tiff_ifd[i].t_width;
    5756. 

  5756.       raw_height    = tiff_ifd[i].t_height;
    5757. 

  5757.       tiff_bps      = tiff_ifd[i].bps;
    5758. 

  5758.       tiff_compress = tiff_ifd[i].comp;
    5759. 

  5759.       data_offset   = tiff_ifd[i].offset;
    5760. 

  5760.       tiff_flip     = tiff_ifd[i].t_flip;
    5761. 

  5761.       tiff_samples  = tiff_ifd[i].samples;
    5762. 

  5762. #ifdef LIBRAW_LIBRARY_BUILD
    5763. 

  5763.       data_size     = tile_length < INT_MAX ? tiff_ifd[i].tile_maxbytes: tiff_ifd[i].bytes;
    5764. 

  5764. #endif
    5765. 

  5765.       raw = i;
    5766. 

  5766.     }
    5767. 

  5767.   }
    5768. 

  5768.   for (i=tiff_nifds; i--; )
    5769. 

  5769.     if (tiff_ifd[i].t_flip) tiff_flip = tiff_ifd[i].t_flip;
    5770. 

  5770.   if (raw >= 0 && !load_raw)
    5771. 

  5771.     switch (tiff_compress) {
    5772. 

  5772.       case 0:  case 1:
    5773. 

  5773. 	switch (tiff_bps) {
    5774. 

  5774. 	  case  8: load_raw = &CLASS eight_bit_load_raw;	break;
    5775. 

  5775. 	  case 12: load_raw = &CLASS packed_load_raw;
    5776. 

  5776. 		   if (tiff_ifd[raw].phint == 2)
    5777. 

  5777. 		     load_flags = 6;
    5778. 

  5778. 		   if (strncmp(make,"PENTAX",6)) break;
    5779. 

  5779. 	  case 14:
    5780. 

  5780. 	  case 16: load_raw = &CLASS unpacked_load_raw;		break;
    5781. 

  5781. 	}
    5782. 

  5782. 	if (tiff_ifd[raw].bytes*5 == raw_width*raw_height*8) {
    5783. 

  5783. 	  tiff_bps = 12;
    5784. 

  5784. 	  load_raw = &CLASS packed_load_raw;
    5785. 

  5785. 	  load_flags = 81;
    5786. 

  5786. 	}
    5787. 

  5787. 	break;
    5788. 

  5788.       case 6:  case 7:  case 99:
    5789. 

  5789. 	load_raw = &CLASS lossless_jpeg_load_raw;		break;
    5790. 

  5790.       case 262:
    5791. 

  5791. 	load_raw = &CLASS kodak_262_load_raw;			break;
    5792. 

  5792.       case 32767:
    5793. 

  5793. 	if (tiff_ifd[raw].bytes == raw_width*raw_height) {
    5794. 

  5794. 	  tiff_bps = 12;
    5795. 

  5795. 	  load_raw = &CLASS sony_arw2_load_raw;			break;
    5796. 

  5796. 	}
    5797. 

  5797. 	if (tiff_ifd[raw].bytes*8 != raw_width*raw_height*tiff_bps) {
    5798. 

  5798. 	  raw_height += 8;
    5799. 

  5799. 	  load_raw = &CLASS sony_arw_load_raw;			break;
    5800. 

  5800. 	}
    5801. 

  5801. 	load_flags = 79;
    5802. 

  5802.       case 32769:
    5803. 

  5803. 	load_flags++;
    5804. 

  5804.       case 32770:
    5805. 

  5805.       case 32773:
    5806. 

  5806. 	load_raw = &CLASS packed_load_raw;			break;
    5807. 

  5807.       case 34713:
    5808. 

  5808. 	load_raw = &CLASS nikon_compressed_load_raw;		break;
    5809. 

  5809.       case 65535:
    5810. 

  5810. 	load_raw = &CLASS pentax_load_raw;			break;
    5811. 

  5811.       case 65000:
    5812. 

  5812. 	switch (tiff_ifd[raw].phint) {
    5813. 

  5813. 	  case 2: load_raw = &CLASS kodak_rgb_load_raw;   filters = 0;  break;
    5814. 

  5814. 	  case 6: load_raw = &CLASS kodak_ycbcr_load_raw; filters = 0;  break;
    5815. 

  5815. 	  case 32803: load_raw = &CLASS kodak_65000_load_raw;
    5816. 

  5816. 	}
    5817. 

  5817.       case 32867: break;
    5818. 

  5818.       default: is_raw = 0;
    5819. 

  5819.     }
    5820. 

  5820.   if (!dng_version)
    5821. 

  5821.     if ( (tiff_samples == 3 && tiff_ifd[raw].bytes &&
    5822. 

  5822. 	  tiff_bps != 14 && tiff_bps != 2048)
    5823. 

  5823.       || (tiff_bps == 8 && !strstr(make,"KODAK") && !strstr(make,"Kodak") &&
    5824. 

  5824. 	  !strstr(model2,"DEBUG RAW")))
    5825. 

  5825.       is_raw = 0;
    5826. 

  5826.   if(dng_version && max_bps > 16)
    5827. 

  5827.       is_raw = 0;
    5828. 

  5828.   for (i=0; i < tiff_nifds; i++)
    5829. 

  5829.     if (i != raw && tiff_ifd[i].samples == max_samp &&
    5830. 

  5830. 	tiff_ifd[i].t_width * tiff_ifd[i].t_height / SQR(tiff_ifd[i].bps+1) >
    5831. 

  5831. 	      thumb_width *       thumb_height / SQR(thumb_misc+1)) {
    5832. 

  5832.       thumb_width  = tiff_ifd[i].t_width;
    5833. 

  5833.       thumb_height = tiff_ifd[i].t_height;
    5834. 

  5834.       thumb_offset = tiff_ifd[i].offset;
    5835. 

  5835.       thumb_length = tiff_ifd[i].bytes;
    5836. 

  5836.       thumb_misc   = tiff_ifd[i].bps;
    5837. 

  5837.       thm = i;
    5838. 

  5838.     }
    5839. 

  5839.   if (thm >= 0) {
    5840. 

  5840.     thumb_misc |= tiff_ifd[thm].samples << 5;
    5841. 

  5841.     switch (tiff_ifd[thm].comp) {
    5842. 

  5842.       case 0:
    5843. 

  5843. 	write_thumb = &CLASS layer_thumb;
    5844. 

  5844. 	break;
    5845. 

  5845.       case 1:
    5846. 

  5846. 	if (tiff_ifd[thm].bps > 8)
    5847. 

  5847. 	  thumb_load_raw = &CLASS kodak_thumb_load_raw;
    5848. 

  5848. 	else
    5849. 

  5849. 	  write_thumb = &CLASS ppm_thumb;
    5850. 

  5850. 	break;
    5851. 

  5851.       case 65000:
    5852. 

  5852. 	thumb_load_raw = tiff_ifd[thm].phint == 6 ?
    5853. 

  5853. 		&CLASS kodak_ycbcr_load_thumb : &CLASS kodak_rgb_load_thumb;
    5854. 

  5854.     }
    5855. 

  5855.   }
    5856. 

  5856. }
    5857. 

  5857. 

  5858. void CLASS parse_minolta (int base)
    5859. 

  5859. {
    5860. 

  5860.   int save, tag, len, offset, high=0, wide=0, i, c;
    5861. 

  5861.   short sorder=order;
    5862. 

  5862. 

  5863.   fseek (ifp, base, SEEK_SET);
    5864. 

  5864.   if (fgetc(ifp) || fgetc(ifp)-'M' || fgetc(ifp)-'R') return;
    5865. 

  5865.   order = fgetc(ifp) * 0x101;
    5866. 

  5866.   offset = base + get4() + 8;
    5867. 

  5867.   while ((save=ftell(ifp)) < offset) {
    5868. 

  5868.     for (tag=i=0; i < 4; i++)
    5869. 

  5869.       tag = tag << 8 | fgetc(ifp);
    5870. 

  5870.     len = get4();
    5871. 

  5871.     switch (tag) {
    5872. 

  5872.       case 0x505244:				/* PRD */
    5873. 

  5873. 	fseek (ifp, 8, SEEK_CUR);
    5874. 

  5874. 	high = get2();
    5875. 

  5875. 	wide = get2();
    5876. 

  5876. 	break;
    5877. 

  5877.       case 0x574247:				/* WBG */
    5878. 

  5878. 	get4();
    5879. 

  5879. 	i = strcmp(model,"DiMAGE A200") ? 0:3;
    5880. 

  5880. 	FORC4 cam_mul[c ^ (c >> 1) ^ i] = get2();
    5881. 

  5881. #ifdef LIBRAW_LIBRARY_BUILD
    5882. 

  5882.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    5883. 

  5883. #endif
    5884. 

  5884. 	break;
    5885. 

  5885.       case 0x545457:				/* TTW */
    5886. 

  5886. 	parse_tiff (ftell(ifp));
    5887. 

  5887. 	data_offset = offset;
    5888. 

  5888.     }
    5889. 

  5889.     fseek (ifp, save+len+8, SEEK_SET);
    5890. 

  5890.   }
    5891. 

  5891.   raw_height = high;
    5892. 

  5892.   raw_width  = wide;
    5893. 

  5893.   order = sorder;
    5894. 

  5894. }
    5895. 

  5895. 

  5896. /*
    5897. 

  5897.    Many cameras have a "debug mode" that writes JPEG and raw
    5898. 

  5898.    at the same time.  The raw file has no header, so try to
    5899. 

  5899.    to open the matching JPEG file and read its metadata.
    5900. 

  5900.  */
    5901. 

  5901. void CLASS parse_external_jpeg()
    5902. 

  5902. {
    5903. 

  5903.   const char *file, *ext;
    5904. 

  5904.   char *jname, *jfile, *jext;
    5905. 

  5905. #ifndef LIBRAW_LIBRARY_BUILD
    5906. 

  5906.   FILE *save=ifp;
    5907. 

  5907. #else
    5908. 

  5908.   if(!ifp->fname())
    5909. 

  5909.       {
    5910. 

  5910.           imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5911. 

  5911.           return;
    5912. 

  5912.       }
    5913. 

  5913. #endif
    5914. 

  5914. 

  5915.   ext  = strrchr (ifname, '.');
    5916. 

  5916.   file = strrchr (ifname, '/');
    5917. 

  5917.   if (!file) file = strrchr (ifname, '\\');
    5918. 

  5918. #ifndef LIBRAW_LIBRARY_BUILD
    5919. 

  5919.   if (!file) file = ifname-1;
    5920. 

  5920. #else
    5921. 

  5921.   if (!file) file = (char*)ifname-1;
    5922. 

  5922. #endif
    5923. 

  5923.   file++;
    5924. 

  5924.   if (!ext || strlen(ext) != 4 || ext-file != 8) return;
    5925. 

  5925.   jname = (char *) malloc (strlen(ifname) + 1);
    5926. 

  5926.   merror (jname, "parse_external_jpeg()");
    5927. 

  5927.   strcpy (jname, ifname);
    5928. 

  5928.   jfile = file - ifname + jname;
    5929. 

  5929.   jext  = ext  - ifname + jname;
    5930. 

  5930.   if (strcasecmp (ext, ".jpg")) {
    5931. 

  5931.     strcpy (jext, isupper(ext[1]) ? ".JPG":".jpg");
    5932. 

  5932.     if (isdigit(*file)) {
    5933. 

  5933.       memcpy (jfile, file+4, 4);
    5934. 

  5934.       memcpy (jfile+4, file, 4);
    5935. 

  5935.     }
    5936. 

  5936.   } else
    5937. 

  5937.     while (isdigit(*--jext)) {
    5938. 

  5938.       if (*jext != '9') {
    5939. 

  5939. 	(*jext)++;
    5940. 

  5940. 	break;
    5941. 

  5941.       }
    5942. 

  5942.       *jext = '0';
    5943. 

  5943.     }
    5944. 

  5944. #ifndef LIBRAW_LIBRARY_BUILD
    5945. 

  5945.   if (strcmp (jname, ifname)) {
    5946. 

  5946.     if ((ifp = fopen (jname, "rb"))) {
    5947. 

  5947. #ifdef DCRAW_VERBOSE
    5948. 

  5948.       if (verbose)
    5949. 

  5949. 	fprintf (stderr,_("Reading metadata from %s ...\n"), jname);
    5950. 

  5950. #endif
    5951. 

  5951.       parse_tiff (12);
    5952. 

  5952.       thumb_offset = 0;
    5953. 

  5953.       is_raw = 1;
    5954. 

  5954.       fclose (ifp);
    5955. 

  5955.     }
    5956. 

  5956.   }
    5957. 

  5957. #else
    5958. 

  5958.   if (strcmp (jname, ifname)) 
    5959. 

  5959.       {
    5960. 

  5960.           if(!ifp->subfile_open(jname))
    5961. 

  5961.               {
    5962. 

  5962.                   parse_tiff (12);
    5963. 

  5963.                   thumb_offset = 0;
    5964. 

  5964.                   is_raw = 1;
    5965. 

  5965.                   ifp->subfile_close();
    5966. 

  5966.               }
    5967. 

  5967.           else
    5968. 

  5968.               imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5969. 

  5969.       }
    5970. 

  5970. #endif
    5971. 

  5971.   if (!timestamp)
    5972. 

  5972.       {
    5973. 

  5973. #ifdef LIBRAW_LIBRARY_BUILD
    5974. 

  5974.           imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5975. 

  5975. #endif
    5976. 

  5976. #ifdef DCRAW_VERBOSE
    5977. 

  5977.           fprintf (stderr,_("Failed to read metadata from %s\n"), jname);
    5978. 

  5978. #endif
    5979. 

  5979.       }
    5980. 

  5980.   free (jname);
    5981. 

  5981. #ifndef LIBRAW_LIBRARY_BUILD
    5982. 

  5982.   ifp = save;
    5983. 

  5983. #endif
    5984. 

  5984. }
    5985. 

  5985. 

  5986. /*
    5987. 

  5987.    CIFF block 0x1030 contains an 8x8 white sample.
    5988. 

  5988.    Load this into white[][] for use in scale_colors().
    5989. 

  5989.  */
    5990. 

  5990. void CLASS ciff_block_1030()
    5991. 

  5991. {
    5992. 

  5992.   static const ushort key[] = { 0x410, 0x45f3 };
    5993. 

  5993.   int i, bpp, row, col, vbits=0;
    5994. 

  5994.   unsigned long bitbuf=0;
    5995. 

  5995. 

  5996.   if ((get2(),get4()) != 0x80008 || !get4()) return;
    5997. 

  5997.   bpp = get2();
    5998. 

  5998.   if (bpp != 10 && bpp != 12) return;
    5999. 

  5999.   for (i=row=0; row < 8; row++)
    6000. 

  6000.     for (col=0; col < 8; col++) {
    6001. 

  6001.       if (vbits < bpp) {
    6002. 

  6002. 	bitbuf = bitbuf << 16 | (get2() ^ key[i++ & 1]);
    6003. 

  6003. 	vbits += 16;
    6004. 

  6004.       }
    6005. 

  6005.       white[row][col] =
    6006. 

  6006. 	bitbuf << (LONG_BIT - vbits) >> (LONG_BIT - bpp);
    6007. 

  6007.       vbits -= bpp;
    6008. 

  6008.     }
    6009. 

  6009. }
    6010. 

  6010. 

  6011. /*
    6012. 

  6012.    Parse a CIFF file, better known as Canon CRW format.
    6013. 

  6013.  */
    6014. 

  6014. void CLASS parse_ciff (int offset, int length)
    6015. 

  6015. {
    6016. 

  6016.   int tboff, nrecs, c, type, len, save, wbi=-1;
    6017. 

  6017.   ushort key[] = { 0x410, 0x45f3 };
    6018. 

  6018. 

  6019.   fseek (ifp, offset+length-4, SEEK_SET);
    6020. 

  6020.   tboff = get4() + offset;
    6021. 

  6021.   fseek (ifp, tboff, SEEK_SET);
    6022. 

  6022.   nrecs = get2();
    6023. 

  6023.   if (nrecs > 100) return;
    6024. 

  6024.   while (nrecs--) {
    6025. 

  6025.     type = get2();
    6026. 

  6026.     len  = get4();
    6027. 

  6027.     save = ftell(ifp) + 4;
    6028. 

  6028.     fseek (ifp, offset+get4(), SEEK_SET);
    6029. 

  6029.     if ((((type >> 8) + 8) | 8) == 0x38)
    6030. 

  6030.       parse_ciff (ftell(ifp), len);	/* Parse a sub-table */
    6031. 

  6031. 

  6032.     if (type == 0x0810)
    6033. 

  6033.       fread (artist, 64, 1, ifp);
    6034. 

  6034.     if (type == 0x080a) {
    6035. 

  6035.       fread (make, 64, 1, ifp);
    6036. 

  6036.       fseek (ifp, ((INT64)strlen(make)) - 63, SEEK_CUR);
    6037. 

  6037.       fread (model, 64, 1, ifp);
    6038. 

  6038.     }
    6039. 

  6039.     if (type == 0x1810) {
    6040. 

  6040.       fseek (ifp, 12, SEEK_CUR);
    6041. 

  6041.       flip = get4();
    6042. 

  6042.     }
    6043. 

  6043.     if (type == 0x1835)			/* Get the decoder table */
    6044. 

  6044.       tiff_compress = get4();
    6045. 

  6045.     if (type == 0x2007) {
    6046. 

  6046.       thumb_offset = ftell(ifp);
    6047. 

  6047.       thumb_length = len;
    6048. 

  6048.     }
    6049. 

  6049.     if (type == 0x1818) {
    6050. 

  6050.       shutter = pow (2.0f, -int_to_float((get4(),get4())));
    6051. 

  6051.       aperture = pow (2.0f, int_to_float(get4())/2);
    6052. 

  6052.     }
    6053. 

  6053.     if (type == 0x102a) {
    6054. 

  6054.       iso_speed = pow (2.0, (get4(),get2())/32.0 - 4) * 50;
    6055. 

  6055.       aperture  = pow (2.0, (get2(),(short)get2())/64.0);
    6056. 

  6056.       shutter   = pow (2.0,-((short)get2())/32.0);
    6057. 

  6057.       wbi = (get2(),get2());
    6058. 

  6058.       if (wbi > 17) wbi = 0;
    6059. 

  6059.       fseek (ifp, 32, SEEK_CUR);
    6060. 

  6060.       if (shutter > 1e6) shutter = get2()/10.0;
    6061. 

  6061.     }
    6062. 

  6062.     if (type == 0x102c) {
    6063. 

  6063.       if (get2() > 512) {		/* Pro90, G1 */
    6064. 

  6064. 	fseek (ifp, 118, SEEK_CUR);
    6065. 

  6065. 	FORC4 cam_mul[c ^ 2] = get2();
    6066. 

  6066. #ifdef LIBRAW_LIBRARY_BUILD
    6067. 

  6067.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6068. 

  6068. #endif
    6069. 

  6069.       } else {				/* G2, S30, S40 */
    6070. 

  6070. 	fseek (ifp, 98, SEEK_CUR);
    6071. 

  6071. 	FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get2();
    6072. 

  6072. #ifdef LIBRAW_LIBRARY_BUILD
    6073. 

  6073.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6074. 

  6074. #endif
    6075. 

  6075.       }
    6076. 

  6076.     }
    6077. 

  6077.     if (type == 0x0032) {
    6078. 

  6078.       if (len == 768) {			/* EOS D30 */
    6079. 

  6079. 	fseek (ifp, 72, SEEK_CUR);
    6080. 

  6080. 	FORC4 cam_mul[c ^ (c >> 1)] = 1024.0 / get2();
    6081. 

  6081. #ifdef LIBRAW_LIBRARY_BUILD
    6082. 

  6082.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6083. 

  6083. #endif
    6084. 

  6084. 	if (!wbi) cam_mul[0] = -1;	/* use my auto white balance */
    6085. 

  6085.       } else if (!cam_mul[0]) {
    6086. 

  6086. 	if (get2() == key[0])		/* Pro1, G6, S60, S70 */
    6087. 

  6087. 	  c = (strstr(model,"Pro1") ?
    6088. 

  6088. 	      "012346000000000000":"01345:000000006008")[wbi]-'0'+ 2;
    6089. 

  6089. 	else {				/* G3, G5, S45, S50 */
    6090. 

  6090. 	  c = "023457000000006000"[wbi]-'0';
    6091. 

  6091. 	  key[0] = key[1] = 0;
    6092. 

  6092. 	}
    6093. 

  6093. 	fseek (ifp, 78 + c*8, SEEK_CUR);
    6094. 

  6094. 	FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get2() ^ key[c & 1];
    6095. 

  6095. #ifdef LIBRAW_LIBRARY_BUILD
    6096. 

  6096.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6097. 

  6097. #endif
    6098. 

  6098. 	if (!wbi) cam_mul[0] = -1;
    6099. 

  6099.       }
    6100. 

  6100.     }
    6101. 

  6101.     if (type == 0x10a9) {		/* D60, 10D, 300D, and clones */
    6102. 

  6102.       if (len > 66) wbi = "0134567028"[wbi]-'0';
    6103. 

  6103.       fseek (ifp, 2 + wbi*8, SEEK_CUR);
    6104. 

  6104.       FORC4 cam_mul[c ^ (c >> 1)] = get2();
    6105. 

  6105. #ifdef LIBRAW_LIBRARY_BUILD
    6106. 

  6106.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6107. 

  6107. #endif
    6108. 

  6108.     }
    6109. 

  6109.     if (type == 0x1030 && (0x18040 >> wbi & 1))
    6110. 

  6110.       ciff_block_1030();		/* all that don't have 0x10a9 */
    6111. 

  6111.     if (type == 0x1031) {
    6112. 

  6112.       raw_width = (get2(),get2());
    6113. 

  6113.       raw_height = get2();
    6114. 

  6114.     }
    6115. 

  6115.     if (type == 0x5029) {
    6116. 

  6116.       focal_len = len >> 16;
    6117. 

  6117.       if ((len & 0xffff) == 2) focal_len /= 32;
    6118. 

  6118.     }
    6119. 

  6119.     if (type == 0x5813) flash_used = int_to_float(len);
    6120. 

  6120.     if (type == 0x5814) canon_ev   = int_to_float(len);
    6121. 

  6121.     if (type == 0x5817) shot_order = len;
    6122. 

  6122.     if (type == 0x5834) unique_id  = len;
    6123. 

  6123.     if (type == 0x580e) timestamp  = len;
    6124. 

  6124.     if (type == 0x180e) timestamp  = get4();
    6125. 

  6125. #ifdef LOCALTIME
    6126. 

  6126.     if ((type | 0x4000) == 0x580e)
    6127. 

  6127.       timestamp = mktime (gmtime (&timestamp));
    6128. 

  6128. #endif
    6129. 

  6129.     fseek (ifp, save, SEEK_SET);
    6130. 

  6130.   }
    6131. 

  6131. }
    6132. 

  6132. 

  6133. void CLASS parse_rollei()
    6134. 

  6134. {
    6135. 

  6135.   char line[128], *val;
    6136. 

  6136.   struct tm t;
    6137. 

  6137. 

  6138.   fseek (ifp, 0, SEEK_SET);
    6139. 

  6139.   memset (&t, 0, sizeof t);
    6140. 

  6140.   do {
    6141. 

  6141.     fgets (line, 128, ifp);
    6142. 

  6142.     if ((val = strchr(line,'=')))
    6143. 

  6143.       *val++ = 0;
    6144. 

  6144.     else
    6145. 

  6145.       val = line + strlen(line);
    6146. 

  6146.     if (!strcmp(line,"DAT"))
    6147. 

  6147.       sscanf (val, "%d.%d.%d", &t.tm_mday, &t.tm_mon, &t.tm_year);
    6148. 

  6148.     if (!strcmp(line,"TIM"))
    6149. 

  6149.       sscanf (val, "%d:%d:%d", &t.tm_hour, &t.tm_min, &t.tm_sec);
    6150. 

  6150.     if (!strcmp(line,"HDR"))
    6151. 

  6151.       thumb_offset = atoi(val);
    6152. 

  6152.     if (!strcmp(line,"X  "))
    6153. 

  6153.       raw_width = atoi(val);
    6154. 

  6154.     if (!strcmp(line,"Y  "))
    6155. 

  6155.       raw_height = atoi(val);
    6156. 

  6156.     if (!strcmp(line,"TX "))
    6157. 

  6157.       thumb_width = atoi(val);
    6158. 

  6158.     if (!strcmp(line,"TY "))
    6159. 

  6159.       thumb_height = atoi(val);
    6160. 

  6160.   } while (strncmp(line,"EOHD",4));
    6161. 

  6161.   data_offset = thumb_offset + thumb_width * thumb_height * 2;
    6162. 

  6162.   t.tm_year -= 1900;
    6163. 

  6163.   t.tm_mon -= 1;
    6164. 

  6164.   if (mktime(&t) > 0)
    6165. 

  6165.     timestamp = mktime(&t);
    6166. 

  6166.   strcpy (make, "Rollei");
    6167. 

  6167.   strcpy (model,"d530flex");
    6168. 

  6168.   write_thumb = &CLASS rollei_thumb;
    6169. 

  6169. }
    6170. 

  6170. 

  6171. void CLASS parse_sinar_ia()
    6172. 

  6172. {
    6173. 

  6173.   int entries, off;
    6174. 

  6174.   char str[8], *cp;
    6175. 

  6175. 

  6176.   order = 0x4949;
    6177. 

  6177.   fseek (ifp, 4, SEEK_SET);
    6178. 

  6178.   entries = get4();
    6179. 

  6179.   fseek (ifp, get4(), SEEK_SET);
    6180. 

  6180.   while (entries--) {
    6181. 

  6181.     off = get4(); get4();
    6182. 

  6182.     fread (str, 8, 1, ifp);
    6183. 

  6183.     if (!strcmp(str,"META"))   meta_offset = off;
    6184. 

  6184.     if (!strcmp(str,"THUMB")) thumb_offset = off;
    6185. 

  6185.     if (!strcmp(str,"RAW0"))   data_offset = off;
    6186. 

  6186.   }
    6187. 

  6187.   fseek (ifp, meta_offset+20, SEEK_SET);
    6188. 

  6188.   fread (make, 64, 1, ifp);
    6189. 

  6189.   make[63] = 0;
    6190. 

  6190.   if ((cp = strchr(make,' '))) {
    6191. 

  6191.     strcpy (model, cp+1);
    6192. 

  6192.     *cp = 0;
    6193. 

  6193.   }
    6194. 

  6194.   raw_width  = get2();
    6195. 

  6195.   raw_height = get2();
    6196. 

  6196.   load_raw = &CLASS unpacked_load_raw;
    6197. 

  6197.   thumb_width = (get4(),get2());
    6198. 

  6198.   thumb_height = get2();
    6199. 

  6199.   write_thumb = &CLASS ppm_thumb;
    6200. 

  6200.   maximum = 0x3fff;
    6201. 

  6201. }
    6202. 

  6202. 

  6203. void CLASS parse_phase_one (int base)
    6204. 

  6204. {
    6205. 

  6205.   unsigned entries, tag, type, len, data, save, i, c;
    6206. 

  6206.   float romm_cam[3][3];
    6207. 

  6207.   char *cp;
    6208. 

  6208. 

  6209.   memset (&ph1, 0, sizeof ph1);
    6210. 

  6210.   fseek (ifp, base, SEEK_SET);
    6211. 

  6211.   order = get4() & 0xffff;
    6212. 

  6212.   if (get4() >> 8 != 0x526177) return;		/* "Raw" */
    6213. 

  6213.   fseek (ifp, get4()+base, SEEK_SET);
    6214. 

  6214.   entries = get4();
    6215. 

  6215.   get4();
    6216. 

  6216.   while (entries--) {
    6217. 

  6217.     tag  = get4();
    6218. 

  6218.     type = get4();
    6219. 

  6219.     len  = get4();
    6220. 

  6220.     data = get4();
    6221. 

  6221.     save = ftell(ifp);
    6222. 

  6222.     fseek (ifp, base+data, SEEK_SET);
    6223. 

  6223.     switch (tag) {
    6224. 

  6224.       case 0x100:  flip = "0653"[data & 3]-'0';  break;
    6225. 

  6225.       case 0x106:
    6226. 

  6226. 	for (i=0; i < 9; i++)
    6227. 

  6227. 	  romm_cam[0][i] = getreal(11);
    6228. 

  6228. 	romm_coeff (romm_cam);
    6229. 

  6229. 	break;
    6230. 

  6230.       case 0x107:
    6231. 

  6231. 	FORC3 cam_mul[c] = getreal(11);
    6232. 

  6232. #ifdef LIBRAW_LIBRARY_BUILD
    6233. 

  6233.         color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6234. 

  6234. #endif
    6235. 

  6235. 	break;
    6236. 

  6236.       case 0x108:  raw_width     = data;	break;
    6237. 

  6237.       case 0x109:  raw_height    = data;	break;
    6238. 

  6238.       case 0x10a:  left_margin   = data;	break;
    6239. 

  6239.       case 0x10b:  top_margin    = data;	break;
    6240. 

  6240.       case 0x10c:  width         = data;	break;
    6241. 

  6241.       case 0x10d:  height        = data;	break;
    6242. 

  6242.       case 0x10e:  ph1.format    = data;	break;
    6243. 

  6243.       case 0x10f:  data_offset   = data+base;	break;
    6244. 

  6244.       case 0x110:  meta_offset   = data+base;
    6245. 

  6245. 		   meta_length   = len;			break;
    6246. 

  6246.       case 0x112:  ph1.key_off   = save - 4;		break;
    6247. 

  6247.       case 0x210:  ph1.tag_210   = int_to_float(data);	break;
    6248. 

  6248.       case 0x21a:  ph1.tag_21a   = data;		break;
    6249. 

  6249.       case 0x21c:  strip_offset  = data+base;		break;
    6250. 

  6250.       case 0x21d:  ph1.t_black     = data;		break;
    6251. 

  6251.       case 0x222:  ph1.split_col = data - left_margin;	break;
    6252. 

  6252.       case 0x223:  ph1.black_off = data+base;		break;
    6253. 

  6253.       case 0x301:
    6254. 

  6254. 	model[63] = 0;
    6255. 

  6255. 	fread (model, 1, 63, ifp);
    6256. 

  6256. 	if ((cp = strstr(model," camera"))) *cp = 0;
    6257. 

  6257.     }
    6258. 

  6258.     fseek (ifp, save, SEEK_SET);
    6259. 

  6259.   }
    6260. 

  6260.   load_raw = ph1.format < 3 ?
    6261. 

  6261. 	&CLASS phase_one_load_raw : &CLASS phase_one_load_raw_c;
    6262. 

  6262.   maximum = 0xffff;
    6263. 

  6263.   strcpy (make, "Phase One");
    6264. 

  6264.   if (model[0]) return;
    6265. 

  6265.   switch (raw_height) {
    6266. 

  6266.     case 2060: strcpy (model,"LightPhase");	break;
    6267. 

  6267.     case 2682: strcpy (model,"H 10");		break;
    6268. 

  6268.     case 4128: strcpy (model,"H 20");		break;
    6269. 

  6269.     case 5488: strcpy (model,"H 25");		break;
    6270. 

  6270.   }
    6271. 

  6271. }
    6272. 

  6272. 

  6273. void CLASS parse_fuji (int offset)
    6274. 

  6274. {
    6275. 

  6275.   unsigned entries, tag, len, save, c;
    6276. 

  6276. 

  6277.   fseek (ifp, offset, SEEK_SET);
    6278. 

  6278.   entries = get4();
    6279. 

  6279.   if (entries > 255) return;
    6280. 

  6280.   while (entries--) {
    6281. 

  6281.     tag = get2();
    6282. 

  6282.     len = get2();
    6283. 

  6283.     save = ftell(ifp);
    6284. 

  6284.     if (tag == 0x100) {
    6285. 

  6285.       raw_height = get2();
    6286. 

  6286.       raw_width  = get2();
    6287. 

  6287.     } else if (tag == 0x121) {
    6288. 

  6288.       height = get2();
    6289. 

  6289.       if ((width = get2()) == 4284) width += 3;
    6290. 

  6290.     } else if (tag == 0x130) {
    6291. 

  6291.       fuji_layout = fgetc(ifp) >> 7;
    6292. 

  6292.       load_raw = fgetc(ifp) & 8 ?
    6293. 

  6293. 	&CLASS unpacked_load_raw : &CLASS fuji_load_raw;
    6294. 

  6294.     } else if (tag == 0x2ff0) {
    6295. 

  6295.       FORC4 cam_mul[c ^ 1] = get2();
    6296. 

  6296. #ifdef LIBRAW_LIBRARY_BUILD
    6297. 

  6297.       color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6298. 

  6298. #endif
    6299. 

  6299.     } else if (tag == 0xc000) {
    6300. 

  6300.       c = order;
    6301. 

  6301.       order = 0x4949;
    6302. 

  6302.       width  = get4();
    6303. 

  6303.       height = get4();
    6304. 

  6304.       order = c;
    6305. 

  6305.     }
    6306. 

  6306.     fseek (ifp, save+len, SEEK_SET);
    6307. 

  6307.   }
    6308. 

  6308.   height <<= fuji_layout;
    6309. 

  6309.   width  >>= fuji_layout;
    6310. 

  6310. }
    6311. 

  6311. 

  6312. int CLASS parse_jpeg (int offset)
    6313. 

  6313. {
    6314. 

  6314.   int len, save, hlen, mark;
    6315. 

  6315. 

  6316.   fseek (ifp, offset, SEEK_SET);
    6317. 

  6317.   if (fgetc(ifp) != 0xff || fgetc(ifp) != 0xd8) return 0;
    6318. 

  6318. 

  6319.   while (fgetc(ifp) == 0xff && (mark = fgetc(ifp)) != 0xda) {
    6320. 

  6320.     order = 0x4d4d;
    6321. 

  6321.     len   = get2() - 2;
    6322. 

  6322.     save  = ftell(ifp);
    6323. 

  6323.     if (mark == 0xc0 || mark == 0xc3) {
    6324. 

  6324.       fgetc(ifp);
    6325. 

  6325.       raw_height = get2();
    6326. 

  6326.       raw_width  = get2();
    6327. 

  6327.     }
    6328. 

  6328.     order = get2();
    6329. 

  6329.     hlen  = get4();
    6330. 

  6330.     if (get4() == 0x48454150)		/* "HEAP" */
    6331. 

  6331.       parse_ciff (save+hlen, len-hlen);
    6332. 

  6332.     if (parse_tiff (save+6)) apply_tiff();
    6333. 

  6333.     fseek (ifp, save+len, SEEK_SET);
    6334. 

  6334.   }
    6335. 

  6335.   return 1;
    6336. 

  6336. }
    6337. 

  6337. 

  6338. void CLASS parse_riff()
    6339. 

  6339. {
    6340. 

  6340.   unsigned i, size, end;
    6341. 

  6341.   char tag[4], date[64], month[64];
    6342. 

  6342.   static const char mon[12][4] =
    6343. 

  6343.   { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
    6344. 

  6344.   struct tm t;
    6345. 

  6345. 

  6346.   order = 0x4949;
    6347. 

  6347.   fread (tag, 4, 1, ifp);
    6348. 

  6348.   size = get4();
    6349. 

  6349.   end = ftell(ifp) + size;
    6350. 

  6350.   if (!memcmp(tag,"RIFF",4) || !memcmp(tag,"LIST",4)) {
    6351. 

  6351.       int cnt=0;
    6352. 

  6352.     get4();
    6353. 

  6353.     while (ftell(ifp)+7 < end)
    6354. 

  6354.         {
    6355. 

  6355.             parse_riff();
    6356. 

  6356.             if(cnt++>10000) break; // no more than 10k times
    6357. 

  6357.         }
    6358. 

  6358.   } else if (!memcmp(tag,"nctg",4)) {
    6359. 

  6359.     while (ftell(ifp)+7 < end) {
    6360. 

  6360.       i = get2();
    6361. 

  6361.       size = get2();
    6362. 

  6362.       if ((i+1) >> 1 == 10 && size == 20)
    6363. 

  6363. 	get_timestamp(0);
    6364. 

  6364.       else fseek (ifp, size, SEEK_CUR);
    6365. 

  6365.     }
    6366. 

  6366.   } else if (!memcmp(tag,"IDIT",4) && size < 64) {
    6367. 

  6367.     fread (date, 64, 1, ifp);
    6368. 

  6368.     date[size] = 0;
    6369. 

  6369.     memset (&t, 0, sizeof t);
    6370. 

  6370.     if (sscanf (date, "%*s %s %d %d:%d:%d %d", month, &t.tm_mday,
    6371. 

  6371. 	&t.tm_hour, &t.tm_min, &t.tm_sec, &t.tm_year) == 6) {
    6372. 

  6372.       for (i=0; i < 12 && strcasecmp(mon[i],month); i++);
    6373. 

  6373.       t.tm_mon = i;
    6374. 

  6374.       t.tm_year -= 1900;
    6375. 

  6375.       if (mktime(&t) > 0)
    6376. 

  6376. 	timestamp = mktime(&t);
    6377. 

  6377.     }
    6378. 

  6378.   } else
    6379. 

  6379.     fseek (ifp, size, SEEK_CUR);
    6380. 

  6380. }
    6381. 

  6381. 

  6382. void CLASS parse_smal (int offset, int fsize)
    6383. 

  6383. {
    6384. 

  6384.   int ver;
    6385. 

  6385. 

  6386.   fseek (ifp, offset+2, SEEK_SET);
    6387. 

  6387.   order = 0x4949;
    6388. 

  6388.   ver = fgetc(ifp);
    6389. 

  6389.   if (ver == 6)
    6390. 

  6390.     fseek (ifp, 5, SEEK_CUR);
    6391. 

  6391.   if (get4() != fsize) return;
    6392. 

  6392.   if (ver > 6) data_offset = get4();
    6393. 

  6393.   raw_height = height = get2();
    6394. 

  6394.   raw_width  = width  = get2();
    6395. 

  6395.   strcpy (make, "SMaL");
    6396. 

  6396.   sprintf (model, "v%d %dx%d", ver, width, height);
    6397. 

  6397.   if (ver == 6) load_raw = &CLASS smal_v6_load_raw;
    6398. 

  6398.   if (ver == 9) load_raw = &CLASS smal_v9_load_raw;
    6399. 

  6399. }
    6400. 

  6400. 

  6401. void CLASS parse_cine()
    6402. 

  6402. {
    6403. 

  6403.   unsigned off_head, off_setup, off_image, i;
    6404. 

  6404. 

  6405.   order = 0x4949;
    6406. 

  6406.   fseek (ifp, 4, SEEK_SET);
    6407. 

  6407.   is_raw = get2() == 2;
    6408. 

  6408.   fseek (ifp, 14, SEEK_CUR);
    6409. 

  6409.   is_raw *= get4();
    6410. 

  6410.   off_head = get4();
    6411. 

  6411.   off_setup = get4();
    6412. 

  6412.   off_image = get4();
    6413. 

  6413.   timestamp = get4();
    6414. 

  6414.   if ((i = get4())) timestamp = i;
    6415. 

  6415.   fseek (ifp, off_head+4, SEEK_SET);
    6416. 

  6416.   raw_width = get4();
    6417. 

  6417.   raw_height = get4();
    6418. 

  6418.   switch (get2(),get2()) {
    6419. 

  6419.     case  8:  load_raw = &CLASS eight_bit_load_raw;  break;
    6420. 

  6420.     case 16:  load_raw = &CLASS  unpacked_load_raw;
    6421. 

  6421.   }
    6422. 

  6422.   fseek (ifp, off_setup+792, SEEK_SET);
    6423. 

  6423.   strcpy (make, "CINE");
    6424. 

  6424.   sprintf (model, "%d", get4());
    6425. 

  6425.   fseek (ifp, 12, SEEK_CUR);
    6426. 

  6426.   switch ((i=get4()) & 0xffffff) {
    6427. 

  6427.     case  3:  filters = 0x94949494;  break;
    6428. 

  6428.     case  4:  filters = 0x49494949;  break;
    6429. 

  6429.     default:  is_raw = 0;
    6430. 

  6430.   }
    6431. 

  6431.   fseek (ifp, 72, SEEK_CUR);
    6432. 

  6432.   switch ((get4()+3600) % 360) {
    6433. 

  6433.     case 270:  flip = 4;  break;
    6434. 

  6434.     case 180:  flip = 1;  break;
    6435. 

  6435.     case  90:  flip = 7;  break;
    6436. 

  6436.     case   0:  flip = 2;
    6437. 

  6437.   }
    6438. 

  6438.   cam_mul[0] = getreal(11);
    6439. 

  6439.   cam_mul[2] = getreal(11);
    6440. 

  6440. #ifdef LIBRAW_LIBRARY_BUILD
    6441. 

  6441.   color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    6442. 

  6442. #endif
    6443. 

  6443.   maximum = ~(-1 << get4());
    6444. 

  6444.   fseek (ifp, 668, SEEK_CUR);
    6445. 

  6445.   shutter = get4()/1000000000.0;
    6446. 

  6446.   fseek (ifp, off_image, SEEK_SET);
    6447. 

  6447.   if (shot_select < is_raw)
    6448. 

  6448.     fseek (ifp, shot_select*8, SEEK_CUR);
    6449. 

  6449.   data_offset  = (INT64) get4() + 8;
    6450. 

  6450.   data_offset += (INT64) get4() << 32;
    6451. 

  6451. }
    6452. 

  6452. 

  6453. void CLASS parse_redcine()
    6454. 

  6454. {
    6455. 

  6455.   unsigned i, len, rdvo;
    6456. 

  6456. 

  6457.   order = 0x4d4d;
    6458. 

  6458.   is_raw = 0;
    6459. 

  6459.   fseek (ifp, 52, SEEK_SET);
    6460. 

  6460.   width  = get4();
    6461. 

  6461.   height = get4();
    6462. 

  6462.   fseek (ifp, 0, SEEK_END);
    6463. 

  6463.   fseek (ifp, -(i = ftello(ifp) & 511), SEEK_CUR);
    6464. 

  6464.   if (get4() != i || get4() != 0x52454f42) {
    6465. 

  6465. #ifdef DCRAW_VERBOSE
    6466. 

  6466.     fprintf (stderr,_("%s: Tail is missing, parsing from head...\n"), ifname);
    6467. 

  6467. #endif
    6468. 

  6468.     fseek (ifp, 0, SEEK_SET);
    6469. 

  6469.     while ((len = get4()) != EOF) {
    6470. 

  6470.       if (get4() == 0x52454456)
    6471. 

  6471. 	if (is_raw++ == shot_select)
    6472. 

  6472. 	  data_offset = ftello(ifp) - 8;
    6473. 

  6473.       fseek (ifp, len-8, SEEK_CUR);
    6474. 

  6474.     }
    6475. 

  6475.   } else {
    6476. 

  6476.     rdvo = get4();
    6477. 

  6477.     fseek (ifp, 12, SEEK_CUR);
    6478. 

  6478.     is_raw = get4();
    6479. 

  6479.     fseeko (ifp, rdvo+8 + shot_select*4, SEEK_SET);
    6480. 

  6480.     data_offset = get4();
    6481. 

  6481.   }
    6482. 

  6482. }
    6483. 

  6483. void CLASS adobe_coeff (const char *p_make, const char *p_model)
    6484. 

  6484. {
    6485. 

  6485.   static const struct {
    6486. 

  6486.     const char *prefix;
    6487. 

  6487.     int t_black, t_maximum, trans[12];
    6488. 

  6488.   } table[] = {
    6489. 

  6489.     { "AGFAPHOTO DC-833m", 0, 0,	/* DJC */
    6490. 

  6490. 	{ 11438,-3762,-1115,-2409,9914,2497,-1227,2295,5300 } },
    6491. 

  6491.     { "Apple QuickTake", 0, 0,		/* DJC */
    6492. 

  6492. 	{ 21392,-5653,-3353,2406,8010,-415,7166,1427,2078 } },
    6493. 

  6493.     { "Canon EOS D2000", 0, 0,
    6494. 

  6494. 	{ 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } },
    6495. 

  6495.     { "Canon EOS D6000", 0, 0,
    6496. 

  6496. 	{ 20482,-7172,-3125,-1033,10410,-285,2542,226,3136 } },
    6497. 

  6497.     { "Canon EOS D30", 0, 0,
    6498. 

  6498. 	{ 9805,-2689,-1312,-5803,13064,3068,-2438,3075,8775 } },
    6499. 

  6499.     { "Canon EOS D60", 0, 0xfa0,
    6500. 

  6500. 	{ 6188,-1341,-890,-7168,14489,2937,-2640,3228,8483 } },
    6501. 

  6501.     { "Canon EOS 5D Mark II", 0, 0x3cf0,
    6502. 

  6502. 	{ 4716,603,-830,-7798,15474,2480,-1496,1937,6651 } },
    6503. 

  6503.     { "Canon EOS 5D", 0, 0xe6c,
    6504. 

  6504. 	{ 6347,-479,-972,-8297,15954,2480,-1968,2131,7649 } },
    6505. 

  6505.     { "Canon EOS 7D", 0, 0x3510,
    6506. 

  6506. 	{ 6844,-996,-856,-3876,11761,2396,-593,1772,6198 } },
    6507. 

  6507.     { "Canon EOS 10D", 0, 0xfa0,
    6508. 

  6508. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6509. 

  6509.     { "Canon EOS 20Da", 0, 0,
    6510. 

  6510. 	{ 14155,-5065,-1382,-6550,14633,2039,-1623,1824,6561 } },
    6511. 

  6511.     { "Canon EOS 20D", 0, 0xfff,
    6512. 

  6512. 	{ 6599,-537,-891,-8071,15783,2424,-1983,2234,7462 } },
    6513. 

  6513.     { "Canon EOS 30D", 0, 0,
    6514. 

  6514. 	{ 6257,-303,-1000,-7880,15621,2396,-1714,1904,7046 } },
    6515. 

  6515.     { "Canon EOS 40D", 0, 0x3f60,
    6516. 

  6516. 	{ 6071,-747,-856,-7653,15365,2441,-2025,2553,7315 } },
    6517. 

  6517.     { "Canon EOS 50D", 0, 0x3d93,
    6518. 

  6518. 	{ 4920,616,-593,-6493,13964,2784,-1774,3178,7005 } },
    6519. 

  6519.     { "Canon EOS 60D", 0, 0x2ff7,
    6520. 

  6520. 	{ 6719,-994,-925,-4408,12426,2211,-887,2129,6051 } },
    6521. 

  6521.     { "Canon EOS 300D", 0, 0xfa0,
    6522. 

  6522. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6523. 

  6523.     { "Canon EOS 350D", 0, 0xfff,
    6524. 

  6524. 	{ 6018,-617,-965,-8645,15881,2975,-1530,1719,7642 } },
    6525. 

  6525.     { "Canon EOS 400D", 0, 0xe8e,
    6526. 

  6526. 	{ 7054,-1501,-990,-8156,15544,2812,-1278,1414,7796 } },
    6527. 

  6527.     { "Canon EOS 450D", 0, 0x390d,
    6528. 

  6528. 	{ 5784,-262,-821,-7539,15064,2672,-1982,2681,7427 } },
    6529. 

  6529.     { "Canon EOS 500D", 0, 0x3479,
    6530. 

  6530. 	{ 4763,712,-646,-6821,14399,2640,-1921,3276,6561 } },
    6531. 

  6531.     { "Canon EOS 550D", 0, 0x3dd7,
    6532. 

  6532. 	{ 6941,-1164,-857,-3825,11597,2534,-416,1540,6039 } },
    6533. 

  6533.     { "Canon EOS 600D", 0, 0x3510,
    6534. 

  6534. 	{ 6461,-907,-882,-4300,12184,2378,-819,1944,5931 } },
    6535. 

  6535.     { "Canon EOS 1000D", 0, 0xe43,
    6536. 

  6536. 	{ 6771,-1139,-977,-7818,15123,2928,-1244,1437,7533 } },
    6537. 

  6537.     { "Canon EOS 1100D", 0, 0x3510,
    6538. 

  6538. 	{ 6444,-904,-893,-4563,12308,2535,-903,2016,6728 } },
    6539. 

  6539.     { "Canon EOS-1Ds Mark III", 0, 0x3bb0,
    6540. 

  6540. 	{ 5859,-211,-930,-8255,16017,2353,-1732,1887,7448 } },
    6541. 

  6541.     { "Canon EOS-1Ds Mark II", 0, 0xe80,
    6542. 

  6542. 	{ 6517,-602,-867,-8180,15926,2378,-1618,1771,7633 } },
    6543. 

  6543.     { "Canon EOS-1D Mark IV", 0, 0x3bb0,
    6544. 

  6544. 	{ 6014,-220,-795,-4109,12014,2361,-561,1824,5787 } },
    6545. 

  6545.     { "Canon EOS-1D Mark III", 0, 0x3bb0,
    6546. 

  6546. 	{ 6291,-540,-976,-8350,16145,2311,-1714,1858,7326 } },
    6547. 

  6547.     { "Canon EOS-1D Mark II N", 0, 0xe80,
    6548. 

  6548. 	{ 6240,-466,-822,-8180,15825,2500,-1801,1938,8042 } },
    6549. 

  6549.     { "Canon EOS-1D Mark II", 0, 0xe80,
    6550. 

  6550. 	{ 6264,-582,-724,-8312,15948,2504,-1744,1919,8664 } },
    6551. 

  6551.     { "Canon EOS-1DS", 0, 0xe20,
    6552. 

  6552. 	{ 4374,3631,-1743,-7520,15212,2472,-2892,3632,8161 } },
    6553. 

  6553.     { "Canon EOS-1D", 0, 0xe20,
    6554. 

  6554. 	{ 6806,-179,-1020,-8097,16415,1687,-3267,4236,7690 } },
    6555. 

  6555.     { "Canon EOS", 0, 0,
    6556. 

  6556. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6557. 

  6557.     { "Canon PowerShot A530", 0, 0,
    6558. 

  6558. 	{ 0 } },	/* don't want the A5 matrix */
    6559. 

  6559.     { "Canon PowerShot A50", 0, 0,
    6560. 

  6560. 	{ -5300,9846,1776,3436,684,3939,-5540,9879,6200,-1404,11175,217 } },
    6561. 

  6561.     { "Canon PowerShot A5", 0, 0,
    6562. 

  6562. 	{ -4801,9475,1952,2926,1611,4094,-5259,10164,5947,-1554,10883,547 } },
    6563. 

  6563.     { "Canon PowerShot G10", 0, 0,
    6564. 

  6564. 	{ 11093,-3906,-1028,-5047,12492,2879,-1003,1750,5561 } },
    6565. 

  6565.     { "Canon PowerShot G11", 0, 0,
    6566. 

  6566. 	{ 12177,-4817,-1069,-1612,9864,2049,-98,850,4471 } },
    6567. 

  6567.     { "Canon PowerShot G12", 0, 0,
    6568. 

  6568. 	{ 13244,-5501,-1248,-1508,9858,1935,-270,1083,4366 } },
    6569. 

  6569.     { "Canon PowerShot G1", 0, 0,
    6570. 

  6570. 	{ -4778,9467,2172,4743,-1141,4344,-5146,9908,6077,-1566,11051,557 } },
    6571. 

  6571.     { "Canon PowerShot G2", 0, 0,
    6572. 

  6572. 	{ 9087,-2693,-1049,-6715,14382,2537,-2291,2819,7790 } },
    6573. 

  6573.     { "Canon PowerShot G3", 0, 0,
    6574. 

  6574. 	{ 9212,-2781,-1073,-6573,14189,2605,-2300,2844,7664 } },
    6575. 

  6575.     { "Canon PowerShot G5", 0, 0,
    6576. 

  6576. 	{ 9757,-2872,-933,-5972,13861,2301,-1622,2328,7212 } },
    6577. 

  6577.     { "Canon PowerShot G6", 0, 0,
    6578. 

  6578. 	{ 9877,-3775,-871,-7613,14807,3072,-1448,1305,7485 } },
    6579. 

  6579.     { "Canon PowerShot G9", 0, 0,
    6580. 

  6580. 	{ 7368,-2141,-598,-5621,13254,2625,-1418,1696,5743 } },
    6581. 

  6581.     { "Canon PowerShot Pro1", 0, 0,
    6582. 

  6582. 	{ 10062,-3522,-999,-7643,15117,2730,-765,817,7323 } },
    6583. 

  6583.     { "Canon PowerShot Pro70", 34, 0,
    6584. 

  6584. 	{ -4155,9818,1529,3939,-25,4522,-5521,9870,6610,-2238,10873,1342 } },
    6585. 

  6585.     { "Canon PowerShot Pro90", 0, 0,
    6586. 

  6586. 	{ -4963,9896,2235,4642,-987,4294,-5162,10011,5859,-1770,11230,577 } },
    6587. 

  6587.     { "Canon PowerShot S30", 0, 0,
    6588. 

  6588. 	{ 10566,-3652,-1129,-6552,14662,2006,-2197,2581,7670 } },
    6589. 

  6589.     { "Canon PowerShot S40", 0, 0,
    6590. 

  6590. 	{ 8510,-2487,-940,-6869,14231,2900,-2318,2829,9013 } },
    6591. 

  6591.     { "Canon PowerShot S45", 0, 0,
    6592. 

  6592. 	{ 8163,-2333,-955,-6682,14174,2751,-2077,2597,8041 } },
    6593. 

  6593.     { "Canon PowerShot S50", 0, 0,
    6594. 

  6594. 	{ 8882,-2571,-863,-6348,14234,2288,-1516,2172,6569 } },
    6595. 

  6595.     { "Canon PowerShot S60", 0, 0,
    6596. 

  6596. 	{ 8795,-2482,-797,-7804,15403,2573,-1422,1996,7082 } },
    6597. 

  6597.     { "Canon PowerShot S70", 0, 0,
    6598. 

  6598. 	{ 9976,-3810,-832,-7115,14463,2906,-901,989,7889 } },
    6599. 

  6599.     { "Canon PowerShot S90", 0, 0,
    6600. 

  6600. 	{ 12374,-5016,-1049,-1677,9902,2078,-83,852,4683 } },
    6601. 

  6601.     { "Canon PowerShot S95", 0, 0,
    6602. 

  6602. 	{ 13440,-5896,-1279,-1236,9598,1931,-180,1001,4651 } },
    6603. 

  6603.     { "Canon PowerShot S100", 0, 0,
    6604. 

  6604. 	{ 7968,-2565,-636,-2873,10697,2513,180,667,4211 } },
    6605. 

  6605.     { "Canon PowerShot A470", 0, 0,	/* DJC */
    6606. 

  6606. 	{ 12513,-4407,-1242,-2680,10276,2405,-878,2215,4734 } },
    6607. 

  6607.     { "Canon PowerShot A610", 0, 0,	/* DJC */
    6608. 

  6608. 	{ 15591,-6402,-1592,-5365,13198,2168,-1300,1824,5075 } },
    6609. 

  6609.     { "Canon PowerShot A620", 0, 0,	/* DJC */
    6610. 

  6610. 	{ 15265,-6193,-1558,-4125,12116,2010,-888,1639,5220 } },
    6611. 

  6611.     { "Canon PowerShot A630", 0, 0,	/* DJC */
    6612. 

  6612. 	{ 14201,-5308,-1757,-6087,14472,1617,-2191,3105,5348 } },
    6613. 

  6613.     { "Canon PowerShot A640", 0, 0,	/* DJC */
    6614. 

  6614. 	{ 13124,-5329,-1390,-3602,11658,1944,-1612,2863,4885 } },
    6615. 

  6615.     { "Canon PowerShot A650", 0, 0,	/* DJC */
    6616. 

  6616. 	{ 9427,-3036,-959,-2581,10671,1911,-1039,1982,4430 } },
    6617. 

  6617.     { "Canon PowerShot A720", 0, 0,	/* DJC */
    6618. 

  6618. 	{ 14573,-5482,-1546,-1266,9799,1468,-1040,1912,3810 } },
    6619. 

  6619.     { "Canon PowerShot S2 IS", 0, 0,    /* jlb */
    6620. 

  6620.       { 14062,-5199,-1446,-4712,12470,2243,-1286,2028,4836 } },   /* jlb - copied from Powershot S3 IS */
    6621. 

  6621.     { "Canon PowerShot S3 IS", 0, 0,	/* DJC */
    6622. 

  6622. 	{ 14062,-5199,-1446,-4712,12470,2243,-1286,2028,4836 } },
    6623. 

  6623.     { "Canon PowerShot SX1 IS", 0, 0,
    6624. 

  6624. 	{ 6578,-259,-502,-5974,13030,3309,-308,1058,4970 } },
    6625. 

  6625.     { "Canon PowerShot SX110 IS", 0, 0,	/* DJC */
    6626. 

  6626. 	{ 14134,-5576,-1527,-1991,10719,1273,-1158,1929,3581 } },
    6627. 

  6627.     { "CASIO EX-S20", 0, 0,		/* DJC */
    6628. 

  6628. 	{ 11634,-3924,-1128,-4968,12954,2015,-1588,2648,7206 } },
    6629. 

  6629.     { "CASIO EX-Z750", 0, 0,		/* DJC */
    6630. 

  6630. 	{ 10819,-3873,-1099,-4903,13730,1175,-1755,3751,4632 } },
    6631. 

  6631.     { "CASIO EX-Z10", 128, 0xfff,	/* DJC */
    6632. 

  6632. 	{ 9790,-3338,-603,-2321,10222,2099,-344,1273,4799 } },
    6633. 

  6633.     { "CINE 650", 0, 0,
    6634. 

  6634. 	{ 3390,480,-500,-800,3610,340,-550,2336,1192 } },
    6635. 

  6635.     { "CINE 660", 0, 0,
    6636. 

  6636. 	{ 3390,480,-500,-800,3610,340,-550,2336,1192 } },
    6637. 

  6637.     { "CINE", 0, 0,
    6638. 

  6638. 	{ 20183,-4295,-423,-3940,15330,3985,-280,4870,9800 } },
    6639. 

  6639.     { "Contax N Digital", 0, 0xf1e,
    6640. 

  6640. 	{ 7777,1285,-1053,-9280,16543,2916,-3677,5679,7060 } },
    6641. 

  6641.     { "EPSON R-D1", 0, 0,
    6642. 

  6642. 	{ 6827,-1878,-732,-8429,16012,2564,-704,592,7145 } },
    6643. 

  6643.     { "FUJIFILM FinePix E550", 0, 0,
    6644. 

  6644. 	{ 11044,-3888,-1120,-7248,15168,2208,-1531,2277,8069 } },
    6645. 

  6645.     { "FUJIFILM FinePix E900", 0, 0,
    6646. 

  6646. 	{ 9183,-2526,-1078,-7461,15071,2574,-2022,2440,8639 } },
    6647. 

  6647.     { "FUJIFILM FinePix F8", 0, 0,
    6648. 

  6648. 	{ 11044,-3888,-1120,-7248,15168,2208,-1531,2277,8069 } },
    6649. 

  6649.     { "FUJIFILM FinePix F7", 0, 0,
    6650. 

  6650. 	{ 10004,-3219,-1201,-7036,15047,2107,-1863,2565,7736 } },
    6651. 

  6651.     { "FUJIFILM FinePix S100FS", 514, 0,
    6652. 

  6652. 	{ 11521,-4355,-1065,-6524,13767,3058,-1466,1984,6045 } },
    6653. 

  6653.     { "FUJIFILM FinePix S200EXR", 512, 0x3fff,
    6654. 

  6654. 	{ 11401,-4498,-1312,-5088,12751,2613,-838,1568,5941 } },
    6655. 

  6655.     { "FUJIFILM FinePix S20Pro", 0, 0,
    6656. 

  6656. 	{ 10004,-3219,-1201,-7036,15047,2107,-1863,2565,7736 } },
    6657. 

  6657.     { "FUJIFILM FinePix S2Pro", 128, 0,
    6658. 

  6658. 	{ 12492,-4690,-1402,-7033,15423,1647,-1507,2111,7697 } },
    6659. 

  6659.     { "FUJIFILM FinePix S3Pro", 0, 0,
    6660. 

  6660. 	{ 11807,-4612,-1294,-8927,16968,1988,-2120,2741,8006 } },
    6661. 

  6661.     { "FUJIFILM FinePix S5Pro", 0, 0,
    6662. 

  6662. 	{ 12300,-5110,-1304,-9117,17143,1998,-1947,2448,8100 } },
    6663. 

  6663.     { "FUJIFILM FinePix S5000", 0, 0,
    6664. 

  6664. 	{ 8754,-2732,-1019,-7204,15069,2276,-1702,2334,6982 } },
    6665. 

  6665.     { "FUJIFILM FinePix S5100", 0, 0,
    6666. 

  6666. 	{ 11940,-4431,-1255,-6766,14428,2542,-993,1165,7421 } },
    6667. 

  6667.     { "FUJIFILM FinePix S5500", 0, 0,
    6668. 

  6668. 	{ 11940,-4431,-1255,-6766,14428,2542,-993,1165,7421 } },
    6669. 

  6669.     { "FUJIFILM FinePix S5200", 0, 0,
    6670. 

  6670. 	{ 9636,-2804,-988,-7442,15040,2589,-1803,2311,8621 } },
    6671. 

  6671.     { "FUJIFILM FinePix S5600", 0, 0,
    6672. 

  6672. 	{ 9636,-2804,-988,-7442,15040,2589,-1803,2311,8621 } },
    6673. 

  6673.     { "FUJIFILM FinePix S6", 0, 0,
    6674. 

  6674. 	{ 12628,-4887,-1401,-6861,14996,1962,-2198,2782,7091 } },
    6675. 

  6675.     { "FUJIFILM FinePix S7000", 0, 0,
    6676. 

  6676. 	{ 10190,-3506,-1312,-7153,15051,2238,-2003,2399,7505 } },
    6677. 

  6677.     { "FUJIFILM FinePix S9000", 0, 0,
    6678. 

  6678. 	{ 10491,-3423,-1145,-7385,15027,2538,-1809,2275,8692 } },
    6679. 

  6679.     { "FUJIFILM FinePix S9500", 0, 0,
    6680. 

  6680. 	{ 10491,-3423,-1145,-7385,15027,2538,-1809,2275,8692 } },
    6681. 

  6681.     { "FUJIFILM FinePix S9100", 0, 0,
    6682. 

  6682. 	{ 12343,-4515,-1285,-7165,14899,2435,-1895,2496,8800 } },
    6683. 

  6683.     { "FUJIFILM FinePix S9600", 0, 0,
    6684. 

  6684. 	{ 12343,-4515,-1285,-7165,14899,2435,-1895,2496,8800 } },
    6685. 

  6685.     { "FUJIFILM IS-1", 0, 0,
    6686. 

  6686. 	{ 21461,-10807,-1441,-2332,10599,1999,289,875,7703 } },
    6687. 

  6687.     { "FUJIFILM IS Pro", 0, 0,
    6688. 

  6688. 	{ 12300,-5110,-1304,-9117,17143,1998,-1947,2448,8100 } },
    6689. 

  6689.     { "FUJIFILM FinePix HS10 HS11", 0, 0xf68,
    6690. 

  6690. 	{ 12440,-3954,-1183,-1123,9674,1708,-83,1614,4086 } },
    6691. 

  6691.     { "FUJIFILM FinePix HS20EXR", 0, 0,
    6692. 

  6692. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6693. 

  6693.     { "FUJIFILM FinePix F550EXR", 0, 0,
    6694. 

  6694. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6695. 

  6695.     { "FUJIFILM FinePix F600EXR", 0, 0,
    6696. 

  6696. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6697. 

  6697.     { "FUJIFILM FinePix X100", 0, 0,
    6698. 

  6698. 	{ 12161,-4457,-1069,-5034,12874,2400,-795,1724,6904 } },
    6699. 

  6699.     { "FUJIFILM X10", 0, 0,
    6700. 

  6700. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6701. 

  6701.     { "Imacon Ixpress", 0, 0,		/* DJC */
    6702. 

  6702. 	{ 7025,-1415,-704,-5188,13765,1424,-1248,2742,6038 } },
    6703. 

  6703.     { "KODAK NC2000", 0, 0,
    6704. 

  6704. 	{ 13891,-6055,-803,-465,9919,642,2121,82,1291 } },
    6705. 

  6705.     { "Kodak DCS315C", 8, 0,
    6706. 

  6706. 	{ 17523,-4827,-2510,756,8546,-137,6113,1649,2250 } },
    6707. 

  6707.     { "Kodak DCS330C", 8, 0,
    6708. 

  6708. 	{ 20620,-7572,-2801,-103,10073,-396,3551,-233,2220 } },
    6709. 

  6709.     { "KODAK DCS420", 0, 0,
    6710. 

  6710. 	{ 10868,-1852,-644,-1537,11083,484,2343,628,2216 } },
    6711. 

  6711.     { "KODAK DCS460", 0, 0,
    6712. 

  6712. 	{ 10592,-2206,-967,-1944,11685,230,2206,670,1273 } },
    6713. 

  6713.     { "KODAK EOSDCS1", 0, 0,
    6714. 

  6714. 	{ 10592,-2206,-967,-1944,11685,230,2206,670,1273 } },
    6715. 

  6715.     { "KODAK EOSDCS3B", 0, 0,
    6716. 

  6716. 	{ 9898,-2700,-940,-2478,12219,206,1985,634,1031 } },
    6717. 

  6717.     { "Kodak DCS520C", 180, 0,
    6718. 

  6718. 	{ 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } },
    6719. 

  6719.     { "Kodak DCS560C", 188, 0,
    6720. 

  6720. 	{ 20482,-7172,-3125,-1033,10410,-285,2542,226,3136 } },
    6721. 

  6721.     { "Kodak DCS620C", 180, 0,
    6722. 

  6722. 	{ 23617,-10175,-3149,-2054,11749,-272,2586,-489,3453 } },
    6723. 

  6723.     { "Kodak DCS620X", 185, 0,
    6724. 

  6724. 	{ 13095,-6231,154,12221,-21,-2137,895,4602,2258 } },
    6725. 

  6725.     { "Kodak DCS660C", 214, 0,
    6726. 

  6726. 	{ 18244,-6351,-2739,-791,11193,-521,3711,-129,2802 } },
    6727. 

  6727.     { "Kodak DCS720X", 0, 0,
    6728. 

  6728. 	{ 11775,-5884,950,9556,1846,-1286,-1019,6221,2728 } },
    6729. 

  6729.     { "Kodak DCS760C", 0, 0,
    6730. 

  6730. 	{ 16623,-6309,-1411,-4344,13923,323,2285,274,2926 } },
    6731. 

  6731.     { "Kodak DCS Pro SLR", 0, 0,
    6732. 

  6732. 	{ 5494,2393,-232,-6427,13850,2846,-1876,3997,5445 } },
    6733. 

  6733.     { "Kodak DCS Pro 14nx", 0, 0,
    6734. 

  6734. 	{ 5494,2393,-232,-6427,13850,2846,-1876,3997,5445 } },
    6735. 

  6735.     { "Kodak DCS Pro 14", 0, 0,
    6736. 

  6736. 	{ 7791,3128,-776,-8588,16458,2039,-2455,4006,6198 } },
    6737. 

  6737.     { "Kodak ProBack645", 0, 0,
    6738. 

  6738. 	{ 16414,-6060,-1470,-3555,13037,473,2545,122,4948 } },
    6739. 

  6739.     { "Kodak ProBack", 0, 0,
    6740. 

  6740. 	{ 21179,-8316,-2918,-915,11019,-165,3477,-180,4210 } },
    6741. 

  6741.     { "KODAK P712", 0, 0,
    6742. 

  6742. 	{ 9658,-3314,-823,-5163,12695,2768,-1342,1843,6044 } },
    6743. 

  6743.     { "KODAK P850", 0, 0xf7c,
    6744. 

  6744. 	{ 10511,-3836,-1102,-6946,14587,2558,-1481,1792,6246 } },
    6745. 

  6745.     { "KODAK P880", 0, 0xfff,
    6746. 

  6746. 	{ 12805,-4662,-1376,-7480,15267,2360,-1626,2194,7904 } },
    6747. 

  6747.     { "KODAK EasyShare Z980", 0, 0,
    6748. 

  6748. 	{ 11313,-3559,-1101,-3893,11891,2257,-1214,2398,4908 } },
    6749. 

  6749.     { "KODAK EasyShare Z981", 0, 0,
    6750. 

  6750. 	{ 12729,-4717,-1188,-1367,9187,2582,274,860,4411 } },
    6751. 

  6751.     { "KODAK EasyShare Z990", 0, 0xfed,
    6752. 

  6752. 	{ 11749,-4048,-1309,-1867,10572,1489,-138,1449,4522 } },
    6753. 

  6753.     { "KODAK EASYSHARE Z1015", 0, 0xef1,
    6754. 

  6754. 	{ 11265,-4286,-992,-4694,12343,2647,-1090,1523,5447 } },
    6755. 

  6755.     { "Leaf CMost", 0, 0,
    6756. 

  6756. 	{ 3952,2189,449,-6701,14585,2275,-4536,7349,6536 } },
    6757. 

  6757.     { "Leaf Valeo 6", 0, 0,
    6758. 

  6758. 	{ 3952,2189,449,-6701,14585,2275,-4536,7349,6536 } },
    6759. 

  6759.     { "Leaf Aptus 54S", 0, 0,
    6760. 

  6760. 	{ 8236,1746,-1314,-8251,15953,2428,-3673,5786,5771 } },
    6761. 

  6761.     { "Leaf Aptus 65", 0, 0,
    6762. 

  6762. 	{ 7914,1414,-1190,-8777,16582,2280,-2811,4605,5562 } },
    6763. 

  6763.     { "Leaf Aptus 75", 0, 0,
    6764. 

  6764. 	{ 7914,1414,-1190,-8777,16582,2280,-2811,4605,5562 } },
    6765. 

  6765.     { "Leaf Aptus 22", 0, 0,
    6766. 

  6766.       { 8236, 1746, -1314, -8251, 15953, 2428, -3673, 5786, 5770, } },
    6767. 

  6767.     { "Leaf Aptus-II 5", 0, 0,                                                    // Mamiya 645 AFD
    6768. 

  6768.       { 8236, 1746, -1314, -8251, 15953, 2428, -3673, 5786, 5770, } },
    6769. 

  6769.     { "Leaf Aptus-II 6", 0, 0,
    6770. 

  6770.       { 7914, 1414, -1190, -8777, 16582, 2280, -2811, 4605, 5562, } },
    6771. 

  6771.     { "Leaf Aptus-II 7", 0, 0,
    6772. 

  6772.       { 7914, 1414, -1190, -8777, 16582, 2280, -2811, 4605, 5562, } },
    6773. 

  6773.     { "Leaf Aptus-II 8", 0, 0,                                                    // Hasselblad 500 Series
    6774. 

  6774.       { 8236, 1746, -1314, -8251, 15953, 2428, -3673, 5786, 5770, } },
    6775. 

  6775.     { "Leaf Aptus-II 10", 0, 0,
    6776. 

  6776.       { 8236, 1746, -1314, -8251, 15953, 2428, -3673, 5786, 5770, } },
    6777. 

  6777.     { "Leaf Aptus-II 10R", 0, 0,
    6778. 

  6778.       { 8236, 1746, -1314, -8251, 15953, 2428, -3673, 5786, 5770, } },
    6779. 

  6779.     { "Leaf Aptus-II 12", 0, 0,
    6780. 

  6780.       { 8236, 1746, -1314, -8251, 15953, 2428, -3673, 5786, 5770, } },
    6781. 

  6781.     { "Leaf", 0, 0,
    6782. 

  6782. 	{ 8236,1746,-1314,-8251,15953,2428,-3673,5786,5771 } },
    6783. 

  6783.     { "Mamiya ZD", 0, 0,
    6784. 

  6784. 	{ 7645,2579,-1363,-8689,16717,2015,-3712,5941,5961 } },
    6785. 

  6785.     { "Micron 2010", 110, 0,		/* DJC */
    6786. 

  6786. 	{ 16695,-3761,-2151,155,9682,163,3433,951,4904 } },
    6787. 

  6787.     { "Minolta DiMAGE 5", 0, 0xf7d,
    6788. 

  6788. 	{ 8983,-2942,-963,-6556,14476,2237,-2426,2887,8014 } },
    6789. 

  6789.     { "Minolta DiMAGE 7Hi", 0, 0xf7d,
    6790. 

  6790. 	{ 11368,-3894,-1242,-6521,14358,2339,-2475,3056,7285 } },
    6791. 

  6791.     { "Minolta DiMAGE 7", 0, 0xf7d,
    6792. 

  6792. 	{ 9144,-2777,-998,-6676,14556,2281,-2470,3019,7744 } },
    6793. 

  6793.     { "Minolta DiMAGE A1", 0, 0xf8b,
    6794. 

  6794. 	{ 9274,-2547,-1167,-8220,16323,1943,-2273,2720,8340 } },
    6795. 

  6795.     { "MINOLTA DiMAGE A200", 0, 0,
    6796. 

  6796. 	{ 8560,-2487,-986,-8112,15535,2771,-1209,1324,7743 } },
    6797. 

  6797.     { "Minolta DiMAGE A2", 0, 0xf8f,
    6798. 

  6798. 	{ 9097,-2726,-1053,-8073,15506,2762,-966,981,7763 } },
    6799. 

  6799.     { "Minolta DiMAGE Z2", 0, 0,	/* DJC */
    6800. 

  6800. 	{ 11280,-3564,-1370,-4655,12374,2282,-1423,2168,5396 } },
    6801. 

  6801.     { "MINOLTA DYNAX 5", 0, 0xffb,
    6802. 

  6802. 	{ 10284,-3283,-1086,-7957,15762,2316,-829,882,6644 } },
    6803. 

  6803.     { "MINOLTA DYNAX 7", 0, 0xffb,
    6804. 

  6804. 	{ 10239,-3104,-1099,-8037,15727,2451,-927,925,6871 } },
    6805. 

  6805.     { "MOTOROLA PIXL", 0, 0,		/* DJC */
    6806. 

  6806. 	{ 8898,-989,-1033,-3292,11619,1674,-661,3178,5216 } },
    6807. 

  6807.     { "NIKON D100", 0, 0,
    6808. 

  6808. 	{ 5902,-933,-782,-8983,16719,2354,-1402,1455,6464 } },
    6809. 

  6809.     { "NIKON D1H", 0, 0,
    6810. 

  6810. 	{ 7577,-2166,-926,-7454,15592,1934,-2377,2808,8606 } },
    6811. 

  6811.     { "NIKON D1X", 0, 0,
    6812. 

  6812. 	{ 7702,-2245,-975,-9114,17242,1875,-2679,3055,8521 } },
    6813. 

  6813.     { "NIKON D1", 0, 0, /* multiplied by 2.218750, 1.0, 1.148438 */
    6814. 

  6814. 	{ 16772,-4726,-2141,-7611,15713,1972,-2846,3494,9521 } },
    6815. 

  6815.     { "NIKON D200", 0, 0xfbc,
    6816. 

  6816. 	{ 8367,-2248,-763,-8758,16447,2422,-1527,1550,8053 } },
    6817. 

  6817.     { "NIKON D2H", 0, 0,
    6818. 

  6818. 	{ 5710,-901,-615,-8594,16617,2024,-2975,4120,6830 } },
    6819. 

  6819.     { "NIKON D2X", 0, 0,
    6820. 

  6820. 	{ 10231,-2769,-1255,-8301,15900,2552,-797,680,7148 } },
    6821. 

  6821.     { "NIKON D3000", 0, 0,
    6822. 

  6822. 	{ 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
    6823. 

  6823.     { "NIKON D3100", 0, 0,
    6824. 

  6824. 	{ 7911,-2167,-813,-5327,13150,2408,-1288,2483,7968 } },
    6825. 

  6825.     { "NIKON D300", 0, 0,
    6826. 

  6826. 	{ 9030,-1992,-715,-8465,16302,2255,-2689,3217,8069 } },
    6827. 

  6827.     { "NIKON D3X", 0, 0,
    6828. 

  6828. 	{ 7171,-1986,-648,-8085,15555,2718,-2170,2512,7457 } },
    6829. 

  6829.     { "NIKON D3S", 0, 0,
    6830. 

  6830. 	{ 8828,-2406,-694,-4874,12603,2541,-660,1509,7587 } },
    6831. 

  6831.     { "NIKON D3", 0, 0,
    6832. 

  6832. 	{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
    6833. 

  6833.     { "NIKON D40X", 0, 0,
    6834. 

  6834. 	{ 8819,-2543,-911,-9025,16928,2151,-1329,1213,8449 } },
    6835. 

  6835.     { "NIKON D40", 0, 0,
    6836. 

  6836. 	{ 6992,-1668,-806,-8138,15748,2543,-874,850,7897 } },
    6837. 

  6837.     { "NIKON D5000", 0, 0xf00,
    6838. 

  6838. 	{ 7309,-1403,-519,-8474,16008,2622,-2433,2826,8064 } },
    6839. 

  6839.     { "NIKON D5100", 0, 0x3de6,
    6840. 

  6840. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6841. 

  6841.     { "NIKON D50", 0, 0,
    6842. 

  6842. 	{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
    6843. 

  6843.     { "NIKON D60", 0, 0,
    6844. 

  6844. 	{ 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
    6845. 

  6845.     { "NIKON D7000", 0, 0,
    6846. 

  6846. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6847. 

  6847.     { "NIKON D700", 0, 0,
    6848. 

  6848. 	{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
    6849. 

  6849.     { "NIKON D70", 0, 0,
    6850. 

  6850. 	{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
    6851. 

  6851.     { "NIKON D80", 0, 0,
    6852. 

  6852. 	{ 8629,-2410,-883,-9055,16940,2171,-1490,1363,8520 } },
    6853. 

  6853.     { "NIKON D90", 0, 0xf00,
    6854. 

  6854. 	{ 7309,-1403,-519,-8474,16008,2622,-2434,2826,8064 } },
    6855. 

  6855.     { "NIKON E950", 0, 0x3dd,		/* DJC */
    6856. 

  6856. 	{ -3746,10611,1665,9621,-1734,2114,-2389,7082,3064,3406,6116,-244 } },
    6857. 

  6857.     { "NIKON E995", 0, 0,	/* copied from E5000 */
    6858. 

  6858. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6859. 

  6859.     { "NIKON E2100", 0, 0,	/* copied from Z2, new white balance */
    6860. 

  6860. 	{ 13142,-4152,-1596,-4655,12374,2282,-1769,2696,6711} },
    6861. 

  6861.     { "NIKON E2500", 0, 0,
    6862. 

  6862. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6863. 

  6863.     { "NIKON E3200", 0, 0,		/* DJC */
    6864. 

  6864. 	{ 9846,-2085,-1019,-3278,11109,2170,-774,2134,5745 } },
    6865. 

  6865.     { "NIKON E4300", 0, 0,	/* copied from Minolta DiMAGE Z2 */
    6866. 

  6866. 	{ 11280,-3564,-1370,-4655,12374,2282,-1423,2168,5396 } },
    6867. 

  6867.     { "NIKON E4500", 0, 0,
    6868. 

  6868. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6869. 

  6869.     { "NIKON E5000", 0, 0,
    6870. 

  6870. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6871. 

  6871.     { "NIKON E5400", 0, 0,
    6872. 

  6872. 	{ 9349,-2987,-1001,-7919,15766,2266,-2098,2680,6839 } },
    6873. 

  6873.     { "NIKON E5700", 0, 0,
    6874. 

  6874. 	{ -5368,11478,2368,5537,-113,3148,-4969,10021,5782,778,9028,211 } },
    6875. 

  6875.     { "NIKON E8400", 0, 0,
    6876. 

  6876. 	{ 7842,-2320,-992,-8154,15718,2599,-1098,1342,7560 } },
    6877. 

  6877.     { "NIKON E8700", 0, 0,
    6878. 

  6878. 	{ 8489,-2583,-1036,-8051,15583,2643,-1307,1407,7354 } },
    6879. 

  6879.     { "NIKON E8800", 0, 0,
    6880. 

  6880. 	{ 7971,-2314,-913,-8451,15762,2894,-1442,1520,7610 } },
    6881. 

  6881.     { "NIKON COOLPIX P6000", 0, 0,
    6882. 

  6882. 	{ 9698,-3367,-914,-4706,12584,2368,-837,968,5801 } },
    6883. 

  6883.     { "NIKON COOLPIX P7000", 0, 0,
    6884. 

  6884. 	{ 11432,-3679,-1111,-3169,11239,2202,-791,1380,4455 } },
    6885. 

  6885.     { "NIKON COOLPIX P7100", 0, 0,
    6886. 

  6886. 	{ 11053,-4269,-1024,-1976,10182,2088,-526,1263,4469 } },
    6887. 

  6887.     { "NIKON 1 ", 0, 0,
    6888. 

  6888. 	{ 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
    6889. 

  6889.     { "OLYMPUS C5050", 0, 0,
    6890. 

  6890. 	{ 10508,-3124,-1273,-6079,14294,1901,-1653,2306,6237 } },
    6891. 

  6891.     { "OLYMPUS C5060", 0, 0,
    6892. 

  6892. 	{ 10445,-3362,-1307,-7662,15690,2058,-1135,1176,7602 } },
    6893. 

  6893.     { "OLYMPUS C7070", 0, 0,
    6894. 

  6894. 	{ 10252,-3531,-1095,-7114,14850,2436,-1451,1723,6365 } },
    6895. 

  6895.     { "OLYMPUS C70", 0, 0,
    6896. 

  6896. 	{ 10793,-3791,-1146,-7498,15177,2488,-1390,1577,7321 } },
    6897. 

  6897.     { "OLYMPUS C80", 0, 0,
    6898. 

  6898. 	{ 8606,-2509,-1014,-8238,15714,2703,-942,979,7760 } },
    6899. 

  6899.     { "OLYMPUS E-10", 0, 0xffc,
    6900. 

  6900. 	{ 12745,-4500,-1416,-6062,14542,1580,-1934,2256,6603 } },
    6901. 

  6901.     { "OLYMPUS E-1", 0, 0,
    6902. 

  6902. 	{ 11846,-4767,-945,-7027,15878,1089,-2699,4122,8311 } },
    6903. 

  6903.     { "OLYMPUS E-20", 0, 0xffc,
    6904. 

  6904. 	{ 13173,-4732,-1499,-5807,14036,1895,-2045,2452,7142 } },
    6905. 

  6905.     { "OLYMPUS E-300", 0, 0,
    6906. 

  6906. 	{ 7828,-1761,-348,-5788,14071,1830,-2853,4518,6557 } },
    6907. 

  6907.     { "OLYMPUS E-330", 0, 0,
    6908. 

  6908. 	{ 8961,-2473,-1084,-7979,15990,2067,-2319,3035,8249 } },
    6909. 

  6909.     { "OLYMPUS E-30", 0, 0xfbc,
    6910. 

  6910. 	{ 8144,-1861,-1111,-7763,15894,1929,-1865,2542,7607 } },
    6911. 

  6911.     { "OLYMPUS E-3", 0, 0xf99,
    6912. 

  6912. 	{ 9487,-2875,-1115,-7533,15606,2010,-1618,2100,7389 } },
    6913. 

  6913.     { "OLYMPUS E-400", 0, 0,
    6914. 

  6914. 	{ 6169,-1483,-21,-7107,14761,2536,-2904,3580,8568 } },
    6915. 

  6915.     { "OLYMPUS E-410", 0, 0xf6a,
    6916. 

  6916. 	{ 8856,-2582,-1026,-7761,15766,2082,-2009,2575,7469 } },
    6917. 

  6917.     { "OLYMPUS E-420", 0, 0xfd7,
    6918. 

  6918. 	{ 8746,-2425,-1095,-7594,15612,2073,-1780,2309,7416 } },
    6919. 

  6919.     { "OLYMPUS E-450", 0, 0xfd2,
    6920. 

  6920. 	{ 8745,-2425,-1095,-7594,15613,2073,-1780,2309,7416 } },
    6921. 

  6921.     { "OLYMPUS E-500", 0, 0,
    6922. 

  6922. 	{ 8136,-1968,-299,-5481,13742,1871,-2556,4205,6630 } },
    6923. 

  6923.     { "OLYMPUS E-510", 0, 0xf6a,
    6924. 

  6924. 	{ 8785,-2529,-1033,-7639,15624,2112,-1783,2300,7817 } },
    6925. 

  6925.     { "OLYMPUS E-520", 0, 0xfd2,
    6926. 

  6926. 	{ 8344,-2322,-1020,-7596,15635,2048,-1748,2269,7287 } },
    6927. 

  6927.     { "OLYMPUS E-5", 0, 0,
    6928. 

  6928. 	{ 11200,-3783,-1325,-4576,12593,2206,-695,1742,7504 } },
    6929. 

  6929.     { "OLYMPUS E-600", 0, 0xfaf,
    6930. 

  6930. 	{ 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
    6931. 

  6931.     { "OLYMPUS E-620", 0, 0xfaf,
    6932. 

  6932. 	{ 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
    6933. 

  6933.     { "OLYMPUS E-P1", 0, 0xffd,
    6934. 

  6934. 	{ 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
    6935. 

  6935.     { "OLYMPUS E-P2", 0, 0xffd,
    6936. 

  6936. 	{ 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
    6937. 

  6937.     { "OLYMPUS E-P3", 0, 0,
    6938. 

  6938. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6939. 

  6939.     { "OLYMPUS E-PL1s", 0, 0,
    6940. 

  6940. 	{ 11409,-3872,-1393,-4572,12757,2003,-709,1810,7415 } },
    6941. 

  6941.     { "OLYMPUS E-PL1", 0, 0,
    6942. 

  6942. 	{ 11408,-4289,-1215,-4286,12385,2118,-387,1467,7787 } },
    6943. 

  6943.     { "OLYMPUS E-PL2", 0, 0,
    6944. 

  6944. 	{ 15030,-5552,-1806,-3987,12387,1767,-592,1670,7023 } },
    6945. 

  6945.     { "OLYMPUS E-PL3", 0, 0,
    6946. 

  6946. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6947. 

  6947.     { "OLYMPUS E-PM1", 0, 0,
    6948. 

  6948. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6949. 

  6949.     { "OLYMPUS SP350", 0, 0,
    6950. 

  6950. 	{ 12078,-4836,-1069,-6671,14306,2578,-786,939,7418 } },
    6951. 

  6951.     { "OLYMPUS SP3", 0, 0,
    6952. 

  6952. 	{ 11766,-4445,-1067,-6901,14421,2707,-1029,1217,7572 } },
    6953. 

  6953.     { "OLYMPUS SP500UZ", 0, 0xfff,
    6954. 

  6954. 	{ 9493,-3415,-666,-5211,12334,3260,-1548,2262,6482 } },
    6955. 

  6955.     { "OLYMPUS SP510UZ", 0, 0xffe,
    6956. 

  6956. 	{ 10593,-3607,-1010,-5881,13127,3084,-1200,1805,6721 } },
    6957. 

  6957.     { "OLYMPUS SP550UZ", 0, 0xffe,
    6958. 

  6958. 	{ 11597,-4006,-1049,-5432,12799,2957,-1029,1750,6516 } },
    6959. 

  6959.     { "OLYMPUS SP560UZ", 0, 0xff9,
    6960. 

  6960. 	{ 10915,-3677,-982,-5587,12986,2911,-1168,1968,6223 } },
    6961. 

  6961.     { "OLYMPUS SP570UZ", 0, 0,
    6962. 

  6962. 	{ 11522,-4044,-1146,-4736,12172,2904,-988,1829,6039 } },
    6963. 

  6963.     { "OLYMPUS XZ-1", 0, 0,
    6964. 

  6964. 	{ 10901,-4095,-1074,-1141,9208,2293,-62,1417,5158 } },
    6965. 

  6965.     { "PENTAX *ist DL2", 0, 0,
    6966. 

  6966. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    6967. 

  6967.     { "PENTAX *ist DL", 0, 0,
    6968. 

  6968. 	{ 10829,-2838,-1115,-8339,15817,2696,-837,680,11939 } },
    6969. 

  6969.     { "PENTAX *ist DS2", 0, 0,
    6970. 

  6970. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    6971. 

  6971.     { "PENTAX *ist DS", 0, 0,
    6972. 

  6972. 	{ 10371,-2333,-1206,-8688,16231,2602,-1230,1116,11282 } },
    6973. 

  6973.     { "PENTAX *ist D", 0, 0,
    6974. 

  6974. 	{ 9651,-2059,-1189,-8881,16512,2487,-1460,1345,10687 } },
    6975. 

  6975.     { "PENTAX K10D", 0, 0,
    6976. 

  6976. 	{ 9566,-2863,-803,-7170,15172,2112,-818,803,9705 } },
    6977. 

  6977.     { "PENTAX K1", 0, 0,
    6978. 

  6978. 	{ 11095,-3157,-1324,-8377,15834,2720,-1108,947,11688 } },
    6979. 

  6979.     { "PENTAX K20D", 0, 0,
    6980. 

  6980. 	{ 9427,-2714,-868,-7493,16092,1373,-2199,3264,7180 } },
    6981. 

  6981.     { "PENTAX K200D", 0, 0,
    6982. 

  6982. 	{ 9186,-2678,-907,-8693,16517,2260,-1129,1094,8524 } },
    6983. 

  6983.     { "PENTAX K2000", 0, 0,
    6984. 

  6984. 	{ 11057,-3604,-1155,-5152,13046,2329,-282,375,8104 } },
    6985. 

  6985.     { "PENTAX K-m", 0, 0,
    6986. 

  6986. 	{ 11057,-3604,-1155,-5152,13046,2329,-282,375,8104 } },
    6987. 

  6987.     { "PENTAX K-x", 0, 0,
    6988. 

  6988. 	{ 8843,-2837,-625,-5025,12644,2668,-411,1234,7410 } },
    6989. 

  6989.     { "PENTAX K-r", 0, 0,
    6990. 

  6990. 	{ 9895,-3077,-850,-5304,13035,2521,-883,1768,6936 } },
    6991. 

  6991.     { "PENTAX K-5", 0, 0,
    6992. 

  6992. 	{ 8713,-2833,-743,-4342,11900,2772,-722,1543,6247 } },
    6993. 

  6993.     { "PENTAX K-7", 0, 0,
    6994. 

  6994. 	{ 9142,-2947,-678,-8648,16967,1663,-2224,2898,8615 } },
    6995. 

  6995.     { "PENTAX 645D", 0, 0x3e00,
    6996. 

  6996. 	{ 10646,-3593,-1158,-3329,11699,1831,-667,2874,6287 } },
    6997. 

  6997.     { "Panasonic DMC-FZ8", 0, 0xf7f,
    6998. 

  6998. 	{ 8986,-2755,-802,-6341,13575,3077,-1476,2144,6379 } },
    6999. 

  6999.     { "Panasonic DMC-FZ18", 0, 0,
    7000. 

  7000. 	{ 9932,-3060,-935,-5809,13331,2753,-1267,2155,5575 } },
    7001. 

  7001.     { "Panasonic DMC-FZ28", 15, 0xf96,
    7002. 

  7002. 	{ 10109,-3488,-993,-5412,12812,2916,-1305,2140,5543 } },
    7003. 

  7003.     { "Panasonic DMC-FZ30", 0, 0xf94,
    7004. 

  7004. 	{ 10976,-4029,-1141,-7918,15491,2600,-1670,2071,8246 } },
    7005. 

  7005.     { "Panasonic DMC-FZ3", 143, 0,
    7006. 

  7006. 	{ 9938,-2780,-890,-4604,12393,2480,-1117,2304,4620 } },
    7007. 

  7007.     { "Panasonic DMC-FZ4", 143, 0,
    7008. 

  7008. 	{ 13639,-5535,-1371,-1698,9633,2430,316,1152,4108 } },
    7009. 

  7009.     { "Panasonic DMC-FZ50", 0, 0,
    7010. 

  7010. 	{ 7906,-2709,-594,-6231,13351,3220,-1922,2631,6537 } },
    7011. 

  7011.     { "LEICA V-LUX1", 0, 0,
    7012. 

  7012. 	{ 7906,-2709,-594,-6231,13351,3220,-1922,2631,6537 } },
    7013. 

  7013.     { "Panasonic DMC-L10", 15, 0xf96,
    7014. 

  7014. 	{ 8025,-1942,-1050,-7920,15904,2100,-2456,3005,7039 } },
    7015. 

  7015.     { "Panasonic DMC-L1", 0, 0xf7f,
    7016. 

  7016. 	{ 8054,-1885,-1025,-8349,16367,2040,-2805,3542,7629 } },
    7017. 

  7017.     { "LEICA DIGILUX 3", 0, 0xf7f,
    7018. 

  7018. 	{ 8054,-1885,-1025,-8349,16367,2040,-2805,3542,7629 } },
    7019. 

  7019.     { "Panasonic DMC-LC1", 0, 0,
    7020. 

  7020. 	{ 11340,-4069,-1275,-7555,15266,2448,-2960,3426,7685 } },
    7021. 

  7021.     { "LEICA DIGILUX 2", 0, 0,
    7022. 

  7022. 	{ 11340,-4069,-1275,-7555,15266,2448,-2960,3426,7685 } },
    7023. 

  7023.     { "Panasonic DMC-LX1", 0, 0xf7f,
    7024. 

  7024. 	{ 10704,-4187,-1230,-8314,15952,2501,-920,945,8927 } },
    7025. 

  7025.     { "LEICA D-LUX2", 0, 0xf7f,
    7026. 

  7026. 	{ 10704,-4187,-1230,-8314,15952,2501,-920,945,8927 } },
    7027. 

  7027.     { "Panasonic DMC-LX2", 0, 0,
    7028. 

  7028. 	{ 8048,-2810,-623,-6450,13519,3272,-1700,2146,7049 } },
    7029. 

  7029.     { "LEICA D-LUX3", 0, 0,
    7030. 

  7030. 	{ 8048,-2810,-623,-6450,13519,3272,-1700,2146,7049 } },
    7031. 

  7031.     { "Panasonic DMC-LX3", 15, 0,
    7032. 

  7032. 	{ 8128,-2668,-655,-6134,13307,3161,-1782,2568,6083 } },
    7033. 

  7033.     { "LEICA D-LUX 4", 15, 0,
    7034. 

  7034. 	{ 8128,-2668,-655,-6134,13307,3161,-1782,2568,6083 } },
    7035. 

  7035.     { "Panasonic DMC-LX5", 143, 0,
    7036. 

  7036. 	{ 10909,-4295,-948,-1333,9306,2399,22,1738,4582 } },
    7037. 

  7037.     { "LEICA D-LUX 5", 143, 0,
    7038. 

  7038. 	{ 10909,-4295,-948,-1333,9306,2399,22,1738,4582 } },
    7039. 

  7039.     { "Panasonic DMC-FZ100", 143, 0xfff,
    7040. 

  7040. 	{ 16197,-6146,-1761,-2393,10765,1869,366,2238,5248 } },
    7041. 

  7041.     { "LEICA V-LUX 2", 143, 0xfff,
    7042. 

  7042. 	{ 16197,-6146,-1761,-2393,10765,1869,366,2238,5248 } },
    7043. 

  7043.     { "Panasonic DMC-FZ150", 143, 0xfff,
    7044. 

  7044. 	{ 11904,-4541,-1189,-2355,10899,1662,-296,1586,4289 } },
    7045. 

  7045.     { "LEICA V-LUX 3", 143, 0xfff,
    7046. 

  7046. 	{ 11904,-4541,-1189,-2355,10899,1662,-296,1586,4289 } },
    7047. 

  7047.     { "Panasonic DMC-FX150", 15, 0xfff,
    7048. 

  7048. 	{ 9082,-2907,-925,-6119,13377,3058,-1797,2641,5609 } },
    7049. 

  7049.     { "Panasonic DMC-G10", 0, 0,
    7050. 

  7050. 	{ 10113,-3400,-1114,-4765,12683,2317,-377,1437,6710 } },
    7051. 

  7051.     { "Panasonic DMC-G1", 15, 0xf94,
    7052. 

  7052. 	{ 8199,-2065,-1056,-8124,16156,2033,-2458,3022,7220 } },
    7053. 

  7053.     { "Panasonic DMC-G2", 15, 0xf3c,
    7054. 

  7054. 	{ 10113,-3400,-1114,-4765,12683,2317,-377,1437,6710 } },
    7055. 

  7055.     { "Panasonic DMC-G3", 143, 0xfff,
    7056. 

  7056. 	{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
    7057. 

  7057.     { "Panasonic DMC-GF1", 15, 0xf92,
    7058. 

  7058. 	{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
    7059. 

  7059.     { "Panasonic DMC-GF2", 143, 0xfff,
    7060. 

  7060. 	{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
    7061. 

  7061.     { "Panasonic DMC-GF3", 143, 0xfff,
    7062. 

  7062. 	{ 9051,-2468,-1204,-5212,13276,2121,-1197,2510,6890 } },
    7063. 

  7063.     { "Panasonic DMC-GH1", 15, 0xf92,
    7064. 

  7064. 	{ 6299,-1466,-532,-6535,13852,2969,-2331,3112,5984 } },
    7065. 

  7065.     { "Panasonic DMC-GH2", 15, 0xf95,
    7066. 

  7066. 	{ 7780,-2410,-806,-3913,11724,2484,-1018,2390,5298 } },
    7067. 

  7067.     { "Panasonic DMC-GX1", 143, 0,
    7068. 

  7068. 	{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
    7069. 

  7069.     { "Phase One H 20", 0, 0,		/* DJC */
    7070. 

  7070. 	{ 1313,1855,-109,-6715,15908,808,-327,1840,6020 } },
    7071. 

  7071.     { "Phase One H 25", 0, 0,
    7072. 

  7072. 	{ 2905,732,-237,-8134,16626,1476,-3038,4253,7517 } },
    7073. 

  7073.     { "Phase One P 2", 0, 0,
    7074. 

  7074. 	{ 2905,732,-237,-8134,16626,1476,-3038,4253,7517 } },
    7075. 

  7075.     { "Phase One P 30", 0, 0,
    7076. 

  7076. 	{ 4516,-245,-37,-7020,14976,2173,-3206,4671,7087 } },
    7077. 

  7077.     { "Phase One P 45", 0, 0,
    7078. 

  7078. 	{ 5053,-24,-117,-5684,14076,1702,-2619,4492,5849 } },
    7079. 

  7079.     { "Phase One P40", 0, 0,
    7080. 

  7080. 	{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
    7081. 

  7081.     { "Phase One P65", 0, 0,
    7082. 

  7082. 	{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
    7083. 

  7083.     { "RED ONE", 704, 0xffff,		/* DJC */
    7084. 

  7084. 	{ 21014,-7891,-2613,-3056,12201,856,-2203,5125,8042 } },
    7085. 

  7085.     { "SAMSUNG EX1", 0, 0x3e00,
    7086. 

  7086. 	{ 8898,-2498,-994,-3144,11328,2066,-760,1381,4576 } },
    7087. 

  7087.     { "SAMSUNG NX200", 0, 0xfff,
    7088. 

  7088. 	{ 6933,-2268,-753,-4921,13387,1647,-803,1641,6096 } },
    7089. 

  7089.     { "SAMSUNG NX", 0, 0,	/* NX5, NX10, NX11, NX100 */
    7090. 

  7090. 	{ 10332,-3234,-1168,-6111,14639,1520,-1352,2647,8331 } },
    7091. 

  7091.     { "SAMSUNG WB2000", 0, 0xfff,
    7092. 

  7092. 	{ 12093,-3557,-1155,-1000,9534,1733,-22,1787,4576 } },
    7093. 

  7093.     { "SAMSUNG GX-1", 0, 0,
    7094. 

  7094. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    7095. 

  7095.     { "SAMSUNG S85", 0, 0xffff,		/* DJC */
    7096. 

  7096. 	{ 11885,-3968,-1473,-4214,12299,1916,-835,1655,5549 } },
    7097. 

  7097.     { "Sinar", 0, 0,			/* DJC */
    7098. 

  7098. 	{ 16442,-2956,-2422,-2877,12128,750,-1136,6066,4559 } },
    7099. 

  7099.     { "SONY DSC-F828", 491, 0,
    7100. 

  7100. 	{ 7924,-1910,-777,-8226,15459,2998,-1517,2199,6818,-7242,11401,3481 } },
    7101. 

  7101.     { "SONY DSC-R1", 512, 0,
    7102. 

  7102. 	{ 8512,-2641,-694,-8042,15670,2526,-1821,2117,7414 } },
    7103. 

  7103.     { "SONY DSC-V3", 0, 0,
    7104. 

  7104. 	{ 7511,-2571,-692,-7894,15088,3060,-948,1111,8128 } },
    7105. 

  7105.     { "SONY DSLR-A100", 0, 0xfeb,
    7106. 

  7106. 	{ 9437,-2811,-774,-8405,16215,2290,-710,596,7181 } },
    7107. 

  7107.     { "SONY DSLR-A290", 0, 0,
    7108. 

  7108. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7109. 

  7109.     { "SONY DSLR-A2", 0, 0,
    7110. 

  7110. 	{ 9847,-3091,-928,-8485,16345,2225,-715,595,7103 } },
    7111. 

  7111.     { "SONY DSLR-A300", 0, 0,
    7112. 

  7112. 	{ 9847,-3091,-928,-8485,16345,2225,-715,595,7103 } },
    7113. 

  7113.     { "SONY DSLR-A330", 0, 0,
    7114. 

  7114. 	{ 9847,-3091,-929,-8485,16346,2225,-714,595,7103 } },
    7115. 

  7115.     { "SONY DSLR-A350", 0, 0xffc,
    7116. 

  7116. 	{ 6038,-1484,-578,-9146,16746,2513,-875,746,7217 } },
    7117. 

  7117.     { "SONY DSLR-A380", 0, 0,
    7118. 

  7118. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7119. 

  7119.     { "SONY DSLR-A390", 0, 0,
    7120. 

  7120. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7121. 

  7121.     { "SONY DSLR-A450", 128, 0xfeb,
    7122. 

  7122. 	{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
    7123. 

  7123.     { "SONY DSLR-A580", 128, 0xfeb,
    7124. 

  7124. 	{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
    7125. 

  7125.     { "SONY DSLR-A5", 128, 0xfeb,
    7126. 

  7126. 	{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
    7127. 

  7127.     { "SONY DSLR-A700", 126, 0,
    7128. 

  7128. 	{ 5775,-805,-359,-8574,16295,2391,-1943,2341,7249 } },
    7129. 

  7129.     { "SONY DSLR-A850", 128, 0,
    7130. 

  7130. 	{ 5413,-1162,-365,-5665,13098,2866,-608,1179,8440 } },
    7131. 

  7131.     { "SONY DSLR-A900", 128, 0,
    7132. 

  7132. 	{ 5209,-1072,-397,-8845,16120,2919,-1618,1803,8654 } },
    7133. 

  7133.     { "SONY NEX-5N", 128, 0,
    7134. 

  7134. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7135. 

  7135.     { "SONY NEX-C3", 128, 0,
    7136. 

  7136. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7137. 

  7137.     { "SONY NEX-3", 138, 0,		/* DJC */
    7138. 

  7138. 	{ 6907,-1256,-645,-4940,12621,2320,-1710,2581,6230 } },
    7139. 

  7139.     { "SONY NEX-5", 116, 0,		/* DJC */
    7140. 

  7140. 	{ 6807,-1350,-342,-4216,11649,2567,-1089,2001,6420 } },
    7141. 

  7141.     { "SONY NEX-3", 128, 0,		/* Adobe */
    7142. 

  7142. 	{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
    7143. 

  7143.     { "SONY NEX-5", 128, 0,		/* Adobe */
    7144. 

  7144. 	{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
    7145. 

  7145.     { "SONY NEX-7", 128, 0,
    7146. 

  7146. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7147. 

  7147.     { "SONY SLT-A33", 128, 0,
    7148. 

  7148. 	{ 6069,-1221,-366,-5221,12779,2734,-1024,2066,6834 } },
    7149. 

  7149.     { "SONY SLT-A35", 128, 0,
    7150. 

  7150. 	{ 5986,-1618,-415,-4557,11820,3120,-681,1404,6971 } },
    7151. 

  7151.     { "SONY SLT-A55", 128, 0,
    7152. 

  7152. 	{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
    7153. 

  7153.     { "SONY SLT-A65", 128, 0,
    7154. 

  7154. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7155. 

  7155.     { "SONY SLT-A77", 128, 0,
    7156. 

  7156. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } }
    7157. 

  7157.   };
    7158. 

  7158.   double cam_xyz[4][3];
    7159. 

  7159.   char name[130];
    7160. 

  7160.   int i, j;
    7161. 

  7161. 

  7162.   sprintf (name, "%s %s", p_make, p_model);
    7163. 

  7163.   for (i=0; i < sizeof table / sizeof *table; i++)
    7164. 

  7164.     if (!strncmp (name, table[i].prefix, strlen(table[i].prefix))) {
    7165. 

  7165.       if (table[i].t_black)   black   = (ushort) table[i].t_black;
    7166. 

  7166.       if (table[i].t_maximum) maximum = (ushort) table[i].t_maximum;
    7167. 

  7167.       if (table[i].trans[0]) {
    7168. 

  7168.         for (j=0; j < 12; j++)
    7169. 

  7169. #ifdef LIBRAW_LIBRARY_BUILD
    7170. 

  7170.           imgdata.color.cam_xyz[0][j] = 
    7171. 

  7171. #endif
    7172. 

  7172. 	  cam_xyz[0][j] = table[i].trans[j] / 10000.0;
    7173. 

  7173.       cam_xyz_coeff (cam_xyz);
    7174. 

  7174.       }
    7175. 

  7175.       break;
    7176. 

  7176.     }
    7177. 

  7177. }
    7178. 

  7178. 

  7179. void CLASS simple_coeff (int index)
    7180. 

  7180. {
    7181. 

  7181.   static const float table[][12] = {
    7182. 

  7182.   /* index 0 -- all Foveon cameras */
    7183. 

  7183.   { 1.4032,-0.2231,-0.1016,-0.5263,1.4816,0.017,-0.0112,0.0183,0.9113 },
    7184. 

  7184.   /* index 1 -- Kodak DC20 and DC25 */
    7185. 

  7185.   { 2.25,0.75,-1.75,-0.25,-0.25,0.75,0.75,-0.25,-0.25,-1.75,0.75,2.25 },
    7186. 

  7186.   /* index 2 -- Logitech Fotoman Pixtura */
    7187. 

  7187.   { 1.893,-0.418,-0.476,-0.495,1.773,-0.278,-1.017,-0.655,2.672 },
    7188. 

  7188.   /* index 3 -- Nikon E880, E900, and E990 */
    7189. 

  7189.   { -1.936280,  1.800443, -1.448486,  2.584324,
    7190. 

  7190.      1.405365, -0.524955, -0.289090,  0.408680,
    7191. 

  7191.     -1.204965,  1.082304,  2.941367, -1.818705 }
    7192. 

  7192.   };
    7193. 

  7193.   int i, c;
    7194. 

  7194. 

  7195.   for (raw_color = i=0; i < 3; i++)
    7196. 

  7196.     FORCC rgb_cam[i][c] = table[index][i*colors+c];
    7197. 

  7197. #ifdef LIBRAW_LIBRARY_BUILD
    7198. 

  7198.   color_flags.rgb_cam_state = LIBRAW_COLORSTATE_CALCULATED;
    7199. 

  7199. #endif
    7200. 

  7200. }
    7201. 

  7201. 

  7202. short CLASS guess_byte_order (int words)
    7203. 

  7203. {
    7204. 

  7204.   uchar test[4][2];
    7205. 

  7205.   int t=2, msb;
    7206. 

  7206.   double diff, sum[2] = {0,0};
    7207. 

  7207. 

  7208.   fread (test[0], 2, 2, ifp);
    7209. 

  7209.   for (words-=2; words--; ) {
    7210. 

  7210.     fread (test[t], 2, 1, ifp);
    7211. 

  7211.     for (msb=0; msb < 2; msb++) {
    7212. 

  7212.       diff = (test[t^2][msb] << 8 | test[t^2][!msb])
    7213. 

  7213. 	   - (test[t  ][msb] << 8 | test[t  ][!msb]);
    7214. 

  7214.       sum[msb] += diff*diff;
    7215. 

  7215.     }
    7216. 

  7216.     t = (t+1) & 3;
    7217. 

  7217.   }
    7218. 

  7218.   return sum[0] < sum[1] ? 0x4d4d : 0x4949;
    7219. 

  7219. }
    7220. 

  7220. 

  7221. 

  7222. float CLASS find_green (int bps, int bite, int off0, int off1)
    7223. 

  7223. {
    7224. 

  7224.   UINT64 bitbuf=0;
    7225. 

  7225.   int vbits, col, i, c;
    7226. 

  7226.   ushort img[2][2064];
    7227. 

  7227.   double sum[]={0,0};
    7228. 

  7228. 

  7229.   FORC(2) {
    7230. 

  7230.     fseek (ifp, c ? off1:off0, SEEK_SET);
    7231. 

  7231.     for (vbits=col=0; col < width; col++) {
    7232. 

  7232.       for (vbits -= bps; vbits < 0; vbits += bite) {
    7233. 

  7233. 	bitbuf <<= bite;
    7234. 

  7234. 	for (i=0; i < bite; i+=8)
    7235. 

  7235. 	  bitbuf |= (unsigned) (fgetc(ifp) << i);
    7236. 

  7236.       }
    7237. 

  7237.       img[c][col] = bitbuf << (64-bps-vbits) >> (64-bps);
    7238. 

  7238.     }
    7239. 

  7239.   }
    7240. 

  7240.   FORC(width-1) {
    7241. 

  7241.     sum[ c & 1] += ABS(img[0][c]-img[1][c+1]);
    7242. 

  7242.     sum[~c & 1] += ABS(img[1][c]-img[0][c+1]);
    7243. 

  7243.   }
    7244. 

  7244.   return 100 * log(sum[0]/sum[1]);
    7245. 

  7245. }
    7246. 

  7246. 

  7247. /*
    7248. 

  7248.    Identify which camera created this file, and set global variables
    7249. 

  7249.    accordingly.
    7250. 

  7250.  */
    7251. 

  7251. void CLASS identify()
    7252. 

  7252. {
    7253. 

  7253.   char head[32], *cp;
    7254. 

  7254.   int hlen, flen, fsize, zero_fsize=1, i, c, is_canon;
    7255. 

  7255.   struct jhead jh;
    7256. 

  7256.   short pana[][6] = {
    7257. 

  7257.     { 3130, 1743,  4,  0, -6,  0 },
    7258. 

  7258.     { 3130, 2055,  4,  0, -6,  0 },
    7259. 

  7259.     { 3130, 2319,  4,  0, -6,  0 },
    7260. 

  7260.     { 3170, 2103, 18,  0,-42, 20 },
    7261. 

  7261.     { 3170, 2367, 18, 13,-42,-21 },
    7262. 

  7262.     { 3177, 2367,  0,  0, -1,  0 },
    7263. 

  7263.     { 3304, 2458,  0,  0, -1,  0 },
    7264. 

  7264.     { 3330, 2463,  9,  0, -5,  0 },
    7265. 

  7265.     { 3330, 2479,  9,  0,-17,  4 },
    7266. 

  7266.     { 3370, 1899, 15,  0,-44, 20 },
    7267. 

  7267.     { 3370, 2235, 15,  0,-44, 20 },
    7268. 

  7268.     { 3370, 2511, 15, 10,-44,-21 },
    7269. 

  7269.     { 3690, 2751,  3,  0, -8, -3 },
    7270. 

  7270.     { 3710, 2751,  0,  0, -3,  0 },
    7271. 

  7271.     { 3724, 2450,  0,  0,  0, -2 },
    7272. 

  7272.     { 3770, 2487, 17,  0,-44, 19 },
    7273. 

  7273.     { 3770, 2799, 17, 15,-44,-19 },
    7274. 

  7274.     { 3880, 2170,  6,  0, -6,  0 },
    7275. 

  7275.     { 4060, 3018,  0,  0,  0, -2 },
    7276. 

  7276.     { 4290, 2391,  3,  0, -8, -1 },
    7277. 

  7277.     { 4330, 2439, 17, 15,-44,-19 },
    7278. 

  7278.     { 4508, 2962,  0,  0, -3, -4 },
    7279. 

  7279.     { 4508, 3330,  0,  0, -3, -6 } };
    7280. 

  7280.   static const struct {
    7281. 

  7281.     int fsize;
    7282. 

  7282.     char t_make[12], t_model[19], withjpeg;
    7283. 

  7283.   } table[] = {
    7284. 

  7284.     {    62464, "Kodak",    "DC20"            ,0 },
    7285. 

  7285.     {   124928, "Kodak",    "DC20"            ,0 },
    7286. 

  7286.     {  1652736, "Kodak",    "DCS200"          ,0 },
    7287. 

  7287.     {  4159302, "Kodak",    "C330"            ,0 },
    7288. 

  7288.     {  4162462, "Kodak",    "C330"            ,0 },
    7289. 

  7289.     {   460800, "Kodak",    "C603v"           ,0 },
    7290. 

  7290.     {   614400, "Kodak",    "C603v"           ,0 },
    7291. 

  7291.     {  6163328, "Kodak",    "C603"            ,0 },
    7292. 

  7292.     {  6166488, "Kodak",    "C603"            ,0 },
    7293. 

  7293.     {  9116448, "Kodak",    "C603y"           ,0 },
    7294. 

  7294.     {   311696, "ST Micro", "STV680 VGA"      ,0 },  /* SPYz */
    7295. 

  7295.     {   787456, "Creative", "PC-CAM 600"      ,0 },
    7296. 

  7296.     {  1138688, "Minolta",  "RD175"           ,0 },
    7297. 

  7297.     {  3840000, "Foculus",  "531C"            ,0 },
    7298. 

  7298.     {   786432, "AVT",      "F-080C"          ,0 },
    7299. 

  7299.     {  1447680, "AVT",      "F-145C"          ,0 },
    7300. 

  7300.     {  1920000, "AVT",      "F-201C"          ,0 },
    7301. 

  7301.     {  5067304, "AVT",      "F-510C"          ,0 },
    7302. 

  7302.     {  5067316, "AVT",      "F-510C"          ,0 },
    7303. 

  7303.     { 10134608, "AVT",      "F-510C"          ,0 },
    7304. 

  7304.     { 10134620, "AVT",      "F-510C"          ,0 },
    7305. 

  7305.     { 16157136, "AVT",      "F-810C"          ,0 },
    7306. 

  7306.     {  1409024, "Sony",     "XCD-SX910CR"     ,0 },
    7307. 

  7307.     {  2818048, "Sony",     "XCD-SX910CR"     ,0 },
    7308. 

  7308.     {  3884928, "Micron",   "2010"            ,0 },
    7309. 

  7309.     {  6624000, "Pixelink", "A782"            ,0 },
    7310. 

  7310.     { 13248000, "Pixelink", "A782"            ,0 },
    7311. 

  7311.     {  6291456, "RoverShot","3320AF"          ,0 },
    7312. 

  7312.     {  6553440, "Canon",    "PowerShot A460"  ,0 },
    7313. 

  7313.     {  6653280, "Canon",    "PowerShot A530"  ,0 },
    7314. 

  7314.     {  6573120, "Canon",    "PowerShot A610"  ,0 },
    7315. 

  7315.     {  9219600, "Canon",    "PowerShot A620"  ,0 },
    7316. 

  7316.     {  9243240, "Canon",    "PowerShot A470"  ,0 },
    7317. 

  7317.     { 10341600, "Canon",    "PowerShot A720 IS",0 },
    7318. 

  7318.     { 10383120, "Canon",    "PowerShot A630"  ,0 },
    7319. 

  7319.     { 12945240, "Canon",    "PowerShot A640"  ,0 },
    7320. 

  7320.     { 15636240, "Canon",    "PowerShot A650"  ,0 },
    7321. 

  7321.     {  5298000, "Canon",    "PowerShot SD300" ,0 },
    7322. 

  7322.     {  7710960, "Canon",    "PowerShot S3 IS" ,0 },
    7323. 

  7323.     { 15467760, "Canon",    "PowerShot SX110 IS",0 },
    7324. 

  7324.     { 15534576, "Canon",    "PowerShot SX120 IS",0 },
    7325. 

  7325.     { 18653760, "Canon",    "PowerShot SX20 IS",0 },
    7326. 

  7326.     { 21936096, "Canon",    "PowerShot SX30 IS",0 },
    7327. 

  7327.     {  5939200, "OLYMPUS",  "C770UZ"          ,0 },
    7328. 

  7328.     {  1581060, "NIKON",    "E900"            ,1 },  /* or E900s,E910 */
    7329. 

  7329.     {  2465792, "NIKON",    "E950"            ,1 },  /* or E800,E700 */
    7330. 

  7330.     {  2940928, "NIKON",    "E2100"           ,1 },  /* or E2500 */
    7331. 

  7331.     {  4771840, "NIKON",    "E990"            ,1 },  /* or E995, Oly C3030Z */
    7332. 

  7332.     {  4775936, "NIKON",    "E3700"           ,1 },  /* or Optio 33WR */
    7333. 

  7333.     {  5869568, "NIKON",    "E4300"           ,1 },  /* or DiMAGE Z2 */
    7334. 

  7334.     {  5865472, "NIKON",    "E4500"           ,1 },
    7335. 

  7335.     {  7438336, "NIKON",    "E5000"           ,1 },  /* or E5700 */
    7336. 

  7336.     {  8998912, "NIKON",    "COOLPIX S6"      ,1 },
    7337. 

  7337.     {  1976352, "CASIO",    "QV-2000UX"       ,1 },
    7338. 

  7338.     {  3217760, "CASIO",    "QV-3*00EX"       ,1 },
    7339. 

  7339.     {  6218368, "CASIO",    "QV-5700"         ,1 },
    7340. 

  7340.     {  6054400, "CASIO",    "QV-R41"          ,1 },
    7341. 

  7341.     {  7530816, "CASIO",    "QV-R51"          ,1 },
    7342. 

  7342.     {  7684000, "CASIO",    "QV-4000"         ,1 },
    7343. 

  7343.     {  2937856, "CASIO",    "EX-S20"          ,1 },
    7344. 

  7344.     {  4948608, "CASIO",    "EX-S100"         ,1 },
    7345. 

  7345.     {  7542528, "CASIO",    "EX-Z50"          ,1 },
    7346. 

  7346.     {  7753344, "CASIO",    "EX-Z55"          ,1 },
    7347. 

  7347.     {  7816704, "CASIO",    "EX-Z60"          ,1 },
    7348. 

  7348.     { 10843712, "CASIO",    "EX-Z75"          ,1 },
    7349. 

  7349.     { 10834368, "CASIO",    "EX-Z750"         ,1 },
    7350. 

  7350.     { 12310144, "CASIO",    "EX-Z850"         ,1 },
    7351. 

  7351.     { 15499264, "CASIO",    "EX-Z1050"        ,1 },
    7352. 

  7352.     {  7426656, "CASIO",    "EX-P505"         ,1 },
    7353. 

  7353.     {  9313536, "CASIO",    "EX-P600"         ,1 },
    7354. 

  7354.     { 10979200, "CASIO",    "EX-P700"         ,1 },
    7355. 

  7355.     {  3178560, "PENTAX",   "Optio S"         ,1 },
    7356. 

  7356.     {  4841984, "PENTAX",   "Optio S"         ,1 },
    7357. 

  7357.     {  6114240, "PENTAX",   "Optio S4"        ,1 },  /* or S4i, CASIO EX-Z4 */
    7358. 

  7358.     { 10702848, "PENTAX",   "Optio 750Z"      ,1 },
    7359. 

  7359.     { 15980544, "AGFAPHOTO","DC-833m"         ,1 },
    7360. 

  7360.     { 16098048, "SAMSUNG",  "S85"             ,1 },
    7361. 

  7361.     { 16215552, "SAMSUNG",  "S85"             ,1 },
    7362. 

  7362.     { 20487168, "SAMSUNG",  "WB550"           ,1 },
    7363. 

  7363.     { 24000000, "SAMSUNG",  "WB550"           ,1 },
    7364. 

  7364.     { 9994240, "ptGrey", "GRAS-50S5C" ,0 }, // KC: SUPPORT GRASSHOPPER
    7365. 

  7365.     { 10075968, "JaiPulnix","BB-500CL" ,0 }, // KC: SUPPORT BB-500CL
    7366. 

  7366.     { 10108896, "JaiPulnix","BB-500GE" ,0 }, // KC: SUPPORT BB-500GE
    7367. 

  7367.     { 10036800, "SVS", "SVS625CL" ,0 }, // KC: SUPPORT SVS625 cameralink
    7368. 

  7368.     { 12582980, "Sinar",    ""                ,0 },
    7369. 

  7369.     { 33292868, "Sinar",    ""                ,0 },
    7370. 

  7370.     { 44390468, "Sinar",    ""                ,0 } };
    7371. 

  7371.   static const char *corp[] =
    7372. 

  7372.     { "Canon", "NIKON", "EPSON", "KODAK", "Kodak", "OLYMPUS", "PENTAX",
    7373. 

  7373.       "MINOLTA", "Minolta", "Konica", "CASIO", "Sinar", "Phase One",
    7374. 

  7374.       "SAMSUNG", "Mamiya", "MOTOROLA" };
    7375. 

  7375. 

  7376. #ifdef LIBRAW_LIBRARY_BUILD
    7377. 

  7377.   RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY,0,2);
    7378. 

  7378. #endif
    7379. 

  7379. 

  7380.   tiff_flip = flip = filters = -1;	/* 0 is valid, so -1 is unknown */
    7381. 

  7381.   raw_height = raw_width = fuji_width = fuji_layout = cr2_slice[0] = 0;
    7382. 

  7382.   maximum = height = width = top_margin = left_margin = 0;
    7383. 

  7383.   cdesc[0] = desc[0] = artist[0] = make[0] = model[0] = model2[0] = 0;
    7384. 

  7384.   iso_speed = shutter = aperture = focal_len = unique_id = 0;
    7385. 

  7385.   tiff_nifds = 0;
    7386. 

  7386.   memset (tiff_ifd, 0, sizeof tiff_ifd);
    7387. 

  7387.   memset (gpsdata, 0, sizeof gpsdata);
    7388. 

  7388.   memset (cblack, 0, sizeof cblack);
    7389. 

  7389.   memset (white, 0, sizeof white);
    7390. 

  7390.   thumb_offset = thumb_length = thumb_width = thumb_height = 0;
    7391. 

  7391.   load_raw = thumb_load_raw = 0;
    7392. 

  7392.   write_thumb = &CLASS jpeg_thumb;
    7393. 

  7393.   data_offset = meta_length = tiff_bps = tiff_compress = 0;
    7394. 

  7394.   kodak_cbpp = zero_after_ff = dng_version = load_flags = 0;
    7395. 

  7395.   timestamp = shot_order = tiff_samples = black =  is_foveon = 0;
    7396. 

  7396.   mix_green = profile_length = data_error = zero_is_bad = 0;
    7397. 

  7397.   pixel_aspect = is_raw = raw_color = 1;
    7398. 

  7398.   tile_width = tile_length = INT_MAX;
    7399. 

  7399.   for (i=0; i < 4; i++) {
    7400. 

  7400.     cam_mul[i] = i == 1;
    7401. 

  7401.     pre_mul[i] = i < 3;
    7402. 

  7402.     FORC3 cmatrix[c][i] = 0;
    7403. 

  7403.     FORC3 rgb_cam[c][i] = c == i;
    7404. 

  7404.   }
    7405. 

  7405. #ifdef LIBRAW_LIBRARY_BUILD
    7406. 

  7406.   color_flags.cmatrix_state = LIBRAW_COLORSTATE_INIT;
    7407. 

  7407.   color_flags.rgb_cam_state = LIBRAW_COLORSTATE_INIT;
    7408. 

  7408.   color_flags.pre_mul_state = LIBRAW_COLORSTATE_INIT;
    7409. 

  7409.   color_flags.cam_mul_state = LIBRAW_COLORSTATE_INIT;
    7410. 

  7410. #endif
    7411. 

  7411.   colors = 3;
    7412. 

  7412.   for (i=0; i < 0x4000; i++) curve[i] = i;
    7413. 

  7413. #ifdef LIBRAW_LIBRARY_BUILD
    7414. 

  7414.   color_flags.curve_state = LIBRAW_COLORSTATE_INIT;
    7415. 

  7415. #endif
    7416. 

  7416. 

  7417.   order = get2();
    7418. 

  7418.   hlen = get4();
    7419. 

  7419.   fseek (ifp, 0, SEEK_SET);
    7420. 

  7420.   fread (head, 1, 32, ifp);
    7421. 

  7421.   fseek (ifp, 0, SEEK_END);
    7422. 

  7422.   flen = fsize = ftell(ifp);
    7423. 

  7423.   if ((cp = (char *) memmem (head, 32, (char*)"MMMM", 4)) ||
    7424. 

  7424.       (cp = (char *) memmem (head, 32, (char*)"IIII", 4))) {
    7425. 

  7425.     parse_phase_one (cp-head);
    7426. 

  7426.     if (cp-head && parse_tiff(0)) apply_tiff();
    7427. 

  7427.   } else if (order == 0x4949 || order == 0x4d4d) {
    7428. 

  7428.     if (!memcmp (head+6,"HEAPCCDR",8)) {
    7429. 

  7429.       data_offset = hlen;
    7430. 

  7430.       parse_ciff (hlen, flen - hlen);
    7431. 

  7431.     } else if (parse_tiff(0)) apply_tiff();
    7432. 

  7432.   } else if (!memcmp (head,"\xff\xd8\xff\xe1",4) &&
    7433. 

  7433. 	     !memcmp (head+6,"Exif",4)) {
    7434. 

  7434.     fseek (ifp, 4, SEEK_SET);
    7435. 

  7435.     data_offset = 4 + get2();
    7436. 

  7436.     fseek (ifp, data_offset, SEEK_SET);
    7437. 

  7437.     if (fgetc(ifp) != 0xff)
    7438. 

  7438.       parse_tiff(12);
    7439. 

  7439.     thumb_offset = 0;
    7440. 

  7440.   } else if (!memcmp (head+25,"ARECOYK",7)) {
    7441. 

  7441.     strcpy (make, "Contax");
    7442. 

  7442.     strcpy (model,"N Digital");
    7443. 

  7443.     fseek (ifp, 33, SEEK_SET);
    7444. 

  7444.     get_timestamp(1);
    7445. 

  7445.     fseek (ifp, 60, SEEK_SET);
    7446. 

  7446.     FORC4 cam_mul[c ^ (c >> 1)] = get4();
    7447. 

  7447. #ifdef LIBRAW_LIBRARY_BUILD
    7448. 

  7448.     color_flags.cam_mul_state = LIBRAW_COLORSTATE_LOADED;
    7449. 

  7449. #endif
    7450. 

  7450.   } else if (!strcmp (head, "PXN")) {
    7451. 

  7451.     strcpy (make, "Logitech");
    7452. 

  7452.     strcpy (model,"Fotoman Pixtura");
    7453. 

  7453.   } else if (!strcmp (head, "qktk")) {
    7454. 

  7454.     strcpy (make, "Apple");
    7455. 

  7455.     strcpy (model,"QuickTake 100");
    7456. 

  7456.     load_raw = &CLASS quicktake_100_load_raw;
    7457. 

  7457.   } else if (!strcmp (head, "qktn")) {
    7458. 

  7458.     strcpy (make, "Apple");
    7459. 

  7459.     strcpy (model,"QuickTake 150");
    7460. 

  7460.     load_raw = &CLASS kodak_radc_load_raw;
    7461. 

  7461.   } else if (!memcmp (head,"FUJIFILM",8)) {
    7462. 

  7462.     fseek (ifp, 84, SEEK_SET);
    7463. 

  7463.     thumb_offset = get4();
    7464. 

  7464.     thumb_length = get4();
    7465. 

  7465.     fseek (ifp, 92, SEEK_SET);
    7466. 

  7466.     parse_fuji (get4());
    7467. 

  7467.     if (thumb_offset > 120) {
    7468. 

  7468.       fseek (ifp, 120, SEEK_SET);
    7469. 

  7469.       is_raw += (i = get4()) && 1;
    7470. 

  7470.       if (is_raw == 2 && shot_select)
    7471. 

  7471. 	parse_fuji (i);
    7472. 

  7472.     }
    7473. 

  7473.     fseek (ifp, 100+28*(shot_select > 0), SEEK_SET);
    7474. 

  7474.     parse_tiff (data_offset = get4());
    7475. 

  7475.     parse_tiff (thumb_offset+12);
    7476. 

  7476.     apply_tiff();
    7477. 

  7477.   } else if (!memcmp (head,"RIFF",4)) {
    7478. 

  7478.     fseek (ifp, 0, SEEK_SET);
    7479. 

  7479.     parse_riff();
    7480. 

  7480.   } else if (!memcmp (head,"\0\001\0\001\0@",6)) {
    7481. 

  7481.     fseek (ifp, 6, SEEK_SET);
    7482. 

  7482.     fread (make, 1, 8, ifp);
    7483. 

  7483.     fread (model, 1, 8, ifp);
    7484. 

  7484.     fread (model2, 1, 16, ifp);
    7485. 

  7485.     data_offset = get2();
    7486. 

  7486.     get2();
    7487. 

  7487.     raw_width = get2();
    7488. 

  7488.     raw_height = get2();
    7489. 

  7489.     load_raw = &CLASS nokia_load_raw;
    7490. 

  7490.     filters = 0x61616161;
    7491. 

  7491.   } else if (!memcmp (head,"NOKIARAW",8)) {
    7492. 

  7492.     strcpy (make, "NOKIA");
    7493. 

  7493.     strcpy (model, "X2");
    7494. 

  7494.     order = 0x4949;
    7495. 

  7495.     fseek (ifp, 300, SEEK_SET);
    7496. 

  7496.     data_offset = get4();
    7497. 

  7497.     i = get4();
    7498. 

  7498.     width = get2();
    7499. 

  7499.     height = get2();
    7500. 

  7500.     data_offset += i - width * 5 / 4 * height;
    7501. 

  7501.     load_raw = &CLASS nokia_load_raw;
    7502. 

  7502.     filters = 0x61616161;
    7503. 

  7503.   } else if (!memcmp (head,"ARRI",4)) {
    7504. 

  7504.     order = 0x4949;
    7505. 

  7505.     fseek (ifp, 20, SEEK_SET);
    7506. 

  7506.     width = get4();
    7507. 

  7507.     height = get4();
    7508. 

  7508.     strcpy (make, "ARRI");
    7509. 

  7509.     fseek (ifp, 668, SEEK_SET);
    7510. 

  7510.     fread (model, 1, 64, ifp);
    7511. 

  7511.     data_offset = 4096;
    7512. 

  7512.     load_raw = &CLASS packed_load_raw;
    7513. 

  7513.     load_flags = 88;
    7514. 

  7514.     filters = 0x61616161;
    7515. 

  7515.   } else if (!memcmp (head+4,"RED1",4)) {
    7516. 

  7516.     strcpy (make, "RED");
    7517. 

  7517.     strcpy (model,"ONE");
    7518. 

  7518.     parse_redcine();
    7519. 

  7519.     load_raw = &CLASS redcine_load_raw;
    7520. 

  7520.     gamma_curve (1/2.4, 12.92, 1, 4095);
    7521. 

  7521.     filters = 0x49494949;
    7522. 

  7522.   } else if (!memcmp (head,"DSC-Image",9))
    7523. 

  7523.     parse_rollei();
    7524. 

  7524.   else if (!memcmp (head,"PWAD",4))
    7525. 

  7525.     parse_sinar_ia();
    7526. 

  7526.   else if (!memcmp (head,"\0MRM",4))
    7527. 

  7527.     parse_minolta(0);
    7528. 

  7528.   else if (!memcmp (head,"FOVb",4))
    7529. 

  7529.       {
    7530. 

  7530.           parse_foveon();
    7531. 

  7531.           if(!strcasecmp(make,"SIGMA") && !strncasecmp(model,"SIGMA DP",8))
    7532. 

  7532.               {
    7533. 

  7533.                   make[0] = model[0] = 0;
    7534. 

  7534.                   is_foveon = 0;
    7535. 

  7535.               }
    7536. 

  7536.       }
    7537. 

  7537.   else if (!memcmp (head,"CI",2))
    7538. 

  7538.     parse_cine();
    7539. 

  7539.   else
    7540. 

  7540.     for (zero_fsize=i=0; i < sizeof table / sizeof *table; i++)
    7541. 

  7541.       if (fsize == table[i].fsize) {
    7542. 

  7542. 	strcpy (make,  table[i].t_make );
    7543. 

  7543. 	strcpy (model, table[i].t_model);
    7544. 

  7544. 	if (table[i].withjpeg)
    7545. 

  7545. 	  parse_external_jpeg();
    7546. 

  7546.       }
    7547. 

  7547.   if (zero_fsize) fsize = 0;
    7548. 

  7548.   if (make[0] == 0) parse_smal (0, flen);
    7549. 

  7549.   if (make[0] == 0) parse_jpeg (is_raw = 0);
    7550. 

  7550. 

  7551.   for (i=0; i < sizeof corp / sizeof *corp; i++)
    7552. 

  7552.     if (strstr (make, corp[i]))		/* Simplify company names */
    7553. 

  7553. 	strcpy (make, corp[i]);
    7554. 

  7554.   if (!strncmp (make,"KODAK",5) &&
    7555. 

  7555. 	((cp = strstr(model," DIGITAL CAMERA")) ||
    7556. 

  7556. 	 (cp = strstr(model," Digital Camera")) ||
    7557. 

  7557. 	 (cp = strstr(model,"FILE VERSION"))))
    7558. 

  7558.      *cp = 0;
    7559. 

  7559.   cp = make + strlen(make);		/* Remove trailing spaces */
    7560. 

  7560.   while (*--cp == ' ') *cp = 0;
    7561. 

  7561.   cp = model + strlen(model);
    7562. 

  7562.   while (*--cp == ' ') *cp = 0;
    7563. 

  7563.   i = strlen(make);			/* Remove make from model */
    7564. 

  7564.   if (!strncasecmp (model, make, i) && model[i++] == ' ')
    7565. 

  7565.     memmove (model, model+i, 64-i);
    7566. 

  7566.   if (!strncmp (model,"Digital Camera ",15))
    7567. 

  7567.     strcpy (model, model+15);
    7568. 

  7568.   desc[511] = artist[63] = make[63] = model[63] = model2[63] = 0;
    7569. 

  7569.   if (!is_raw) goto notraw;
    7570. 

  7570. 

  7571.   if (!height) height = raw_height;
    7572. 

  7572.   if (!width)  width  = raw_width;
    7573. 

  7573.   if (fuji_width) {
    7574. 

  7574.     fuji_width = (raw_width+1)/2;
    7575. 

  7575.     width = height + fuji_width;
    7576. 

  7576.     height = width - 1;
    7577. 

  7577.     pixel_aspect = 1;
    7578. 

  7578.   }
    7579. 

  7579.   if (height == 2624 && width == 3936)	/* Pentax K10D and Samsung GX10 */
    7580. 

  7580.     { height  = 2616;   width  = 3896; }
    7581. 

  7581.   if (height == 3136 && width == 4864)  /* Pentax K20D and Samsung GX20 */
    7582. 

  7582.     { height  = 3124;   width  = 4688; filters = 0x16161616; }
    7583. 

  7583.   if (width == 4352 && (!strcmp(model,"K-r") || !strcmp(model,"K-x")))
    7584. 

  7584.     {			width  = 4309; filters = 0x16161616; }
    7585. 

  7585.   if (width >= 4960 && !strcmp(model,"K-5"))
    7586. 

  7586.     { left_margin = 10; width  = 4950; filters = 0x16161616; }
    7587. 

  7587.   if (width == 4736 && !strcmp(model,"K-7"))
    7588. 

  7588.     { height  = 3122;   width  = 4684; filters = 0x16161616; top_margin = 2; }
    7589. 

  7589.   if (width == 7424 && !strcmp(model,"645D"))
    7590. 

  7590.     { height  = 5502;   width  = 7328; filters = 0x61616161; top_margin = 29;
    7591. 

  7591.       left_margin = 48; }
    7592. 

  7592.   if (height == 3014 && width == 4096)	/* Ricoh GX200 */
    7593. 

  7593. 			width  = 4014;
    7594. 

  7594.   if (dng_version) {
    7595. 

  7595.     if (filters == UINT_MAX) filters = 0;
    7596. 

  7596.     if (filters) is_raw = tiff_samples;
    7597. 

  7597.     else	 colors = tiff_samples;
    7598. 

  7598.     if (tiff_compress == 1)
    7599. 

  7599.       load_raw = &CLASS adobe_dng_load_raw_nc;
    7600. 

  7600.     if (tiff_compress == 7)
    7601. 

  7601.       load_raw = &CLASS adobe_dng_load_raw_lj;
    7602. 

  7602.     goto dng_skip;
    7603. 

  7603.   }
    7604. 

  7604.   if ((is_canon = !strcmp(make,"Canon")))
    7605. 

  7605.     load_raw = memcmp (head+6,"HEAPCCDR",8) ?
    7606. 

  7606. 	&CLASS lossless_jpeg_load_raw : &CLASS canon_compressed_load_raw;
    7607. 

  7607.   if (!strcmp(make,"NIKON")) {
    7608. 

  7608.     if (!load_raw)
    7609. 

  7609.       load_raw = &CLASS packed_load_raw;
    7610. 

  7610.     if (model[0] == 'E')
    7611. 

  7611.       load_flags |= !data_offset << 2 | 2;
    7612. 

  7612.   }
    7613. 

  7613.   if (!strcmp(make,"CASIO")) {
    7614. 

  7614.     load_raw = &CLASS packed_load_raw;
    7615. 

  7615.     maximum = 0xf7f;
    7616. 

  7616.   }
    7617. 

  7617. 

  7618. /* Set parameters based on camera name (for non-DNG files). */
    7619. 

  7619.  if (is_foveon) {
    7620. 

  7620.     if (height*2 < width) pixel_aspect = 0.5;
    7621. 

  7621.     if (height   > width) pixel_aspect = 2;
    7622. 

  7622.     filters = 0;
    7623. 

  7623.     load_raw = &CLASS foveon_load_raw;
    7624. 

  7624.     simple_coeff(0);
    7625. 

  7625.   } else if (is_canon && tiff_bps == 15) {
    7626. 

  7626.     switch (width) {
    7627. 

  7627.       case 3344: width -= 66;
    7628. 

  7628.       case 3872: width -= 6;
    7629. 

  7629.     }
    7630. 

  7630.     filters = 0;
    7631. 

  7631.     load_raw = &CLASS canon_sraw_load_raw;
    7632. 

  7632.   } else if (!strcmp(model,"PowerShot 600")) {
    7633. 

  7633.     height = 613;
    7634. 

  7634.     width  = 854;
    7635. 

  7635.     raw_width = 896;
    7636. 

  7636.     pixel_aspect = 607/628.0;
    7637. 

  7637.     colors = 4;
    7638. 

  7638.     filters = 0xe1e4e1e4;
    7639. 

  7639.     load_raw = &CLASS canon_600_load_raw;
    7640. 

  7640.   } else if (!strcmp(model,"PowerShot A5") ||
    7641. 

  7641. 	     !strcmp(model,"PowerShot A5 Zoom")) {
    7642. 

  7642.     height = 773;
    7643. 

  7643.     width  = 960;
    7644. 

  7644.     raw_width = 992;
    7645. 

  7645.     pixel_aspect = 256/235.0;
    7646. 

  7646.     colors = 4;
    7647. 

  7647.     filters = 0x1e4e1e4e;
    7648. 

  7648.     goto canon_a5;
    7649. 

  7649.   } else if (!strcmp(model,"PowerShot A50")) {
    7650. 

  7650.     height =  968;
    7651. 

  7651.     width  = 1290;
    7652. 

  7652.     raw_width = 1320;
    7653. 

  7653.     colors = 4;
    7654. 

  7654.     filters = 0x1b4e4b1e;
    7655. 

  7655.     goto canon_a5;
    7656. 

  7656.   } else if (!strcmp(model,"PowerShot Pro70")) {
    7657. 

  7657.     height = 1024;
    7658. 

  7658.     width  = 1552;
    7659. 

  7659.     colors = 4;
    7660. 

  7660.     filters = 0x1e4b4e1b;
    7661. 

  7661.     goto canon_a5;
    7662. 

  7662.   } else if (!strcmp(model,"PowerShot SD300")) {
    7663. 

  7663.     height = 1752;
    7664. 

  7664.     width  = 2344;
    7665. 

  7665.     raw_height = 1766;
    7666. 

  7666.     raw_width  = 2400;
    7667. 

  7667.     top_margin  = 12;
    7668. 

  7668.     left_margin = 12;
    7669. 

  7669.     goto canon_a5;
    7670. 

  7670.   } else if (!strcmp(model,"PowerShot A460")) {
    7671. 

  7671.     height = 1960;
    7672. 

  7672.     width  = 2616;
    7673. 

  7673.     raw_height = 1968;
    7674. 

  7674.     raw_width  = 2664;
    7675. 

  7675.     top_margin  = 4;
    7676. 

  7676.     left_margin = 4;
    7677. 

  7677.     goto canon_a5;
    7678. 

  7678.   } else if (!strcmp(model,"PowerShot A530")) {
    7679. 

  7679.     height = 1984;
    7680. 

  7680.     width  = 2620;
    7681. 

  7681.     raw_height = 1992;
    7682. 

  7682.     raw_width  = 2672;
    7683. 

  7683.     top_margin  = 6;
    7684. 

  7684.     left_margin = 10;
    7685. 

  7685.     goto canon_a5;
    7686. 

  7686.   } else if (!strcmp(model,"PowerShot A610")) {
    7687. 

  7687.     if (canon_s2is()) strcpy (model+10, "S2 IS");
    7688. 

  7688.     height = 1960;
    7689. 

  7689.     width  = 2616;
    7690. 

  7690.     raw_height = 1968;
    7691. 

  7691.     raw_width  = 2672;
    7692. 

  7692.     top_margin  = 8;
    7693. 

  7693.     left_margin = 12;
    7694. 

  7694.     goto canon_a5;
    7695. 

  7695.   } else if (!strcmp(model,"PowerShot A620")) {
    7696. 

  7696.     height = 2328;
    7697. 

  7697.     width  = 3112;
    7698. 

  7698.     raw_height = 2340;
    7699. 

  7699.     raw_width  = 3152;
    7700. 

  7700.     top_margin  = 12;
    7701. 

  7701.     left_margin = 36;
    7702. 

  7702.     goto canon_a5;
    7703. 

  7703.   } else if (!strcmp(model,"PowerShot A470")) {
    7704. 

  7704.     height = 2328;
    7705. 

  7705.     width  = 3096;
    7706. 

  7706.     raw_height = 2346;
    7707. 

  7707.     raw_width  = 3152;
    7708. 

  7708.     top_margin  = 6;
    7709. 

  7709.     left_margin = 12;
    7710. 

  7710.     goto canon_a5;
    7711. 

  7711.   } else if (!strcmp(model,"PowerShot A720 IS")) {
    7712. 

  7712.     height = 2472;
    7713. 

  7713.     width  = 3298;
    7714. 

  7714.     raw_height = 2480;
    7715. 

  7715.     raw_width  = 3336;
    7716. 

  7716.     top_margin  = 5;
    7717. 

  7717.     left_margin = 6;
    7718. 

  7718.     goto canon_a5;
    7719. 

  7719.   } else if (!strcmp(model,"PowerShot A630")) {
    7720. 

  7720.     height = 2472;
    7721. 

  7721.     width  = 3288;
    7722. 

  7722.     raw_height = 2484;
    7723. 

  7723.     raw_width  = 3344;
    7724. 

  7724.     top_margin  = 6;
    7725. 

  7725.     left_margin = 12;
    7726. 

  7726.     goto canon_a5;
    7727. 

  7727.   } else if (!strcmp(model,"PowerShot A640")) {
    7728. 

  7728.     height = 2760;
    7729. 

  7729.     width  = 3672;
    7730. 

  7730.     raw_height = 2772;
    7731. 

  7731.     raw_width  = 3736;
    7732. 

  7732.     top_margin  = 6;
    7733. 

  7733.     left_margin = 12;
    7734. 

  7734.     goto canon_a5;
    7735. 

  7735.   } else if (!strcmp(model,"PowerShot A650")) {
    7736. 

  7736.     height = 3024;
    7737. 

  7737.     width  = 4032;
    7738. 

  7738.     raw_height = 3048;
    7739. 

  7739.     raw_width  = 4104;
    7740. 

  7740.     top_margin  = 12;
    7741. 

  7741.     left_margin = 48;
    7742. 

  7742.     goto canon_a5;
    7743. 

  7743.   } else if (!strcmp(model,"PowerShot S3 IS")) {
    7744. 

  7744.     height = 2128;
    7745. 

  7745.     width  = 2840;
    7746. 

  7746.     raw_height = 2136;
    7747. 

  7747.     raw_width  = 2888;
    7748. 

  7748.     top_margin  = 8;
    7749. 

  7749.     left_margin = 44;
    7750. 

  7750. canon_a5:
    7751. 

  7751.     tiff_bps = 10;
    7752. 

  7752.     load_raw = &CLASS packed_load_raw;
    7753. 

  7753.     load_flags = 40;
    7754. 

  7754.     if (raw_width > 1600) zero_is_bad = 1;
    7755. 

  7755.   } else if (!strcmp(model,"PowerShot SX110 IS")) {
    7756. 

  7756.     height = 2760;
    7757. 

  7757.     width  = 3684;
    7758. 

  7758.     raw_height = 2772;
    7759. 

  7759.     raw_width  = 3720;
    7760. 

  7760.     top_margin  = 12;
    7761. 

  7761.     left_margin = 6;
    7762. 

  7762.     load_raw = &CLASS packed_load_raw;
    7763. 

  7763.     load_flags = 40;
    7764. 

  7764.     zero_is_bad = 1;
    7765. 

  7765.   } else if (!strcmp(model,"PowerShot SX120 IS")) {
    7766. 

  7766.     height = 2742;
    7767. 

  7767.     width  = 3664;
    7768. 

  7768.     raw_height = 2778;
    7769. 

  7769.     raw_width  = 3728;
    7770. 

  7770.     top_margin  = 18;
    7771. 

  7771.     left_margin = 16;
    7772. 

  7772.     filters = 0x49494949;
    7773. 

  7773.     load_raw = &CLASS packed_load_raw;
    7774. 

  7774.     load_flags = 40;
    7775. 

  7775.     zero_is_bad = 1;
    7776. 

  7776.   } else if (!strcmp(model,"PowerShot SX20 IS")) {
    7777. 

  7777.     height = 3024;
    7778. 

  7778.     width  = 4032;
    7779. 

  7779.     raw_height = 3048;
    7780. 

  7780.     raw_width  = 4080;
    7781. 

  7781.     top_margin  = 12;
    7782. 

  7782.     left_margin = 24;
    7783. 

  7783.     load_raw = &CLASS packed_load_raw;
    7784. 

  7784.     load_flags = 40;
    7785. 

  7785.     zero_is_bad = 1;
    7786. 

  7786.   } else if (!strcmp(model,"PowerShot SX30 IS")) {
    7787. 

  7787.     height = 3254;
    7788. 

  7788.     width  = 4366;
    7789. 

  7789.     raw_height = 3276;
    7790. 

  7790.     raw_width  = 4464;
    7791. 

  7791.     top_margin  = 10;
    7792. 

  7792.     left_margin = 25;
    7793. 

  7793.     filters = 0x16161616;
    7794. 

  7794.     load_raw = &CLASS packed_load_raw;
    7795. 

  7795.     load_flags = 40;
    7796. 

  7796.     zero_is_bad = 1;
    7797. 

  7797.   } else if (!strcmp(model,"PowerShot Pro90 IS")) {
    7798. 

  7798.     width  = 1896;
    7799. 

  7799.     colors = 4;
    7800. 

  7800.     filters = 0xb4b4b4b4;
    7801. 

  7801.   } else if (is_canon && raw_width == 2144) {
    7802. 

  7802.     height = 1550;
    7803. 

  7803.     width  = 2088;
    7804. 

  7804.     top_margin  = 8;
    7805. 

  7805.     left_margin = 4;
    7806. 

  7806.     if (!strcmp(model,"PowerShot G1")) {
    7807. 

  7807.       colors = 4;
    7808. 

  7808.       filters = 0xb4b4b4b4;
    7809. 

  7809.     }
    7810. 

  7810.   } else if (is_canon && raw_width == 2224) {
    7811. 

  7811.     height = 1448;
    7812. 

  7812.     width  = 2176;
    7813. 

  7813.     top_margin  = 6;
    7814. 

  7814.     left_margin = 48;
    7815. 

  7815.   } else if (is_canon && raw_width == 2376) {
    7816. 

  7816.     height = 1720;
    7817. 

  7817.     width  = 2312;
    7818. 

  7818.     top_margin  = 6;
    7819. 

  7819.     left_margin = 12;
    7820. 

  7820.   } else if (is_canon && raw_width == 2672) {
    7821. 

  7821.     height = 1960;
    7822. 

  7822.     width  = 2616;
    7823. 

  7823.     top_margin  = 6;
    7824. 

  7824.     left_margin = 12;
    7825. 

  7825.   } else if (is_canon && raw_width == 3152) {
    7826. 

  7826.     height = 2056;
    7827. 

  7827.     width  = 3088;
    7828. 

  7828.     top_margin  = 12;
    7829. 

  7829.     left_margin = 64;
    7830. 

  7830.     if (unique_id == 0x80000170)
    7831. 

  7831.       adobe_coeff ("Canon","EOS 300D");
    7832. 

  7832.   } else if (is_canon && raw_width == 3160) {
    7833. 

  7833.     height = 2328;
    7834. 

  7834.     width  = 3112;
    7835. 

  7835.     top_margin  = 12;
    7836. 

  7836.     left_margin = 44;
    7837. 

  7837.   } else if (is_canon && raw_width == 3344) {
    7838. 

  7838.     height = 2472;
    7839. 

  7839.     width  = 3288;
    7840. 

  7840.     top_margin  = 6;
    7841. 

  7841.     left_margin = 4;
    7842. 

  7842.   } else if (!strcmp(model,"EOS D2000C")) {
    7843. 

  7843.     filters = 0x61616161;
    7844. 

  7844.     black = curve[200];
    7845. 

  7845.   } else if (is_canon && raw_width == 3516) {
    7846. 

  7846.     top_margin  = 14;
    7847. 

  7847.     left_margin = 42;
    7848. 

  7848.     if (unique_id == 0x80000189)
    7849. 

  7849.       adobe_coeff ("Canon","EOS 350D");
    7850. 

  7850.     goto canon_cr2;
    7851. 

  7851.   } else if (is_canon && raw_width == 3596) {
    7852. 

  7852.     top_margin  = 12;
    7853. 

  7853.     left_margin = 74;
    7854. 

  7854.     goto canon_cr2;
    7855. 

  7855.   } else if (is_canon && raw_width == 3744) {
    7856. 

  7856.     height = 2760;
    7857. 

  7857.     width  = 3684;
    7858. 

  7858.     top_margin  = 16;
    7859. 

  7859.     left_margin = 8;
    7860. 

  7860.     if (unique_id > 0x2720000) {
    7861. 

  7861.       top_margin  = 12;
    7862. 

  7862.       left_margin = 52;
    7863. 

  7863.     }
    7864. 

  7864.   } else if (is_canon && raw_width == 3944) {
    7865. 

  7865.     height = 2602;
    7866. 

  7866.     width  = 3908;
    7867. 

  7867.     top_margin  = 18;
    7868. 

  7868.     left_margin = 30;
    7869. 

  7869.   } else if (is_canon && raw_width == 3948) {
    7870. 

  7870.     top_margin  = 18;
    7871. 

  7871.     left_margin = 42;
    7872. 

  7872.     height -= 2;
    7873. 

  7873.     if (unique_id == 0x80000236)
    7874. 

  7874.       adobe_coeff ("Canon","EOS 400D");
    7875. 

  7875.     if (unique_id == 0x80000254)
    7876. 

  7876.       adobe_coeff ("Canon","EOS 1000D");
    7877. 

  7877.     goto canon_cr2;
    7878. 

  7878.   } else if (is_canon && raw_width == 3984) {
    7879. 

  7879.     top_margin  = 20;
    7880. 

  7880.     left_margin = 76;
    7881. 

  7881.     height -= 2;
    7882. 

  7882.     goto canon_cr2;
    7883. 

  7883.   } else if (is_canon && raw_width == 4104) {
    7884. 

  7884.     height = 3024;
    7885. 

  7885.     width  = 4032;
    7886. 

  7886.     top_margin  = 12;
    7887. 

  7887.     left_margin = 48;
    7888. 

  7888.   } else if (is_canon && raw_width == 4152) {
    7889. 

  7889.     top_margin  = 12;
    7890. 

  7890.     left_margin = 192;
    7891. 

  7891.     goto canon_cr2;
    7892. 

  7892.   } else if (is_canon && raw_width == 4160) {
    7893. 

  7893.     height = 3048;
    7894. 

  7894.     width  = 4048;
    7895. 

  7895.     top_margin  = 11;
    7896. 

  7896.     left_margin = 104;
    7897. 

  7897.   } else if (is_canon && raw_width == 4312) {
    7898. 

  7898.     top_margin  = 18;
    7899. 

  7899.     left_margin = 22;
    7900. 

  7900.     height -= 2;
    7901. 

  7901.     if (unique_id == 0x80000176)
    7902. 

  7902.       adobe_coeff ("Canon","EOS 450D");
    7903. 

  7903.     goto canon_cr2;
    7904. 

  7904.   } else if (is_canon && raw_width == 4352) {
    7905. 

  7905.     top_margin  = 18;
    7906. 

  7906.     left_margin = 62;
    7907. 

  7907.     if (unique_id == 0x80000288)
    7908. 

  7908.       adobe_coeff ("Canon","EOS 1100D");
    7909. 

  7909.     goto canon_cr2;
    7910. 

  7910.   } else if (is_canon && raw_width == 4476) {
    7911. 

  7911.     top_margin  = 34;
    7912. 

  7912.     left_margin = 90;
    7913. 

  7913.     goto canon_cr2;
    7914. 

  7914.   } else if (is_canon && raw_width == 4480) {
    7915. 

  7915.     height = 3326;
    7916. 

  7916.     width  = 4432;
    7917. 

  7917.     top_margin  = 10;
    7918. 

  7918.     left_margin = 12;
    7919. 

  7919.     filters = 0x49494949;
    7920. 

  7920.   } else if (is_canon && raw_width == 4832) {
    7921. 

  7921.     top_margin = unique_id == 0x80000261 ? 51:26;
    7922. 

  7922.     left_margin = 62;
    7923. 

  7923.     if (unique_id == 0x80000252)
    7924. 

  7924.       adobe_coeff ("Canon","EOS 500D");
    7925. 

  7925.     goto canon_cr2;
    7926. 

  7926.   } else if (is_canon && raw_width == 5120) {
    7927. 

  7927.     height -= top_margin = 45;
    7928. 

  7928.     left_margin = 142;
    7929. 

  7929.     width = 4916;
    7930. 

  7930.   } else if (is_canon && raw_width == 5344) {
    7931. 

  7931.     top_margin = 51;
    7932. 

  7932.     left_margin = 142;
    7933. 

  7933.     if (unique_id == 0x80000270)
    7934. 

  7934.       adobe_coeff ("Canon","EOS 550D");
    7935. 

  7935.     if (unique_id == 0x80000286)
    7936. 

  7936.       adobe_coeff ("Canon","EOS 600D");
    7937. 

  7937.     goto canon_cr2;
    7938. 

  7938.   } else if (is_canon && raw_width == 5360) {
    7939. 

  7939.     top_margin = 51;
    7940. 

  7940.     left_margin = 158;
    7941. 

  7941.     goto canon_cr2;
    7942. 

  7942.   } else if (is_canon && raw_width == 5792) {
    7943. 

  7943.     top_margin  = 51;
    7944. 

  7944.     left_margin = 158;
    7945. 

  7945.     goto canon_cr2;
    7946. 

  7946.   } else if (is_canon && raw_width == 5108) {
    7947. 

  7947.     top_margin  = 13;
    7948. 

  7948.     left_margin = 98;
    7949. 

  7949. canon_cr2:
    7950. 

  7950.     height -= top_margin;
    7951. 

  7951.     width  -= left_margin;
    7952. 

  7952.   } else if (is_canon && raw_width == 5712) {
    7953. 

  7953.     height = 3752;
    7954. 

  7954.     width  = 5640;
    7955. 

  7955.     top_margin  = 20;
    7956. 

  7956.     left_margin = 62;
    7957. 

  7957.   } else if (!strcmp(model,"D1")) {
    7958. 

  7958.     cam_mul[0] *= 256/527.0;
    7959. 

  7959.     cam_mul[2] *= 256/317.0;
    7960. 

  7960.   } else if (!strcmp(model,"D1X")) {
    7961. 

  7961.     width -= 4;
    7962. 

  7962.     pixel_aspect = 0.5;
    7963. 

  7963.   } else if (!strcmp(model,"D40X") ||
    7964. 

  7964. 	     !strcmp(model,"D60")  ||
    7965. 

  7965. 	     !strcmp(model,"D80")  ||
    7966. 

  7966. 	     !strcmp(model,"D3000")) {
    7967. 

  7967.     height -= 3;
    7968. 

  7968.     width  -= 4;
    7969. 

  7969.   } else if (!strcmp(model,"D3")   ||
    7970. 

  7970. 	     !strcmp(model,"D3S")  ||
    7971. 

  7971. 	     !strcmp(model,"D700")) {
    7972. 

  7972.     width -= 4;
    7973. 

  7973.     left_margin = 2;
    7974. 

  7974.   } else if (!strcmp(model,"D5000")) {
    7975. 

  7975.     width -= 42;
    7976. 

  7976.   } else if (!strcmp(model,"D5100") ||
    7977. 

  7977. 	     !strcmp(model,"D7000")) {
    7978. 

  7978.     width -= 44;
    7979. 

  7979.   } else if (!strcmp(model,"D3100")) {
    7980. 

  7980.     width -= 28;
    7981. 

  7981.     left_margin = 6;
    7982. 

  7982.   } else if (!strncmp(model,"D40",3) ||
    7983. 

  7983. 	     !strncmp(model,"D50",3) ||
    7984. 

  7984. 	     !strncmp(model,"D70",3)) {
    7985. 

  7985.     width--;
    7986. 

  7986.   } else if (!strcmp(model,"D90")) {
    7987. 

  7987.     width -= 42;
    7988. 

  7988.   } else if (!strcmp(model,"D100")) {
    7989. 

  7989.     if (tiff_compress == 34713 && !nikon_is_compressed()) {
    7990. 

  7990.       load_raw = &CLASS packed_load_raw;
    7991. 

  7991.       load_flags |= 1;
    7992. 

  7992.       raw_width = (width += 3) + 3;
    7993. 

  7993.     }
    7994. 

  7994.   } else if (!strcmp(model,"D200")) {
    7995. 

  7995.     left_margin = 1;
    7996. 

  7996.     width -= 4;
    7997. 

  7997.     filters = 0x94949494;
    7998. 

  7998.   } else if (!strncmp(model,"D2H",3)) {
    7999. 

  7999.     left_margin = 6;
    8000. 

  8000.     width -= 14;
    8001. 

  8001.   } else if (!strncmp(model,"D2X",3)) {
    8002. 

  8002.     if (width == 3264) width -= 32;
    8003. 

  8003.     else width -= 8;
    8004. 

  8004.   } else if (!strncmp(model,"D300",4)) {
    8005. 

  8005.     width -= 32;
    8006. 

  8006.   } else if (!strncmp(model,"COOLPIX P",9)) {
    8007. 

  8007.     load_flags = 24;
    8008. 

  8008.     filters = 0x94949494;
    8009. 

  8009.     if (model[9] == '7' && iso_speed >= 400)
    8010. 

  8010.       black = 255;
    8011. 

  8011.   } else if (!strncmp(model,"1 ",2)) {
    8012. 

  8012.     height -= 2;
    8013. 

  8013.   } else if (fsize == 1581060) {
    8014. 

  8014.     height = 963;
    8015. 

  8015.     width = 1287;
    8016. 

  8016.     raw_width = 1632;
    8017. 

  8017.     maximum = 0x3f4;
    8018. 

  8018.     colors = 4;
    8019. 

  8019.     filters = 0x1e1e1e1e;
    8020. 

  8020.     simple_coeff(3);
    8021. 

  8021.     pre_mul[0] = 1.2085;
    8022. 

  8022.     pre_mul[1] = 1.0943;
    8023. 

  8023.     pre_mul[3] = 1.1103;
    8024. 

  8024. #ifdef LIBRAW_LIBRARY_BUILD
    8025. 

  8025.     color_flags.pre_mul_state = LIBRAW_COLORSTATE_CONST;
    8026. 

  8026. #endif
    8027. 

  8027.     goto e900;
    8028. 

  8028.   } else if (fsize == 2465792) {
    8029. 

  8029.     height = 1203;
    8030. 

  8030.     width  = 1616;
    8031. 

  8031.     raw_width = 2048;
    8032. 

  8032.     colors = 4;
    8033. 

  8033.     filters = 0x4b4b4b4b;
    8034. 

  8034.     adobe_coeff ("NIKON","E950");
    8035. 

  8035. e900:
    8036. 

  8036.     tiff_bps = 10;
    8037. 

  8037.     load_raw = &CLASS packed_load_raw;
    8038. 

  8038.     load_flags = 6;
    8039. 

  8039.   } else if (fsize == 4771840) {
    8040. 

  8040.     height = 1540;
    8041. 

  8041.     width  = 2064;
    8042. 

  8042.     colors = 4;
    8043. 

  8043.     filters = 0xe1e1e1e1;
    8044. 

  8044.     load_raw = &CLASS packed_load_raw;
    8045. 

  8045.     load_flags = 6;
    8046. 

  8046.     if (!timestamp && nikon_e995())
    8047. 

  8047.       strcpy (model, "E995");
    8048. 

  8048.     if (strcmp(model,"E995")) {
    8049. 

  8049.       filters = 0xb4b4b4b4;
    8050. 

  8050.       simple_coeff(3);
    8051. 

  8051.       pre_mul[0] = 1.196;
    8052. 

  8052.       pre_mul[1] = 1.246;
    8053. 

  8053.       pre_mul[2] = 1.018;
    8054. 

  8054. #ifdef LIBRAW_LIBRARY_BUILD
    8055. 

  8055.       color_flags.pre_mul_state = LIBRAW_COLORSTATE_CONST;
    8056. 

  8056. #endif
    8057. 

  8057.     }
    8058. 

  8058.   } else if (!strcmp(model,"E2100")) {
    8059. 

  8059.     if (!timestamp && !nikon_e2100()) goto cp_e2500;
    8060. 

  8060.     height = 1206;
    8061. 

  8061.     width  = 1616;
    8062. 

  8062.     load_flags = 30;
    8063. 

  8063.   } else if (!strcmp(model,"E2500")) {
    8064. 

  8064. cp_e2500:
    8065. 

  8065.     strcpy (model, "E2500");
    8066. 

  8066.     height = 1204;
    8067. 

  8067.     width  = 1616;
    8068. 

  8068.     colors = 4;
    8069. 

  8069.     filters = 0x4b4b4b4b;
    8070. 

  8070.   } else if (fsize == 4775936) {
    8071. 

  8071.     height = 1542;
    8072. 

  8072.     width  = 2064;
    8073. 

  8073.     load_raw = &CLASS packed_load_raw;
    8074. 

  8074.     load_flags = 30;
    8075. 

  8075.     if (!timestamp) nikon_3700();
    8076. 

  8076.     if (model[0] == 'E' && atoi(model+1) < 3700)
    8077. 

  8077.       filters = 0x49494949;
    8078. 

  8078.     if (!strcmp(model,"Optio 33WR")) {
    8079. 

  8079.       flip = 1;
    8080. 

  8080.       filters = 0x16161616;
    8081. 

  8081.     }
    8082. 

  8082.     if (make[0] == 'O') {
    8083. 

  8083.       i = find_green (12, 32, 1188864, 3576832);
    8084. 

  8084.       c = find_green (12, 32, 2383920, 2387016);
    8085. 

  8085.       if (abs(i) < abs(c)) {
    8086. 

  8086. 	SWAP(i,c);
    8087. 

  8087. 	load_flags = 24;
    8088. 

  8088.       }
    8089. 

  8089.       if (i < 0) filters = 0x61616161;
    8090. 

  8090.     }
    8091. 

  8091.   } else if (fsize == 5869568) {
    8092. 

  8092.     height = 1710;
    8093. 

  8093.     width  = 2288;
    8094. 

  8094.     filters = 0x16161616;
    8095. 

  8095.     if (!timestamp && minolta_z2()) {
    8096. 

  8096.       strcpy (make, "Minolta");
    8097. 

  8097.       strcpy (model,"DiMAGE Z2");
    8098. 

  8098.     }
    8099. 

  8099.     load_raw = &CLASS packed_load_raw;
    8100. 

  8100.     load_flags = 6 + 24*(make[0] == 'M');
    8101. 

  8101.   } else if (!strcmp(model,"E4500")) {
    8102. 

  8102.     height = 1708;
    8103. 

  8103.     width  = 2288;
    8104. 

  8104.     colors = 4;
    8105. 

  8105.     filters = 0xb4b4b4b4;
    8106. 

  8106.   } else if (fsize == 7438336) {
    8107. 

  8107.     height = 1924;
    8108. 

  8108.     width  = 2576;
    8109. 

  8109.     colors = 4;
    8110. 

  8110.     filters = 0xb4b4b4b4;
    8111. 

  8111.   } else if (fsize == 8998912) {
    8112. 

  8112.     height = 2118;
    8113. 

  8113.     width  = 2832;
    8114. 

  8114.     maximum = 0xf83;
    8115. 

  8115.     load_raw = &CLASS packed_load_raw;
    8116. 

  8116.     load_flags = 30;
    8117. 

  8117.   } else if (!strcmp(make,"FUJIFILM")) {
    8118. 

  8118.     if (!strcmp(model+7,"S2Pro")) {
    8119. 

  8119.       strcpy (model+7," S2Pro");
    8120. 

  8120.       height = 2144;
    8121. 

  8121.       width  = 2880;
    8122. 

  8122.       flip = 6;
    8123. 

  8123.     } else if (load_raw != &CLASS packed_load_raw)
    8124. 

  8124.       maximum = (is_raw == 2 && shot_select) ? 0x2f00 : 0x3e00;
    8125. 

  8125.     top_margin = (raw_height - height) >> 2 << 1;
    8126. 

  8126.     left_margin = (raw_width - width ) >> 2 << 1;
    8127. 

  8127.     if (width == 3328) {
    8128. 

  8128.       width = 3262;
    8129. 

  8129.       left_margin = 34;
    8130. 

  8130.     }
    8131. 

  8131.     if (!strcmp(model,"X10"))
    8132. 

  8132.       filters = 0x16161616;
    8133. 

  8133.     if (fuji_layout) raw_width *= is_raw;
    8134. 

  8134.     if (load_raw == &CLASS fuji_load_raw) {
    8135. 

  8135.       fuji_width = width >> !fuji_layout;
    8136. 

  8136.       width = (height >> fuji_layout) + fuji_width;
    8137. 

  8137.       raw_height = height;
    8138. 

  8138.       height = width - 1;
    8139. 

  8139.       if (~fuji_width & 1) filters = 0x49494949;
    8140. 

  8140.     }
    8141. 

  8141.   } else if (!strcmp(model,"RD175")) {
    8142. 

  8142.     height = 986;
    8143. 

  8143.     width = 1534;
    8144. 

  8144.     data_offset = 513;
    8145. 

  8145.     filters = 0x61616161;
    8146. 

  8146.     load_raw = &CLASS minolta_rd175_load_raw;
    8147. 

  8147.   } else if (!strcmp(model,"KD-400Z")) {
    8148. 

  8148.     height = 1712;
    8149. 

  8149.     width  = 2312;
    8150. 

  8150.     raw_width = 2336;
    8151. 

  8151.     goto konica_400z;
    8152. 

  8152.   } else if (!strcmp(model,"KD-510Z")) {
    8153. 

  8153.     goto konica_510z;
    8154. 

  8154.   } else if (!strcasecmp(make,"MINOLTA")) {
    8155. 

  8155.     load_raw = &CLASS unpacked_load_raw;
    8156. 

  8156.     maximum = 0xfff;
    8157. 

  8157.     if (!strncmp(model,"DiMAGE A",8)) {
    8158. 

  8158.       if (!strcmp(model,"DiMAGE A200"))
    8159. 

  8159. 	filters = 0x49494949;
    8160. 

  8160.       tiff_bps = 12;
    8161. 

  8161.       load_raw = &CLASS packed_load_raw;
    8162. 

  8162.     } else if (!strncmp(model,"ALPHA",5) ||
    8163. 

  8163. 	       !strncmp(model,"DYNAX",5) ||
    8164. 

  8164. 	       !strncmp(model,"MAXXUM",6)) {
    8165. 

  8165.       sprintf (model+20, "DYNAX %-10s", model+6+(model[0]=='M'));
    8166. 

  8166.       adobe_coeff (make, model+20);
    8167. 

  8167.       load_raw = &CLASS packed_load_raw;
    8168. 

  8168.     } else if (!strncmp(model,"DiMAGE G",8)) {
    8169. 

  8169.       if (model[8] == '4') {
    8170. 

  8170. 	height = 1716;
    8171. 

  8171. 	width  = 2304;
    8172. 

  8172.       } else if (model[8] == '5') {
    8173. 

  8173. konica_510z:
    8174. 

  8174. 	height = 1956;
    8175. 

  8175. 	width  = 2607;
    8176. 

  8176. 	raw_width = 2624;
    8177. 

  8177.       } else if (model[8] == '6') {
    8178. 

  8178. 	height = 2136;
    8179. 

  8179. 	width  = 2848;
    8180. 

  8180.       }
    8181. 

  8181.       data_offset += 14;
    8182. 

  8182.       filters = 0x61616161;
    8183. 

  8183. konica_400z:
    8184. 

  8184.       load_raw = &CLASS unpacked_load_raw;
    8185. 

  8185.       maximum = 0x3df;
    8186. 

  8186.       order = 0x4d4d;
    8187. 

  8187.     }
    8188. 

  8188.   } else if (!strcmp(model,"*ist D")) {
    8189. 

  8189.     data_error = -1;
    8190. 

  8190.   } else if (!strcmp(model,"*ist DS")) {
    8191. 

  8191.     height -= 2;
    8192. 

  8192.   } else if (!strcmp(model,"Optio S")) {
    8193. 

  8193.     if (fsize == 3178560) {
    8194. 

  8194.       height = 1540;
    8195. 

  8195.       width  = 2064;
    8196. 

  8196.       load_raw = &CLASS eight_bit_load_raw;
    8197. 

  8197.       cam_mul[0] *= 4;
    8198. 

  8198.       cam_mul[2] *= 4;
    8199. 

  8199.     } else {
    8200. 

  8200.       height = 1544;
    8201. 

  8201.       width  = 2068;
    8202. 

  8202.       raw_width = 3136;
    8203. 

  8203.       load_raw = &CLASS packed_load_raw;
    8204. 

  8204.       maximum = 0xf7c;
    8205. 

  8205.     }
    8206. 

  8206.   } else if (fsize == 6114240) {
    8207. 

  8207.     height = 1737;
    8208. 

  8208.     width  = 2324;
    8209. 

  8209.     raw_width = 3520;
    8210. 

  8210.     load_raw = &CLASS packed_load_raw;
    8211. 

  8211.     maximum = 0xf7a;
    8212. 

  8212.   } else if (!strcmp(model,"Optio 750Z")) {
    8213. 

  8213.     height = 2302;
    8214. 

  8214.     width  = 3072;
    8215. 

  8215.     load_raw = &CLASS packed_load_raw;
    8216. 

  8216.     load_flags = 30;
    8217. 

  8217.   } else if (!strcmp(model,"DC-833m")) {
    8218. 

  8218.     height = 2448;
    8219. 

  8219.     width  = 3264;
    8220. 

  8220.     order = 0x4949;
    8221. 

  8221.     filters = 0x61616161;
    8222. 

  8222.     load_raw = &CLASS unpacked_load_raw;
    8223. 

  8223.     maximum = 0xfc00;
    8224. 

  8224.   } else if (!strncmp(model,"S85",3)) {
    8225. 

  8225.     height = 2448;
    8226. 

  8226.     width  = 3264;
    8227. 

  8227.     raw_width = fsize/height/2;
    8228. 

  8228.     order = 0x4d4d;
    8229. 

  8229.     load_raw = &CLASS unpacked_load_raw;
    8230. 

  8230.   } else if (!strncmp(model,"NX1",3)) {
    8231. 

  8231.     height -= top_margin = 8;
    8232. 

  8232.     width -= 2 * (left_margin = 8);
    8233. 

  8233.     load_flags = 32;
    8234. 

  8234.   } else if (!strcmp(model,"NX200")) {
    8235. 

  8235.     order = 0x4949;
    8236. 

  8236.     height = 3662;
    8237. 

  8237.     width  = 5528;
    8238. 

  8238.     top_margin = 2;
    8239. 

  8239.     left_margin = 46;
    8240. 

  8240.   } else if (!strcmp(model,"EX1")) {
    8241. 

  8241.     order = 0x4949;
    8242. 

  8242.     height -= 20;
    8243. 

  8243.     top_margin = 2;
    8244. 

  8244.     if ((width -= 6) > 3682) {
    8245. 

  8245.       height -= 10;
    8246. 

  8246.       width  -= 46;
    8247. 

  8247.       top_margin = 8;
    8248. 

  8248.     }
    8249. 

  8249.   } else if (!strcmp(model,"WB2000")) {
    8250. 

  8250.     order = 0x4949;
    8251. 

  8251.     height -= 3;
    8252. 

  8252.     top_margin = 2;
    8253. 

  8253.     if ((width -= 10) > 3718) {
    8254. 

  8254.       height -= 28;
    8255. 

  8255.       width  -= 56;
    8256. 

  8256.       top_margin = 8;
    8257. 

  8257.     }
    8258. 

  8258.   } else if (fsize == 20487168) {
    8259. 

  8259.     height = 2808;
    8260. 

  8260.     width  = 3648;
    8261. 

  8261.     goto wb550;
    8262. 

  8262.   } else if (fsize == 24000000) {
    8263. 

  8263.     height = 3000;
    8264. 

  8264.     width  = 4000;
    8265. 

  8265. wb550:
    8266. 

  8266.     strcpy (model, "WB550");
    8267. 

  8267.     order = 0x4d4d;
    8268. 

  8268.     load_raw = &CLASS unpacked_load_raw;
    8269. 

  8269.     load_flags = 6;
    8270. 

  8270.     maximum = 0x3df;
    8271. 

  8271.   } else if (!strcmp(model,"STV680 VGA")) {
    8272. 

  8272.     height = 484;
    8273. 

  8273.     width  = 644;
    8274. 

  8274.     load_raw = &CLASS eight_bit_load_raw;
    8275. 

  8275.     flip = 2;
    8276. 

  8276.     filters = 0x16161616;
    8277. 

  8277.     black = 16;
    8278. 

  8278.   } else if (!strcmp(model,"N95")) {
    8279. 

  8279.     height = raw_height - (top_margin = 2);
    8280. 

  8280.   } else if (!strcmp(model,"531C")) {
    8281. 

  8281.     height = 1200;
    8282. 

  8282.     width  = 1600;
    8283. 

  8283.     load_raw = &CLASS unpacked_load_raw;
    8284. 

  8284.     filters = 0x49494949;
    8285. 

  8285.   } else if (!strcmp(model,"F-080C")) {
    8286. 

  8286.     height = 768;
    8287. 

  8287.     width  = 1024;
    8288. 

  8288.     load_raw = &CLASS eight_bit_load_raw;
    8289. 

  8289.   } else if (!strcmp(model,"F-145C")) {
    8290. 

  8290.     height = 1040;
    8291. 

  8291.     width  = 1392;
    8292. 

  8292.     load_raw = &CLASS eight_bit_load_raw;
    8293. 

  8293.   } else if (!strcmp(model,"F-201C")) {
    8294. 

  8294.     height = 1200;
    8295. 

  8295.     width  = 1600;
    8296. 

  8296.     load_raw = &CLASS eight_bit_load_raw;
    8297. 

  8297.   } else if (!strcmp(model,"F-510C")) {
    8298. 

  8298.     height = 1958;
    8299. 

  8299.     width  = 2588;
    8300. 

  8300.     load_raw = fsize < 7500000 ?
    8301. 

  8301. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8302. 

  8302.     data_offset = fsize - width*height*(fsize >> 22);
    8303. 

  8303.     maximum = 0xfff0;
    8304. 

  8304.   } else if (!strcmp(model,"F-810C")) {
    8305. 

  8305.     height = 2469;
    8306. 

  8306.     width  = 3272;
    8307. 

  8307.     load_raw = &CLASS unpacked_load_raw;
    8308. 

  8308.     maximum = 0xfff0;
    8309. 

  8309.   } else if (!strcmp(model,"XCD-SX910CR")) {
    8310. 

  8310.     height = 1024;
    8311. 

  8311.     width  = 1375;
    8312. 

  8312.     raw_width = 1376;
    8313. 

  8313.     filters = 0x49494949;
    8314. 

  8314.     maximum = 0x3ff;
    8315. 

  8315.     load_raw = fsize < 2000000 ?
    8316. 

  8316. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8317. 

  8317.   } else if (!strcmp(model,"2010")) {
    8318. 

  8318.     height = 1207;
    8319. 

  8319.     width  = 1608;
    8320. 

  8320.     order = 0x4949;
    8321. 

  8321.     filters = 0x16161616;
    8322. 

  8322.     data_offset = 3212;
    8323. 

  8323.     maximum = 0x3ff;
    8324. 

  8324.     load_raw = &CLASS unpacked_load_raw;
    8325. 

  8325.   } else if (!strcmp(model,"A782")) {
    8326. 

  8326.     height = 3000;
    8327. 

  8327.     width  = 2208;
    8328. 

  8328.     filters = 0x61616161;
    8329. 

  8329.     load_raw = fsize < 10000000 ?
    8330. 

  8330. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8331. 

  8331.     maximum = 0xffc0;
    8332. 

  8332.   } else if (!strcmp(model,"3320AF")) {
    8333. 

  8333.     height = 1536;
    8334. 

  8334.     raw_width = width = 2048;
    8335. 

  8335.     filters = 0x61616161;
    8336. 

  8336.     load_raw = &CLASS unpacked_load_raw;
    8337. 

  8337.     maximum = 0x3ff;
    8338. 

  8338.     fseek (ifp, 0x300000, SEEK_SET);
    8339. 

  8339.     if ((order = guess_byte_order(0x10000)) == 0x4d4d) {
    8340. 

  8340.       height -= (top_margin = 16);
    8341. 

  8341.       width -= (left_margin = 28);
    8342. 

  8342.       maximum = 0xf5c0;
    8343. 

  8343.       strcpy (make, "ISG");
    8344. 

  8344.       model[0] = 0;
    8345. 

  8345.     }
    8346. 

  8346.   } else if (!strcmp(make,"Hasselblad")) {
    8347. 

  8347.     if (load_raw == &CLASS lossless_jpeg_load_raw)
    8348. 

  8348.       load_raw = &CLASS hasselblad_load_raw;
    8349. 

  8349.     if (raw_width == 7262) {
    8350. 

  8350.       height = 5444;
    8351. 

  8351.       width  = 7248;
    8352. 

  8352.       top_margin  = 4;
    8353. 

  8353.       left_margin = 7;
    8354. 

  8354.       filters = 0x61616161;
    8355. 

  8355.     } else if (raw_width == 7410) {
    8356. 

  8356.       height = 5502;
    8357. 

  8357.       width  = 7328;
    8358. 

  8358.       top_margin  = 4;
    8359. 

  8359.       left_margin = 41;
    8360. 

  8360.       filters = 0x61616161;
    8361. 

  8361.     } else if (raw_width == 9044) {
    8362. 

  8362.       height = 6716;
    8363. 

  8363.       width  = 8964;
    8364. 

  8364.       top_margin  = 8;
    8365. 

  8365.       left_margin = 40;
    8366. 

  8366.       black += load_flags = 256;
    8367. 

  8367.       maximum = 0x8101;
    8368. 

  8368.     } else if (raw_width == 4090) {
    8369. 

  8369.       strcpy (model, "V96C");
    8370. 

  8370.       height -= (top_margin = 6);
    8371. 

  8371.       width -= (left_margin = 3) + 7;
    8372. 

  8372.       filters = 0x61616161;
    8373. 

  8373.     }
    8374. 

  8374.   } else if (!strcmp(make,"Sinar")) {
    8375. 

  8375.     if (!memcmp(head,"8BPS",4)) {
    8376. 

  8376.       fseek (ifp, 14, SEEK_SET);
    8377. 

  8377.       height = get4();
    8378. 

  8378.       width  = get4();
    8379. 

  8379.       filters = 0x61616161;
    8380. 

  8380.       data_offset = 68;
    8381. 

  8381.     }
    8382. 

  8382.     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
    8383. 

  8383.     maximum = 0x3fff;
    8384. 

  8384.   } else if (!strcmp(make,"Leaf")) {
    8385. 

  8385.     maximum = 0x3fff;
    8386. 

  8386.     fseek (ifp, data_offset, SEEK_SET);
    8387. 

  8387.     if (ljpeg_start (&jh, 1) && jh.bits == 15)
    8388. 

  8388.       maximum = 0x1fff;
    8389. 

  8389.     if (tiff_samples > 1) filters = 0;
    8390. 

  8390.     if (tiff_samples > 1 || tile_length < raw_height) {
    8391. 

  8391.       load_raw = &CLASS leaf_hdr_load_raw;
    8392. 

  8392.       raw_width = tile_width;
    8393. 

  8393.     }
    8394. 

  8394.     if ((width | height) == 2048) {
    8395. 

  8395.       if (tiff_samples == 1) {
    8396. 

  8396. 	filters = 1;
    8397. 

  8397. 	strcpy (cdesc, "RBTG");
    8398. 

  8398. 	strcpy (model, "CatchLight");
    8399. 

  8399. 	top_margin =  8; left_margin = 18; height = 2032; width = 2016;
    8400. 

  8400.       } else {
    8401. 

  8401. 	strcpy (model, "DCB2");
    8402. 

  8402. 	top_margin = 10; left_margin = 16; height = 2028; width = 2022;
    8403. 

  8403.       }
    8404. 

  8404.     } else if (width+height == 3144+2060) {
    8405. 

  8405.       if (!model[0]) strcpy (model, "Cantare");
    8406. 

  8406.       if (width > height) {
    8407. 

  8407. 	 top_margin = 6; left_margin = 32; height = 2048;  width = 3072;
    8408. 

  8408. 	filters = 0x61616161;
    8409. 

  8409.       } else {
    8410. 

  8410. 	left_margin = 6;  top_margin = 32;  width = 2048; height = 3072;
    8411. 

  8411. 	filters = 0x16161616;
    8412. 

  8412.       }
    8413. 

  8413.       if (!cam_mul[0] || model[0] == 'V') filters = 0;
    8414. 

  8414.       else is_raw = tiff_samples;
    8415. 

  8415.     } else if (width == 2116) {
    8416. 

  8416.       strcpy (model, "Valeo 6");
    8417. 

  8417.       height -= 2 * (top_margin = 30);
    8418. 

  8418.       width -= 2 * (left_margin = 55);
    8419. 

  8419.       filters = 0x49494949;
    8420. 

  8420.     } else if (width == 3171) {
    8421. 

  8421.       strcpy (model, "Valeo 6");
    8422. 

  8422.       height -= 2 * (top_margin = 24);
    8423. 

  8423.       width -= 2 * (left_margin = 24);
    8424. 

  8424.       filters = 0x16161616;
    8425. 

  8425.     }
    8426. 

  8426.   } else if (!strcmp(make,"LEICA") || !strcmp(make,"Panasonic")) {
    8427. 

  8427.      if(raw_width < 1) { is_raw = 0; goto notraw; }
    8428. 

  8428.     if ((flen - data_offset) / (raw_width*8/7) == raw_height)
    8429. 

  8429.       load_raw = &CLASS panasonic_load_raw;
    8430. 

  8430.     if (!load_raw) {
    8431. 

  8431.       load_raw = &CLASS unpacked_load_raw;
    8432. 

  8432.       load_flags = 4;
    8433. 

  8433.     }
    8434. 

  8434.     zero_is_bad = 1;
    8435. 

  8435.     if ((height += 12) > raw_height) height = raw_height;
    8436. 

  8436.     for (i=0; i < sizeof pana / sizeof *pana; i++)
    8437. 

  8437.       if (raw_width == pana[i][0] && raw_height == pana[i][1]) {
    8438. 

  8438. 	left_margin = pana[i][2];
    8439. 

  8439. 	 top_margin = pana[i][3];
    8440. 

  8440. 	     width += pana[i][4];
    8441. 

  8441. 	    height += pana[i][5];
    8442. 

  8442.       }
    8443. 

  8443.     filters = 0x01010101 * (uchar) "\x94\x61\x49\x16"
    8444. 

  8444. 	[((filters-1) ^ (left_margin & 1) ^ (top_margin << 1)) & 3];
    8445. 

  8445.   } else if (!strcmp(model,"C770UZ")) {
    8446. 

  8446.     height = 1718;
    8447. 

  8447.     width  = 2304;
    8448. 

  8448.     filters = 0x16161616;
    8449. 

  8449.     load_raw = &CLASS packed_load_raw;
    8450. 

  8450.     load_flags = 30;
    8451. 

  8451.   } else if (!strcmp(make,"OLYMPUS")) {
    8452. 

  8452.     height += height & 1;
    8453. 

  8453.     filters = exif_cfa;
    8454. 

  8454.     if (width == 4100) width -= 4;
    8455. 

  8455.     if (width == 4080) width -= 24;
    8456. 

  8456.     if (load_raw == &CLASS unpacked_load_raw)
    8457. 

  8457.       load_flags = 4;
    8458. 

  8458.     tiff_bps = 12;
    8459. 

  8459.     if (!strcmp(model,"E-300") ||
    8460. 

  8460. 	!strcmp(model,"E-500")) {
    8461. 

  8461.       width -= 20;
    8462. 

  8462.       if (load_raw == &CLASS unpacked_load_raw) {
    8463. 

  8463. 	maximum = 0xfc3;
    8464. 

  8464. 	memset (cblack, 0, sizeof cblack);
    8465. 

  8465.       }
    8466. 

  8466.     } else if (!strcmp(model,"E-330")) {
    8467. 

  8467.       width -= 30;
    8468. 

  8468.       if (load_raw == &CLASS unpacked_load_raw)
    8469. 

  8469. 	maximum = 0xf79;
    8470. 

  8470.     } else if (!strcmp(model,"SP550UZ")) {
    8471. 

  8471.       thumb_length = flen - (thumb_offset = 0xa39800);
    8472. 

  8472.       thumb_height = 480;
    8473. 

  8473.       thumb_width  = 640;
    8474. 

  8474.     }
    8475. 

  8475.   } else if (!strcmp(model,"N Digital")) {
    8476. 

  8476.     height = 2047;
    8477. 

  8477.     width  = 3072;
    8478. 

  8478.     filters = 0x61616161;
    8479. 

  8479.     data_offset = 0x1a00;
    8480. 

  8480.     load_raw = &CLASS packed_load_raw;
    8481. 

  8481.   } else if (!strcmp(model,"DSC-F828")) {
    8482. 

  8482.     width = 3288;
    8483. 

  8483.     left_margin = 5;
    8484. 

  8484.     data_offset = 862144;
    8485. 

  8485.     load_raw = &CLASS sony_load_raw;
    8486. 

  8486.     filters = 0x9c9c9c9c;
    8487. 

  8487.     colors = 4;
    8488. 

  8488.     strcpy (cdesc, "RGBE");
    8489. 

  8489.   } else if (!strcmp(model,"DSC-V3")) {
    8490. 

  8490.     width = 3109;
    8491. 

  8491.     left_margin = 59;
    8492. 

  8492.     data_offset = 787392;
    8493. 

  8493.     load_raw = &CLASS sony_load_raw;
    8494. 

  8494.   } else if (!strcmp(make,"SONY") && raw_width == 3984) {
    8495. 

  8495.     adobe_coeff ("SONY","DSC-R1");
    8496. 

  8496.     width = 3925;
    8497. 

  8497.     order = 0x4d4d;
    8498. 

  8498.   } else if (!strcmp(make,"SONY") && raw_width == 6048) {
    8499. 

  8499.     width -= 24;
    8500. 

  8500.   } else if (!strcmp(model,"DSLR-A100")) {
    8501. 

  8501.     if (width == 3880) {
    8502. 

  8502.       height--;
    8503. 

  8503.       width = ++raw_width;
    8504. 

  8504.     } else {
    8505. 

  8505.       order = 0x4d4d;
    8506. 

  8506.       load_flags = 2;
    8507. 

  8507.     }
    8508. 

  8508.     filters = 0x61616161;
    8509. 

  8509.   } else if (!strcmp(model,"DSLR-A350")) {
    8510. 

  8510.     height -= 4;
    8511. 

  8511.   }
    8512. 

  8512.   else
    8513. 

  8513.       identify2(fsize,flen,head); /* Avoid MS VS 2008 bug */
    8514. 

  8514. 

  8515. 

  8516.   if (!model[0])
    8517. 

  8517.     sprintf (model, "%dx%d", width, height);
    8518. 

  8518.   if (filters == UINT_MAX) filters = 0x94949494;
    8519. 

  8519.   if (raw_color) adobe_coeff (make, model);
    8520. 

  8520.   if (load_raw == &CLASS kodak_radc_load_raw)
    8521. 

  8521.     if (raw_color) adobe_coeff ("Apple","Quicktake");
    8522. 

  8522.   if (thumb_offset && !thumb_height) {
    8523. 

  8523.     fseek (ifp, thumb_offset, SEEK_SET);
    8524. 

  8524.     if (ljpeg_start (&jh, 1)) {
    8525. 

  8525.       thumb_width  = jh.wide;
    8526. 

  8526.       thumb_height = jh.high;
    8527. 

  8527.     }
    8528. 

  8528.   }
    8529. 

  8529. dng_skip:
    8530. 

  8530.   if (!tiff_bps) tiff_bps = 12;
    8531. 

  8531.   if (!maximum) maximum = (1 << tiff_bps) - 1;
    8532. 

  8532.   if (!load_raw || height < 22) is_raw = 0;
    8533. 

  8533. #ifdef NO_JASPER
    8534. 

  8534.   if (load_raw == &CLASS redcine_load_raw) {
    8535. 

  8535. #ifdef DCRAW_VERBOSE
    8536. 

  8536.     fprintf (stderr,_("%s: You must link dcraw with %s!!\n"),
    8537. 

  8537. 	ifname, "libjasper");
    8538. 

  8538. #endif
    8539. 

  8539.     is_raw = 0;
    8540. 

  8540. #ifdef LIBRAW_LIBRARY_BUILD
    8541. 

  8541.     imgdata.process_warnings |= LIBRAW_WARN_NO_JASPER;
    8542. 

  8542. #endif
    8543. 

  8543.   }
    8544. 

  8544. #endif
    8545. 

  8545. #ifdef NO_JPEG
    8546. 

  8546.   if (load_raw == &CLASS kodak_jpeg_load_raw) {
    8547. 

  8547. #ifdef DCRAW_VERBOSE
    8548. 

  8548.     fprintf (stderr,_("%s: You must link dcraw with %s!!\n"),
    8549. 

  8549. 	ifname, "libjpeg");
    8550. 

  8550. #endif
    8551. 

  8551.     is_raw = 0;
    8552. 

  8552. #ifdef LIBRAW_LIBRARY_BUILD
    8553. 

  8553.     imgdata.process_warnings |= LIBRAW_WARN_NO_JPEGLIB;
    8554. 

  8554. #endif
    8555. 

  8555.   }
    8556. 

  8556. #endif
    8557. 

  8557.   if (!cdesc[0])
    8558. 

  8558.     strcpy (cdesc, colors == 3 ? "RGBG":"GMCY");
    8559. 

  8559.   if (!raw_height) raw_height = height;
    8560. 

  8560.   if (!raw_width ) raw_width  = width;
    8561. 

  8561.   if (filters && colors == 3)
    8562. 

  8562.     filters |= ((filters >> 2 & 0x22222222) |
    8563. 

  8563. 		(filters << 2 & 0x88888888)) & filters << 1;
    8564. 

  8564. notraw:
    8565. 

  8565.   if (flip == -1) flip = tiff_flip;
    8566. 

  8566.   if (flip == -1) flip = 0;
    8567. 

  8567. 

  8568. #ifdef LIBRAW_LIBRARY_BUILD
    8569. 

  8569.   RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY,1,2);
    8570. 

  8570. #endif
    8571. 

  8571. }
    8572. 

  8572. 

  8573. void CLASS identify2(unsigned fsize, unsigned flen, char *head)
    8574. 

  8574. {
    8575. 

  8575.  if (!strcmp(model,"PIXL")) {
    8576. 

  8576.     height -= top_margin = 4;
    8577. 

  8577.     width -= left_margin = 32;
    8578. 

  8578.     gamma_curve (0, 7, 1, 255);
    8579. 

  8579.   } else if (!strcmp(model,"C603v")) {
    8580. 

  8580.     height = 480;
    8581. 

  8581.     width  = 640;
    8582. 

  8582.     if (fsize < 614400 || find_green (16, 16, 3840, 5120) < 25) goto c603v;
    8583. 

  8583.     strcpy (model,"KAI-0340");
    8584. 

  8584.     height -= 3;
    8585. 

  8585.     data_offset = 3840;
    8586. 

  8586.     order = 0x4949;
    8587. 

  8587.     load_raw = &CLASS unpacked_load_raw;
    8588. 

  8588.   } else if (!strcmp(model,"C603y")) {
    8589. 

  8589.     height = 2134;
    8590. 

  8590.     width  = 2848;
    8591. 

  8591. c603v:
    8592. 

  8592.     filters = 0;
    8593. 

  8593.     load_raw = &CLASS kodak_yrgb_load_raw;
    8594. 

  8594.     gamma_curve (0, 3.875, 1, 255);
    8595. 

  8595.   } else if (!strcmp(model,"C603")) {
    8596. 

  8596.     raw_height = height = 2152;
    8597. 

  8597.     raw_width  = width  = 2864;
    8598. 

  8598.     goto c603;
    8599. 

  8599.   } else if (!strcmp(model,"C330")) {
    8600. 

  8600.     height = 1744;
    8601. 

  8601.     width  = 2336;
    8602. 

  8602.     raw_height = 1779;
    8603. 

  8603.     raw_width  = 2338;
    8604. 

  8604.     top_margin = 33;
    8605. 

  8605.     left_margin = 1;
    8606. 

  8606. c603:
    8607. 

  8607.     order = 0x4949;
    8608. 

  8608.     if ((data_offset = fsize - raw_height*raw_width)) {
    8609. 

  8609.       fseek (ifp, 168, SEEK_SET);
    8610. 

  8610.       read_shorts (curve, 256);
    8611. 

  8611. #ifdef LIBRAW_LIBRARY_BUILD
    8612. 

  8612.       color_flags.curve_state = LIBRAW_COLORSTATE_LOADED;
    8613. 

  8613. #endif
    8614. 

  8614.     } else gamma_curve (0, 3.875, 1, 255);
    8615. 

  8615.     load_raw = &CLASS eight_bit_load_raw;
    8616. 

  8616.   }
    8617. 

  8617.  else if (!strncasecmp(model,"EasyShare",9)) {
    8618. 

  8618.     data_offset = data_offset < 0x15000 ? 0x15000 : 0x17000;
    8619. 

  8619.     load_raw = &CLASS packed_load_raw;
    8620. 

  8620.   } else if (!strcasecmp(make,"KODAK")) {
    8621. 

  8621.     if (filters == UINT_MAX) filters = 0x61616161;
    8622. 

  8622.     if (!strncmp(model,"NC2000",6)) {
    8623. 

  8623.       width -= 4;
    8624. 

  8624.       left_margin = 2;
    8625. 

  8625.     } else if (!strcmp(model,"EOSDCS3B")) {
    8626. 

  8626.       width -= 4;
    8627. 

  8627.       left_margin = 2;
    8628. 

  8628.     } else if (!strcmp(model,"EOSDCS1")) {
    8629. 

  8629.       width -= 4;
    8630. 

  8630.       left_margin = 2;
    8631. 

  8631.     } else if (!strcmp(model,"DCS420")) {
    8632. 

  8632.       width -= 4;
    8633. 

  8633.       left_margin = 2;
    8634. 

  8634.     } else if (!strncmp(model,"DCS460 ",7)) {
    8635. 

  8635.       model[6] = 0;
    8636. 

  8636.       width -= 4;
    8637. 

  8637.       left_margin = 2;
    8638. 

  8638.     } else if (!strcmp(model,"DCS460A")) {
    8639. 

  8639.       width -= 4;
    8640. 

  8640.       left_margin = 2;
    8641. 

  8641.       colors = 1;
    8642. 

  8642.       filters = 0;
    8643. 

  8643.     } else if (!strcmp(model,"DCS660M")) {
    8644. 

  8644.       black = 214;
    8645. 

  8645.       colors = 1;
    8646. 

  8646.       filters = 0;
    8647. 

  8647.     } else if (!strcmp(model,"DCS760M")) {
    8648. 

  8648.       colors = 1;
    8649. 

  8649.       filters = 0;
    8650. 

  8650.     }
    8651. 

  8651.     if (!strcmp(model+4,"20X"))
    8652. 

  8652.       strcpy (cdesc, "MYCY");
    8653. 

  8653.     if (strstr(model,"DC25")) {
    8654. 

  8654.       strcpy (model, "DC25");
    8655. 

  8655.       data_offset = 15424;
    8656. 

  8656.     }
    8657. 

  8657.     if (!strncmp(model,"DC2",3)) {
    8658. 

  8658.       height = 242;
    8659. 

  8659.       if (flen < 100000) {
    8660. 

  8660. 	raw_width = 256; width = 249;
    8661. 

  8661. 	pixel_aspect = (4.0*height) / (3.0*width);
    8662. 

  8662.       } else {
    8663. 

  8663. 	raw_width = 512; width = 501;
    8664. 

  8664. 	pixel_aspect = (493.0*height) / (373.0*width);
    8665. 

  8665.       }
    8666. 

  8666.       data_offset += raw_width + 1;
    8667. 

  8667.       colors = 4;
    8668. 

  8668.       filters = 0x8d8d8d8d;
    8669. 

  8669.       simple_coeff(1);
    8670. 

  8670.       pre_mul[1] = 1.179;
    8671. 

  8671.       pre_mul[2] = 1.209;
    8672. 

  8672.       pre_mul[3] = 1.036;
    8673. 

  8673. #ifdef LIBRAW_LIBRARY_BUILD
    8674. 

  8674.       color_flags.pre_mul_state = LIBRAW_COLORSTATE_CONST;
    8675. 

  8675. #endif
    8676. 

  8676.       load_raw = &CLASS eight_bit_load_raw;
    8677. 

  8677.     } else if (!strcmp(model,"40")) {
    8678. 

  8678.       strcpy (model, "DC40");
    8679. 

  8679.       height = 512;
    8680. 

  8680.       width  = 768;
    8681. 

  8681.       data_offset = 1152;
    8682. 

  8682.       load_raw = &CLASS kodak_radc_load_raw;
    8683. 

  8683.     } else if (strstr(model,"DC50")) {
    8684. 

  8684.       strcpy (model, "DC50");
    8685. 

  8685.       height = 512;
    8686. 

  8686.       width  = 768;
    8687. 

  8687.       data_offset = 19712;
    8688. 

  8688.       load_raw = &CLASS kodak_radc_load_raw;
    8689. 

  8689.     } else if (strstr(model,"DC120")) {
    8690. 

  8690.       strcpy (model, "DC120");
    8691. 

  8691.       height = 976;
    8692. 

  8692.       width  = 848;
    8693. 

  8693.       pixel_aspect = height/0.75/width;
    8694. 

  8694.       load_raw = tiff_compress == 7 ?
    8695. 

  8695. 	&CLASS kodak_jpeg_load_raw : &CLASS kodak_dc120_load_raw;
    8696. 

  8696.     } else if (!strcmp(model,"DCS200")) {
    8697. 

  8697.       thumb_height = 128;
    8698. 

  8698.       thumb_width  = 192;
    8699. 

  8699.       thumb_offset = 6144;
    8700. 

  8700.       thumb_misc   = 360;
    8701. 

  8701.       write_thumb = &CLASS layer_thumb;
    8702. 

  8702.       height = 1024;
    8703. 

  8703.       width  = 1536;
    8704. 

  8704.       data_offset = 79872;
    8705. 

  8705.       load_raw = &CLASS eight_bit_load_raw;
    8706. 

  8706.       black = 17;
    8707. 

  8707.     }
    8708. 

  8708. } else if (!strcmp(model,"Fotoman Pixtura")) {
    8709. 

  8709.     height = 512;
    8710. 

  8710.     width  = 768;
    8711. 

  8711.     data_offset = 3632;
    8712. 

  8712.     load_raw = &CLASS kodak_radc_load_raw;
    8713. 

  8713.     filters = 0x61616161;
    8714. 

  8714.     simple_coeff(2);
    8715. 

  8715.   } else if (!strncmp(model,"QuickTake",9)) {
    8716. 

  8716.     if (head[5]) strcpy (model+10, "200");
    8717. 

  8717.     fseek (ifp, 544, SEEK_SET);
    8718. 

  8718.     height = get2();
    8719. 

  8719.     width  = get2();
    8720. 

  8720.     data_offset = (get4(),get2()) == 30 ? 738:736;
    8721. 

  8721.     if (height > width) {
    8722. 

  8722.       SWAP(height,width);
    8723. 

  8723.       fseek (ifp, data_offset-6, SEEK_SET);
    8724. 

  8724.       flip = ~get2() & 3 ? 5:6;
    8725. 

  8725.     }
    8726. 

  8726.     filters = 0x61616161;
    8727. 

  8727.   } else if (!strcmp(make,"Rollei") && !load_raw) {
    8728. 

  8728.     switch (raw_width) {
    8729. 

  8729.       case 1316:
    8730. 

  8730. 	height = 1030;
    8731. 

  8731. 	width  = 1300;
    8732. 

  8732. 	top_margin  = 1;
    8733. 

  8733. 	left_margin = 6;
    8734. 

  8734. 	break;
    8735. 

  8735.       case 2568:
    8736. 

  8736. 	height = 1960;
    8737. 

  8737. 	width  = 2560;
    8738. 

  8738. 	top_margin  = 2;
    8739. 

  8739. 	left_margin = 8;
    8740. 

  8740.     }
    8741. 

  8741.     filters = 0x16161616;
    8742. 

  8742.     load_raw = &CLASS rollei_load_raw;
    8743. 

  8743.   } else if (!strcmp(model,"PC-CAM 600")) {
    8744. 

  8744.     height = 768;
    8745. 

  8745.     data_offset = width = 1024;
    8746. 

  8746.     filters = 0x49494949;
    8747. 

  8747.     load_raw = &CLASS eight_bit_load_raw;
    8748. 

  8748.   }
    8749. 

  8749. else if (!strcmp(model,"QV-2000UX")) {
    8750. 

  8750.     height = 1208;
    8751. 

  8751.     width  = 1632;
    8752. 

  8752.     data_offset = width * 2;
    8753. 

  8753.     load_raw = &CLASS eight_bit_load_raw;
    8754. 

  8754.   } else if (fsize == 3217760) {
    8755. 

  8755.     height = 1546;
    8756. 

  8756.     width  = 2070;
    8757. 

  8757.     raw_width = 2080;
    8758. 

  8758.     load_raw = &CLASS eight_bit_load_raw;
    8759. 

  8759.   } else if (!strcmp(model,"QV-4000")) {
    8760. 

  8760.     height = 1700;
    8761. 

  8761.     width  = 2260;
    8762. 

  8762.     load_raw = &CLASS unpacked_load_raw;
    8763. 

  8763.     maximum = 0xffff;
    8764. 

  8764.   } else if (!strcmp(model,"QV-5700")) {
    8765. 

  8765.     height = 1924;
    8766. 

  8766.     width  = 2576;
    8767. 

  8767.     raw_width = 3232;
    8768. 

  8768.     tiff_bps = 10;
    8769. 

  8769.   } else if (!strcmp(model,"QV-R41")) {
    8770. 

  8770.     height = 1720;
    8771. 

  8771.     width  = 2312;
    8772. 

  8772.     raw_width = 3520;
    8773. 

  8773.     left_margin = 2;
    8774. 

  8774.   } else if (!strcmp(model,"QV-R51")) {
    8775. 

  8775.     height = 1926;
    8776. 

  8776.     width  = 2580;
    8777. 

  8777.     raw_width = 3904;
    8778. 

  8778.   } else if (!strcmp(model,"EX-S20")) {
    8779. 

  8779.     height = 1208;
    8780. 

  8780.     width  = 1620;
    8781. 

  8781.     raw_width = 2432;
    8782. 

  8782.     flip = 3;
    8783. 

  8783.   } else if (!strcmp(model,"EX-S100")) {
    8784. 

  8784.     height = 1544;
    8785. 

  8785.     width  = 2058;
    8786. 

  8786.     raw_width = 3136;
    8787. 

  8787.   } else if (!strcmp(model,"EX-Z50")) {
    8788. 

  8788.     height = 1931;
    8789. 

  8789.     width  = 2570;
    8790. 

  8790.     raw_width = 3904;
    8791. 

  8791.   } else if (!strcmp(model,"EX-Z55")) {
    8792. 

  8792.     height = 1960;
    8793. 

  8793.     width  = 2570;
    8794. 

  8794.     raw_width = 3904;
    8795. 

  8795.   } else if (!strcmp(model,"EX-Z60")) {
    8796. 

  8796.     height = 2145;
    8797. 

  8797.     width  = 2833;
    8798. 

  8798.     raw_width = 3584;
    8799. 

  8799.     filters = 0x16161616;
    8800. 

  8800.     tiff_bps = 10;
    8801. 

  8801.   } else if (!strcmp(model,"EX-Z75")) {
    8802. 

  8802.     height = 2321;
    8803. 

  8803.     width  = 3089;
    8804. 

  8804.     raw_width = 4672;
    8805. 

  8805.   } else if (!strcmp(model,"EX-Z750")) {
    8806. 

  8806.     height = 2319;
    8807. 

  8807.     width  = 3087;
    8808. 

  8808.     raw_width = 4672;
    8809. 

  8809.     maximum = 0xfff;
    8810. 

  8810.   } else if (!strcmp(model,"EX-Z850")) {
    8811. 

  8811.     height = 2468;
    8812. 

  8812.     width  = 3279;
    8813. 

  8813.     raw_width = 4928;
    8814. 

  8814.     maximum = 0xfff;
    8815. 

  8815.   } else if (fsize == 15499264) {       /* EX-Z1050 or EX-Z1080 */
    8816. 

  8816.     height = 2752;
    8817. 

  8817.     width  = 3672;
    8818. 

  8818.     raw_width = 5632;
    8819. 

  8819.   } else if (!strcmp(model,"EX-P505")) {
    8820. 

  8820.     height = 1928;
    8821. 

  8821.     width  = 2568;
    8822. 

  8822.     raw_width = 3852;
    8823. 

  8823.     maximum = 0xfff;
    8824. 

  8824.   } else if (fsize == 9313536) {	/* EX-P600 or QV-R61 */
    8825. 

  8825.     height = 2142;
    8826. 

  8826.     width  = 2844;
    8827. 

  8827.     raw_width = 4288;
    8828. 

  8828.   } else if (!strcmp(model,"EX-P700")) {
    8829. 

  8829.     height = 2318;
    8830. 

  8830.     width  = 3082;
    8831. 

  8831.     raw_width = 4672;
    8832. 

  8832.   }
    8833. 

  8833.   else if (!strcmp(model,"GRAS-50S5C")) {
    8834. 

  8834.    height = 2048;
    8835. 

  8835.    width = 2440;
    8836. 

  8836.    load_raw = &CLASS unpacked_load_raw;
    8837. 

  8837.    data_offset = 0;
    8838. 

  8838.    filters = 0x49494949;
    8839. 

  8839.    order = 0x4949;
    8840. 

  8840.    maximum = 0xfffC;
    8841. 

  8841.   } else if (!strcmp(model,"BB-500CL")) {
    8842. 

  8842.    height = 2058;
    8843. 

  8843.    width = 2448;
    8844. 

  8844.    load_raw = &CLASS unpacked_load_raw;
    8845. 

  8845.    data_offset = 0;
    8846. 

  8846.    filters = 0x94949494;
    8847. 

  8847.    order = 0x4949;
    8848. 

  8848.    maximum = 0x3fff;
    8849. 

  8849.   } else if (!strcmp(model,"BB-500GE")) {
    8850. 

  8850.    height = 2058;
    8851. 

  8851.    width = 2456;
    8852. 

  8852.    load_raw = &CLASS unpacked_load_raw;
    8853. 

  8853.    data_offset = 0;
    8854. 

  8854.    filters = 0x94949494;
    8855. 

  8855.    order = 0x4949;
    8856. 

  8856.    maximum = 0x3fff;
    8857. 

  8857.   } else if (!strcmp(model,"SVS625CL")) {
    8858. 

  8858.    height = 2050;
    8859. 

  8859.    width = 2448;
    8860. 

  8860.    load_raw = &CLASS unpacked_load_raw;
    8861. 

  8861.    data_offset = 0;
    8862. 

  8862.    filters = 0x94949494;
    8863. 

  8863.    order = 0x4949;
    8864. 

  8864.    maximum = 0x0fff;
    8865. 

  8865.   }
    8866. 

  8866. }
    8867. 

  8867. 

  8868. void CLASS convert_to_rgb()
    8869. 

  8869. {
    8870. 

  8870.   int row, col, c, i, j, k;
    8871. 

  8871.   ushort *img;
    8872. 

  8872.   float out[3], out_cam[3][4];
    8873. 

  8873.   double num, inverse[3][3];
    8874. 

  8874.   static const double xyzd50_srgb[3][3] =
    8875. 

  8875.   { { 0.436083, 0.385083, 0.143055 },
    8876. 

  8876.     { 0.222507, 0.716888, 0.060608 },
    8877. 

  8877.     { 0.013930, 0.097097, 0.714022 } };
    8878. 

  8878.   static const double rgb_rgb[3][3] =
    8879. 

  8879.   { { 1,0,0 }, { 0,1,0 }, { 0,0,1 } };
    8880. 

  8880.   static const double adobe_rgb[3][3] =
    8881. 

  8881.   { { 0.715146, 0.284856, 0.000000 },
    8882. 

  8882.     { 0.000000, 1.000000, 0.000000 },
    8883. 

  8883.     { 0.000000, 0.041166, 0.958839 } };
    8884. 

  8884.   static const double wide_rgb[3][3] =
    8885. 

  8885.   { { 0.593087, 0.404710, 0.002206 },
    8886. 

  8886.     { 0.095413, 0.843149, 0.061439 },
    8887. 

  8887.     { 0.011621, 0.069091, 0.919288 } };
    8888. 

  8888.   static const double prophoto_rgb[3][3] =
    8889. 

  8889.   { { 0.529317, 0.330092, 0.140588 },
    8890. 

  8890.     { 0.098368, 0.873465, 0.028169 },
    8891. 

  8891.     { 0.016879, 0.117663, 0.865457 } };
    8892. 

  8892.   static const double (*out_rgb[])[3] =
    8893. 

  8893.   { rgb_rgb, adobe_rgb, wide_rgb, prophoto_rgb, xyz_rgb };
    8894. 

  8894.   static const char *name[] =
    8895. 

  8895.   { "sRGB", "Adobe RGB (1998)", "WideGamut D65", "ProPhoto D65", "XYZ" };
    8896. 

  8896.   static const unsigned phead[] =
    8897. 

  8897.   { 1024, 0, 0x2100000, 0x6d6e7472, 0x52474220, 0x58595a20, 0, 0, 0,
    8898. 

  8898.     0x61637370, 0, 0, 0x6e6f6e65, 0, 0, 0, 0, 0xf6d6, 0x10000, 0xd32d };
    8899. 

  8899.   unsigned pbody[] =
    8900. 

  8900.   { 10, 0x63707274, 0, 36,	/* cprt */
    8901. 

  8901. 	0x64657363, 0, 40,	/* desc */
    8902. 

  8902. 	0x77747074, 0, 20,	/* wtpt */
    8903. 

  8903. 	0x626b7074, 0, 20,	/* bkpt */
    8904. 

  8904. 	0x72545243, 0, 14,	/* rTRC */
    8905. 

  8905. 	0x67545243, 0, 14,	/* gTRC */
    8906. 

  8906. 	0x62545243, 0, 14,	/* bTRC */
    8907. 

  8907. 	0x7258595a, 0, 20,	/* rXYZ */
    8908. 

  8908. 	0x6758595a, 0, 20,	/* gXYZ */
    8909. 

  8909. 	0x6258595a, 0, 20 };	/* bXYZ */
    8910. 

  8910.   static const unsigned pwhite[] = { 0xf351, 0x10000, 0x116cc };
    8911. 

  8911.   unsigned pcurve[] = { 0x63757276, 0, 1, 0x1000000 };
    8912. 

  8912. 

  8913. #ifdef LIBRAW_LIBRARY_BUILD
    8914. 

  8914.   RUN_CALLBACK(LIBRAW_PROGRESS_CONVERT_RGB,0,2);
    8915. 

  8915. #endif
    8916. 

  8916.   gamma_curve (gamm[0], gamm[1], 0, 0);
    8917. 

  8917.   memcpy (out_cam, rgb_cam, sizeof out_cam);
    8918. 

  8918.   raw_color |= colors == 1 || document_mode ||
    8919. 

  8919. 		output_color < 1 || output_color > 5;
    8920. 

  8920.   if (!raw_color) {
    8921. 

  8921.     oprof = (unsigned *) calloc (phead[0], 1);
    8922. 

  8922.     merror (oprof, "convert_to_rgb()");
    8923. 

  8923.     memcpy (oprof, phead, sizeof phead);
    8924. 

  8924.     if (output_color == 5) oprof[4] = oprof[5];
    8925. 

  8925.     oprof[0] = 132 + 12*pbody[0];
    8926. 

  8926.     for (i=0; i < pbody[0]; i++) {
    8927. 

  8927.       oprof[oprof[0]/4] = i ? (i > 1 ? 0x58595a20 : 0x64657363) : 0x74657874;
    8928. 

  8928.       pbody[i*3+2] = oprof[0];
    8929. 

  8929.       oprof[0] += (pbody[i*3+3] + 3) & -4;
    8930. 

  8930.     }
    8931. 

  8931.     memcpy (oprof+32, pbody, sizeof pbody);
    8932. 

  8932.     oprof[pbody[5]/4+2] = strlen(name[output_color-1]) + 1;
    8933. 

  8933.     memcpy ((char *)oprof+pbody[8]+8, pwhite, sizeof pwhite);
    8934. 

  8934.     pcurve[3] = (short)(256/gamm[5]+0.5) << 16;
    8935. 

  8935.     for (i=4; i < 7; i++)
    8936. 

  8936.       memcpy ((char *)oprof+pbody[i*3+2], pcurve, sizeof pcurve);
    8937. 

  8937.     pseudoinverse ((double (*)[3]) out_rgb[output_color-1], inverse, 3);
    8938. 

  8938.     for (i=0; i < 3; i++)
    8939. 

  8939.       for (j=0; j < 3; j++) {
    8940. 

  8940. 	for (num = k=0; k < 3; k++)
    8941. 

  8941. 	  num += xyzd50_srgb[i][k] * inverse[j][k];
    8942. 

  8942. 	oprof[pbody[j*3+23]/4+i+2] = num * 0x10000 + 0.5;
    8943. 

  8943.       }
    8944. 

  8944.     for (i=0; i < phead[0]/4; i++)
    8945. 

  8945.       oprof[i] = htonl(oprof[i]);
    8946. 

  8946.     strcpy ((char *)oprof+pbody[2]+8, "auto-generated by dcraw");
    8947. 

  8947.     strcpy ((char *)oprof+pbody[5]+12, name[output_color-1]);
    8948. 

  8948.     for (i=0; i < 3; i++)
    8949. 

  8949.       for (j=0; j < colors; j++)
    8950. 

  8950. 	for (out_cam[i][j] = k=0; k < 3; k++)
    8951. 

  8951. 	  out_cam[i][j] += out_rgb[output_color-1][i][k] * rgb_cam[k][j];
    8952. 

  8952.   }
    8953. 

  8953. #ifdef DCRAW_VERBOSE
    8954. 

  8954.   if (verbose)
    8955. 

  8955.     fprintf (stderr, raw_color ? _("Building histograms...\n") :
    8956. 

  8956. 	_("Converting to %s colorspace...\n"), name[output_color-1]);
    8957. 

  8957. 

  8958. #endif
    8959. 

  8959. #ifdef LIBRAW_LIBRARY_BUILD
    8960. 

  8960.   memset(histogram,0,sizeof(int)*LIBRAW_HISTOGRAM_SIZE*4);
    8961. 

  8961. #else
    8962. 

  8962.   memset (histogram, 0, sizeof histogram);
    8963. 

  8963. #endif
    8964. 

  8964.   for (img=image[0], row=0; row < height; row++)
    8965. 

  8965.     for (col=0; col < width; col++, img+=4) {
    8966. 

  8966.       if (!raw_color) {
    8967. 

  8967. 	out[0] = out[1] = out[2] = 0;
    8968. 

  8968. 	FORCC {
    8969. 

  8969. 	  out[0] += out_cam[0][c] * img[c];
    8970. 

  8970. 	  out[1] += out_cam[1][c] * img[c];
    8971. 

  8971. 	  out[2] += out_cam[2][c] * img[c];
    8972. 

  8972. 	}
    8973. 

  8973. 	FORC3 img[c] = CLIP((int) out[c]);
    8974. 

  8974.       }
    8975. 

  8975.       else if (document_mode)
    8976. 

  8976. 	img[0] = img[FC(row,col)];
    8977. 

  8977.       FORCC histogram[c][img[c] >> 3]++;
    8978. 

  8978.     }
    8979. 

  8979.   if (colors == 4 && output_color) colors = 3;
    8980. 

  8980.   if (document_mode && filters) colors = 1;
    8981. 

  8981. #ifdef LIBRAW_LIBRARY_BUILD
    8982. 

  8982.   RUN_CALLBACK(LIBRAW_PROGRESS_CONVERT_RGB,1,2);
    8983. 

  8983. #endif
    8984. 

  8984. }
    8985. 

  8985. 

  8986. void CLASS fuji_rotate()
    8987. 

  8987. {
    8988. 

  8988.   int i, row, col;
    8989. 

  8989.   double step;
    8990. 

  8990.   float r, c, fr, fc;
    8991. 

  8991.   unsigned ur, uc;
    8992. 

  8992.   ushort wide, high, (*img)[4], (*pix)[4];
    8993. 

  8993. 

  8994.   if (!fuji_width) return;
    8995. 

  8995. #ifdef DCRAW_VERBOSE
    8996. 

  8996.   if (verbose)
    8997. 

  8997.     fprintf (stderr,_("Rotating image 45 degrees...\n"));
    8998. 

  8998. #endif
    8999. 

  8999.   fuji_width = (fuji_width - 1 + shrink) >> shrink;
    9000. 

  9000.   step = sqrt(0.5);
    9001. 

  9001.   wide = fuji_width / step;
    9002. 

  9002.   high = (height - fuji_width) / step;
    9003. 

  9003.   img = (ushort (*)[4]) calloc (wide*high, sizeof *img);
    9004. 

  9004.   merror (img, "fuji_rotate()");
    9005. 

  9005. 

  9006. #ifdef LIBRAW_LIBRARY_BUILD
    9007. 

  9007.   RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE,0,2);
    9008. 

  9008. #endif
    9009. 

  9009. 

  9010.   for (row=0; row < high; row++)
    9011. 

  9011.     for (col=0; col < wide; col++) {
    9012. 

  9012.       ur = r = fuji_width + (row-col)*step;
    9013. 

  9013.       uc = c = (row+col)*step;
    9014. 

  9014.       if (ur > height-2 || uc > width-2) continue;
    9015. 

  9015.       fr = r - ur;
    9016. 

  9016.       fc = c - uc;
    9017. 

  9017.       pix = image + ur*width + uc;
    9018. 

  9018.       for (i=0; i < colors; i++)
    9019. 

  9019. 	img[row*wide+col][i] =
    9020. 

  9020. 	  (pix[    0][i]*(1-fc) + pix[      1][i]*fc) * (1-fr) +
    9021. 

  9021. 	  (pix[width][i]*(1-fc) + pix[width+1][i]*fc) * fr;
    9022. 

  9022.     }
    9023. 

  9023.   free (image);
    9024. 

  9024.   width  = wide;
    9025. 

  9025.   height = high;
    9026. 

  9026.   image  = img;
    9027. 

  9027.   fuji_width = 0;
    9028. 

  9028. #ifdef LIBRAW_LIBRARY_BUILD
    9029. 

  9029.   RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE,1,2);
    9030. 

  9030. #endif
    9031. 

  9031. }
    9032. 

  9032. 

  9033. void CLASS stretch()
    9034. 

  9034. {
    9035. 

  9035.   ushort newdim, (*img)[4], *pix0, *pix1;
    9036. 

  9036.   int row, col, c;
    9037. 

  9037.   double rc, frac;
    9038. 

  9038. 

  9039.   if (pixel_aspect == 1) return;
    9040. 

  9040. #ifdef LIBRAW_LIBRARY_BUILD
    9041. 

  9041.   RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH,0,2);
    9042. 

  9042. #endif
    9043. 

  9043. #ifdef DCRAW_VERBOSE
    9044. 

  9044.   if (verbose) fprintf (stderr,_("Stretching the image...\n"));
    9045. 

  9045. #endif
    9046. 

  9046.   if (pixel_aspect < 1) {
    9047. 

  9047.     newdim = height / pixel_aspect + 0.5;
    9048. 

  9048.     img = (ushort (*)[4]) calloc (width*newdim, sizeof *img);
    9049. 

  9049.     merror (img, "stretch()");
    9050. 

  9050.     for (rc=row=0; row < newdim; row++, rc+=pixel_aspect) {
    9051. 

  9051.       frac = rc - (c = rc);
    9052. 

  9052.       pix0 = pix1 = image[c*width];
    9053. 

  9053.       if (c+1 < height) pix1 += width*4;
    9054. 

  9054.       for (col=0; col < width; col++, pix0+=4, pix1+=4)
    9055. 

  9055. 	FORCC img[row*width+col][c] = pix0[c]*(1-frac) + pix1[c]*frac + 0.5;
    9056. 

  9056.     }
    9057. 

  9057.     height = newdim;
    9058. 

  9058.   } else {
    9059. 

  9059.     newdim = width * pixel_aspect + 0.5;
    9060. 

  9060.     img = (ushort (*)[4]) calloc (height*newdim, sizeof *img);
    9061. 

  9061.     merror (img, "stretch()");
    9062. 

  9062.     for (rc=col=0; col < newdim; col++, rc+=1/pixel_aspect) {
    9063. 

  9063.       frac = rc - (c = rc);
    9064. 

  9064.       pix0 = pix1 = image[c];
    9065. 

  9065.       if (c+1 < width) pix1 += 4;
    9066. 

  9066.       for (row=0; row < height; row++, pix0+=width*4, pix1+=width*4)
    9067. 

  9067. 	FORCC img[row*newdim+col][c] = pix0[c]*(1-frac) + pix1[c]*frac + 0.5;
    9068. 

  9068.     }
    9069. 

  9069.     width = newdim;
    9070. 

  9070.   }
    9071. 

  9071.   free (image);
    9072. 

  9072.   image = img;
    9073. 

  9073. #ifdef LIBRAW_LIBRARY_BUILD
    9074. 

  9074.   RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH,1,2);
    9075. 

  9075. #endif
    9076. 

  9076. }
    9077. 

  9077. 

  9078. int CLASS flip_index (int row, int col)
    9079. 

  9079. {
    9080. 

  9080.   if (flip & 4) SWAP(row,col);
    9081. 

  9081.   if (flip & 2) row = iheight - 1 - row;
    9082. 

  9082.   if (flip & 1) col = iwidth  - 1 - col;
    9083. 

  9083.   return row * iwidth + col;
    9084. 

  9084. }
    9085. 

  9085. 

  9086. void CLASS tiff_set (ushort *ntag,
    9087. 

  9087. 	ushort tag, ushort type, int count, int val)
    9088. 

  9088. {
    9089. 

  9089.   struct tiff_tag *tt;
    9090. 

  9090.   int c;
    9091. 

  9091. 

  9092.   tt = (struct tiff_tag *)(ntag+1) + (*ntag)++;
    9093. 

  9093.   tt->tag = tag;
    9094. 

  9094.   tt->type = type;
    9095. 

  9095.   tt->count = count;
    9096. 

  9096.   if (type < 3 && count <= 4)
    9097. 

  9097.     FORC(4) tt->val.c[c] = val >> (c << 3);
    9098. 

  9098.   else if (type == 3 && count <= 2)
    9099. 

  9099.     FORC(2) tt->val.s[c] = val >> (c << 4);
    9100. 

  9100.   else tt->val.i = val;
    9101. 

  9101. }
    9102. 

  9102. 

  9103. #define TOFF(ptr) ((char *)(&(ptr)) - (char *)th)
    9104. 

  9104. 

  9105. void CLASS tiff_head (struct tiff_hdr *th, int full)
    9106. 

  9106. {
    9107. 

  9107.   int c, psize=0;
    9108. 

  9108.   struct tm *t;
    9109. 

  9109. 

  9110.   memset (th, 0, sizeof *th);
    9111. 

  9111.   th->t_order = htonl(0x4d4d4949) >> 16;
    9112. 

  9112.   th->magic = 42;
    9113. 

  9113.   th->ifd = 10;
    9114. 

  9114.   if (full) {
    9115. 

  9115.     tiff_set (&th->ntag, 254, 4, 1, 0);
    9116. 

  9116.     tiff_set (&th->ntag, 256, 4, 1, width);
    9117. 

  9117.     tiff_set (&th->ntag, 257, 4, 1, height);
    9118. 

  9118.     tiff_set (&th->ntag, 258, 3, colors, output_bps);
    9119. 

  9119.     if (colors > 2)
    9120. 

  9120.       th->tag[th->ntag-1].val.i = TOFF(th->bps);
    9121. 

  9121.     FORC4 th->bps[c] = output_bps;
    9122. 

  9122.     tiff_set (&th->ntag, 259, 3, 1, 1);
    9123. 

  9123.     tiff_set (&th->ntag, 262, 3, 1, 1 + (colors > 1));
    9124. 

  9124.   }
    9125. 

  9125.   tiff_set (&th->ntag, 270, 2, 512, TOFF(th->t_desc));
    9126. 

  9126.   tiff_set (&th->ntag, 271, 2, 64, TOFF(th->t_make));
    9127. 

  9127.   tiff_set (&th->ntag, 272, 2, 64, TOFF(th->t_model));
    9128. 

  9128.   if (full) {
    9129. 

  9129.     if (oprof) psize = ntohl(oprof[0]);
    9130. 

  9130.     tiff_set (&th->ntag, 273, 4, 1, sizeof *th + psize);
    9131. 

  9131.     tiff_set (&th->ntag, 277, 3, 1, colors);
    9132. 

  9132.     tiff_set (&th->ntag, 278, 4, 1, height);
    9133. 

  9133.     tiff_set (&th->ntag, 279, 4, 1, height*width*colors*output_bps/8);
    9134. 

  9134.   } else
    9135. 

  9135.     tiff_set (&th->ntag, 274, 3, 1, "12435867"[flip]-'0');
    9136. 

  9136.   tiff_set (&th->ntag, 282, 5, 1, TOFF(th->rat[0]));
    9137. 

  9137.   tiff_set (&th->ntag, 283, 5, 1, TOFF(th->rat[2]));
    9138. 

  9138.   tiff_set (&th->ntag, 284, 3, 1, 1);
    9139. 

  9139.   tiff_set (&th->ntag, 296, 3, 1, 2);
    9140. 

  9140.   tiff_set (&th->ntag, 305, 2, 32, TOFF(th->soft));
    9141. 

  9141.   tiff_set (&th->ntag, 306, 2, 20, TOFF(th->date));
    9142. 

  9142.   tiff_set (&th->ntag, 315, 2, 64, TOFF(th->t_artist));
    9143. 

  9143.   tiff_set (&th->ntag, 34665, 4, 1, TOFF(th->nexif));
    9144. 

  9144.   if (psize) tiff_set (&th->ntag, 34675, 7, psize, sizeof *th);
    9145. 

  9145.   tiff_set (&th->nexif, 33434, 5, 1, TOFF(th->rat[4]));
    9146. 

  9146.   tiff_set (&th->nexif, 33437, 5, 1, TOFF(th->rat[6]));
    9147. 

  9147.   tiff_set (&th->nexif, 34855, 3, 1, iso_speed);
    9148. 

  9148.   tiff_set (&th->nexif, 37386, 5, 1, TOFF(th->rat[8]));
    9149. 

  9149.   if (gpsdata[1]) {
    9150. 

  9150.     tiff_set (&th->ntag, 34853, 4, 1, TOFF(th->ngps));
    9151. 

  9151.     tiff_set (&th->ngps,  0, 1,  4, 0x202);
    9152. 

  9152.     tiff_set (&th->ngps,  1, 2,  2, gpsdata[29]);
    9153. 

  9153.     tiff_set (&th->ngps,  2, 5,  3, TOFF(th->gps[0]));
    9154. 

  9154.     tiff_set (&th->ngps,  3, 2,  2, gpsdata[30]);
    9155. 

  9155.     tiff_set (&th->ngps,  4, 5,  3, TOFF(th->gps[6]));
    9156. 

  9156.     tiff_set (&th->ngps,  5, 1,  1, gpsdata[31]);
    9157. 

  9157.     tiff_set (&th->ngps,  6, 5,  1, TOFF(th->gps[18]));
    9158. 

  9158.     tiff_set (&th->ngps,  7, 5,  3, TOFF(th->gps[12]));
    9159. 

  9159.     tiff_set (&th->ngps, 18, 2, 12, TOFF(th->gps[20]));
    9160. 

  9160.     tiff_set (&th->ngps, 29, 2, 12, TOFF(th->gps[23]));
    9161. 

  9161.     memcpy (th->gps, gpsdata, sizeof th->gps);
    9162. 

  9162.   }
    9163. 

  9163.   th->rat[0] = th->rat[2] = 300;
    9164. 

  9164.   th->rat[1] = th->rat[3] = 1;
    9165. 

  9165.   FORC(6) th->rat[4+c] = 1000000;
    9166. 

  9166.   th->rat[4] *= shutter;
    9167. 

  9167.   th->rat[6] *= aperture;
    9168. 

  9168.   th->rat[8] *= focal_len;
    9169. 

  9169.   strncpy (th->t_desc, desc, 512);
    9170. 

  9170.   strncpy (th->t_make, make, 64);
    9171. 

  9171.   strncpy (th->t_model, model, 64);
    9172. 

  9172.   strcpy (th->soft, "dcraw v" DCRAW_VERSION);
    9173. 

  9173.   t = localtime (&timestamp);
    9174. 

  9174.   sprintf (th->date, "%04d:%02d:%02d %02d:%02d:%02d",
    9175. 

  9175.       t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec);
    9176. 

  9176.   strncpy (th->t_artist, artist, 64);
    9177. 

  9177. }
    9178. 

  9178. 

  9179. void CLASS jpeg_thumb_writer (FILE *tfp,char *t_humb,int t_humb_length)
    9180. 

  9180. {
    9181. 

  9181.   ushort exif[5];
    9182. 

  9182.   struct tiff_hdr th;
    9183. 

  9183.   fputc (0xff, tfp);
    9184. 

  9184.   fputc (0xd8, tfp);
    9185. 

  9185.   if (strcmp (t_humb+6, "Exif")) {
    9186. 

  9186.     memcpy (exif, "\xff\xe1  Exif\0\0", 10);
    9187. 

  9187.     exif[1] = htons (8 + sizeof th);
    9188. 

  9188.     fwrite (exif, 1, sizeof exif, tfp);
    9189. 

  9189.     tiff_head (&th, 0);
    9190. 

  9190.     fwrite (&th, 1, sizeof th, tfp);
    9191. 

  9191.   }
    9192. 

  9192.   fwrite (t_humb+2, 1, t_humb_length-2, tfp);
    9193. 

  9193. }
    9194. 

  9194. 

  9195. 

  9196. void CLASS jpeg_thumb()
    9197. 

  9197. {
    9198. 

  9198.   char *thumb;
    9199. 

  9199. 

  9200.   thumb = (char *) malloc (thumb_length);
    9201. 

  9201.   merror (thumb, "jpeg_thumb()");
    9202. 

  9202.   fread (thumb, 1, thumb_length, ifp);
    9203. 

  9203.   jpeg_thumb_writer(ofp,thumb,thumb_length);
    9204. 

  9204.   free (thumb);
    9205. 

  9205. }
    9206. 

  9206. 

  9207. void CLASS write_ppm_tiff()
    9208. 

  9208. {
    9209. 

  9209.   struct tiff_hdr th;
    9210. 

  9210.   uchar *ppm;
    9211. 

  9211.   ushort *ppm2;
    9212. 

  9212.   int c, row, col, soff, rstep, cstep;
    9213. 

  9213.   int perc, val, total, t_white=0x2000;
    9214. 

  9214. 

  9215.   perc = width * height * 0.01;		/* 99th percentile white level */
    9216. 

  9216.   if (fuji_width) perc /= 2;
    9217. 

  9217.   if (!((highlight & ~2) || no_auto_bright))
    9218. 

  9218.     for (t_white=c=0; c < colors; c++) {
    9219. 

  9219.       for (val=0x2000, total=0; --val > 32; )
    9220. 

  9220. 	if ((total += histogram[c][val]) > perc) break;
    9221. 

  9221.       if (t_white < val) t_white = val;
    9222. 

  9222.     }
    9223. 

  9223.   gamma_curve (gamm[0], gamm[1], 2, (t_white << 3)/bright);
    9224. 

  9224.   iheight = height;
    9225. 

  9225.   iwidth  = width;
    9226. 

  9226.   if (flip & 4) SWAP(height,width);
    9227. 

  9227.   ppm = (uchar *) calloc (width, colors*output_bps/8);
    9228. 

  9228.   ppm2 = (ushort *) ppm;
    9229. 

  9229.   merror (ppm, "write_ppm_tiff()");
    9230. 

  9230.   if (output_tiff) {
    9231. 

  9231.     tiff_head (&th, 1);
    9232. 

  9232.     fwrite (&th, sizeof th, 1, ofp);
    9233. 

  9233.     if (oprof)
    9234. 

  9234.       fwrite (oprof, ntohl(oprof[0]), 1, ofp);
    9235. 

  9235.   } else if (colors > 3)
    9236. 

  9236.     fprintf (ofp,
    9237. 

  9237.       "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLTYPE %s\nENDHDR\n",
    9238. 

  9238. 	width, height, colors, (1 << output_bps)-1, cdesc);
    9239. 

  9239.   else
    9240. 

  9240.     fprintf (ofp, "P%d\n%d %d\n%d\n",
    9241. 

  9241. 	colors/2+5, width, height, (1 << output_bps)-1);
    9242. 

  9242. 

  9243.   soff  = flip_index (0, 0);
    9244. 

  9244.   cstep = flip_index (0, 1) - soff;
    9245. 

  9245.   rstep = flip_index (1, 0) - flip_index (0, width);
    9246. 

  9246.   for (row=0; row < height; row++, soff += rstep) {
    9247. 

  9247.     for (col=0; col < width; col++, soff += cstep)
    9248. 

  9248.       if (output_bps == 8)
    9249. 

  9249. 	   FORCC ppm [col*colors+c] = curve[image[soff][c]] >> 8;
    9250. 

  9250.       else FORCC ppm2[col*colors+c] = curve[image[soff][c]];
    9251. 

  9251.     if (output_bps == 16 && !output_tiff && htons(0x55aa) != 0x55aa)
    9252. 

  9252.         swab ((char*)ppm2, (char*)ppm2, width*colors*2);
    9253. 

  9253.     fwrite (ppm, colors*output_bps/8, width, ofp);
    9254. 

  9254.   }
    9255. 

  9255.   free (ppm);
    9256. 

  9256. }
    9257. 

  9257. 

  9258.