PageRenderTime 119ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 3ms

/internal/dcraw_common.cpp

https://github.com/jabbervorx/LibRaw
C++ | 9324 lines | 8823 code | 357 blank | 144 comment | 2893 complexity | c4d4d41542e4407f7663f13c8f9812c0 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, 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. #line 257 "dcraw/dcraw.c"
    25. 

  25. #include <math.h>
    26. 

  26. #define CLASS LibRaw::
    27. 

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

  28. #define LIBRAW_LIBRARY_BUILD
    29. 

  29. #define LIBRAW_IO_REDEFINED
    30. 

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

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

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

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

  34. #line 269 "dcraw/dcraw.c"
    35. 

  35. int CLASS fcol (int row, int col)
    36. 

  36. {
    37. 

  37.   static const char filter[16][16] =
    38. 

  38.   { { 2,1,1,3,2,3,2,0,3,2,3,0,1,2,1,0 },
    39. 

  39.     { 0,3,0,2,0,1,3,1,0,1,1,2,0,3,3,2 },
    40. 

  40.     { 2,3,3,2,3,1,1,3,3,1,2,1,2,0,0,3 },
    41. 

  41.     { 0,1,0,1,0,2,0,2,2,0,3,0,1,3,2,1 },
    42. 

  42.     { 3,1,1,2,0,1,0,2,1,3,1,3,0,1,3,0 },
    43. 

  43.     { 2,0,0,3,3,2,3,1,2,0,2,0,3,2,2,1 },
    44. 

  44.     { 2,3,3,1,2,1,2,1,2,1,1,2,3,0,0,1 },
    45. 

  45.     { 1,0,0,2,3,0,0,3,0,3,0,3,2,1,2,3 },
    46. 

  46.     { 2,3,3,1,1,2,1,0,3,2,3,0,2,3,1,3 },
    47. 

  47.     { 1,0,2,0,3,0,3,2,0,1,1,2,0,1,0,2 },
    48. 

  48.     { 0,1,1,3,3,2,2,1,1,3,3,0,2,1,3,2 },
    49. 

  49.     { 2,3,2,0,0,1,3,0,2,0,1,2,3,0,1,0 },
    50. 

  50.     { 1,3,1,2,3,2,3,2,0,2,0,1,1,0,3,0 },
    51. 

  51.     { 0,2,0,3,1,0,0,1,1,3,3,2,3,2,2,1 },
    52. 

  52.     { 2,1,3,2,3,1,2,1,0,3,0,2,0,2,0,2 },
    53. 

  53.     { 0,3,1,0,0,2,0,3,2,1,3,1,1,3,1,3 } };
    54. 

  54.   static const char filter2[6][6] =
    55. 

  55.   { { 1,1,0,1,1,2 },
    56. 

  56.     { 1,1,2,1,1,0 },
    57. 

  57.     { 2,0,1,0,2,1 },
    58. 

  58.     { 1,1,2,1,1,0 },
    59. 

  59.     { 1,1,0,1,1,2 },
    60. 

  60.     { 0,2,1,2,0,1 } };
    61. 

  61. 

  62.   if (filters == 1) return filter[(row+top_margin)&15][(col+left_margin)&15];
    63. 

  63.   if (filters == 2) return filter2[(row+6) % 6][(col+6) % 6];
    64. 

  64.   return FC(row,col);
    65. 

  65. }
    66. 

  66. 

  67. #ifndef __GLIBC__
    68. 

  68. char *my_memmem (char *haystack, size_t haystacklen,
    69. 

  69. 	      char *needle, size_t needlelen)
    70. 

  70. {
    71. 

  71.   char *c;
    72. 

  72.   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
    73. 

  73.     if (!memcmp (c, needle, needlelen))
    74. 

  74.       return c;
    75. 

  75.   return 0;
    76. 

  76. }
    77. 

  77. #define memmem my_memmem
    78. 

  78. #endif
    79. 

  79. #line 335 "dcraw/dcraw.c"
    80. 

  80. ushort CLASS sget2 (uchar *s)
    81. 

  81. {
    82. 

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

  83.     return s[0] | s[1] << 8;
    84. 

  84.   else				/* "MM" means big-endian */
    85. 

  85.     return s[0] << 8 | s[1];
    86. 

  86. }
    87. 

  87. 

  88. ushort CLASS get2()
    89. 

  89. {
    90. 

  90.   uchar str[2] = { 0xff,0xff };
    91. 

  91.   fread (str, 1, 2, ifp);
    92. 

  92.   return sget2(str);
    93. 

  93. }
    94. 

  94. 

  95. unsigned CLASS sget4 (uchar *s)
    96. 

  96. {
    97. 

  97.   if (order == 0x4949)
    98. 

  98.     return s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
    99. 

  99.   else
    100. 

  100.     return s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3];
    101. 

  101. }
    102. 

  102. #define sget4(s) sget4((uchar *)s)
    103. 

  103. 

  104. unsigned CLASS get4()
    105. 

  105. {
    106. 

  106.   uchar str[4] = { 0xff,0xff,0xff,0xff };
    107. 

  107.   fread (str, 1, 4, ifp);
    108. 

  108.   return sget4(str);
    109. 

  109. }
    110. 

  110. 

  111. unsigned CLASS getint (int type)
    112. 

  112. {
    113. 

  113.   return type == 3 ? get2() : get4();
    114. 

  114. }
    115. 

  115. 

  116. float CLASS int_to_float (int i)
    117. 

  117. {
    118. 

  118.   union { int i; float f; } u;
    119. 

  119.   u.i = i;
    120. 

  120.   return u.f;
    121. 

  121. }
    122. 

  122. 

  123. double CLASS getreal (int type)
    124. 

  124. {
    125. 

  125.   union { char c[8]; double d; } u;
    126. 

  126.   int i, rev;
    127. 

  127. 

  128.   switch (type) {
    129. 

  129.     case 3: return (unsigned short) get2();
    130. 

  130.     case 4: return (unsigned int) get4();
    131. 

  131.     case 5:  u.d = (unsigned int) get4();
    132. 

  132.       return u.d / (unsigned int) get4();
    133. 

  133.     case 8: return (signed short) get2();
    134. 

  134.     case 9: return (signed int) get4();
    135. 

  135.     case 10: u.d = (signed int) get4();
    136. 

  136.       return u.d / (signed int) get4();
    137. 

  137.     case 11: return int_to_float (get4());
    138. 

  138.     case 12:
    139. 

  139.       rev = 7 * ((order == 0x4949) == (ntohs(0x1234) == 0x1234));
    140. 

  140.       for (i=0; i < 8; i++)
    141. 

  141. 	u.c[i ^ rev] = fgetc(ifp);
    142. 

  142.       return u.d;
    143. 

  143.     default: return fgetc(ifp);
    144. 

  144.   }
    145. 

  145. }
    146. 

  146. 

  147. void CLASS read_shorts (ushort *pixel, int count)
    148. 

  148. {
    149. 

  149.   if (fread (pixel, 2, count, ifp) < count) derror();
    150. 

  150.   if ((order == 0x4949) == (ntohs(0x1234) == 0x1234))
    151. 

  151.     swab ((char*)pixel, (char*)pixel, count*2);
    152. 

  152. }
    153. 

  153. 

  154. void CLASS canon_600_fixed_wb (int temp)
    155. 

  155. {
    156. 

  156.   static const short mul[4][5] = {
    157. 

  157.     {  667, 358,397,565,452 },
    158. 

  158.     {  731, 390,367,499,517 },
    159. 

  159.     { 1119, 396,348,448,537 },
    160. 

  160.     { 1399, 485,431,508,688 } };
    161. 

  161.   int lo, hi, i;
    162. 

  162.   float frac=0;
    163. 

  163. 

  164.   for (lo=4; --lo; )
    165. 

  165.     if (*mul[lo] <= temp) break;
    166. 

  166.   for (hi=0; hi < 3; hi++)
    167. 

  167.     if (*mul[hi] >= temp) break;
    168. 

  168.   if (lo != hi)
    169. 

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

  170.   for (i=1; i < 5; i++)
    171. 

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

  172. }
    173. 

  173. 

  174. /* Return values:  0 = white  1 = near white  2 = not white */
    175. 

  175. int CLASS canon_600_color (int ratio[2], int mar)
    176. 

  176. {
    177. 

  177.   int clipped=0, target, miss;
    178. 

  178. 

  179.   if (flash_used) {
    180. 

  180.     if (ratio[1] < -104)
    181. 

  181.       { ratio[1] = -104; clipped = 1; }
    182. 

  182.     if (ratio[1] >   12)
    183. 

  183.       { ratio[1] =   12; clipped = 1; }
    184. 

  184.   } else {
    185. 

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

  186.     if (ratio[1] < -50)
    187. 

  187.       { ratio[1] = -50; clipped = 1; }
    188. 

  188.     if (ratio[1] > 307)
    189. 

  189.       { ratio[1] = 307; clipped = 1; }
    190. 

  190.   }
    191. 

  191.   target = flash_used || ratio[1] < 197
    192. 

  192. 	? -38 - (398 * ratio[1] >> 10)
    193. 

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

  194.   if (target - mar <= ratio[0] &&
    195. 

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

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

  197.   if (abs(miss) >= mar*4) return 2;
    198. 

  198.   if (miss < -20) miss = -20;
    199. 

  199.   if (miss > mar) miss = mar;
    200. 

  200.   ratio[0] = target - miss;
    201. 

  201.   return 1;
    202. 

  202. }
    203. 

  203. 

  204. void CLASS canon_600_auto_wb()
    205. 

  205. {
    206. 

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

  207.   int test[8], total[2][8], ratio[2][2], stat[2];
    208. 

  208. 

  209.   memset (&total, 0, sizeof total);
    210. 

  210.   i = canon_ev + 0.5;
    211. 

  211.   if      (i < 10) mar = 150;
    212. 

  212.   else if (i > 12) mar = 20;
    213. 

  213.   else mar = 280 - 20 * i;
    214. 

  214.   if (flash_used) mar = 80;
    215. 

  215.   for (row=14; row < height-14; row+=4)
    216. 

  216.     for (col=10; col < width; col+=2) {
    217. 

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

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

  219. 		    BAYER(row+(i >> 1),col+(i & 1));
    220. 

  220.       for (i=0; i < 8; i++)
    221. 

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

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

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

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

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

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

  227. 	stat[i] = canon_600_color (ratio[i], mar);
    228. 

  228.       }
    229. 

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

  230.       for (i=0; i < 2; i++)
    231. 

  231. 	if (stat[i])
    232. 

  232. 	  for (j=0; j < 2; j++)
    233. 

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

  234.       for (i=0; i < 8; i++)
    235. 

  235. 	total[st][i] += test[i];
    236. 

  236.       count[st]++;
    237. 

  237. next: ;
    238. 

  238.     }
    239. 

  239.   if (count[0] | count[1]) {
    240. 

  240.     st = count[0]*200 < count[1];
    241. 

  241.     for (i=0; i < 4; i++)
    242. 

  242.       pre_mul[i] = 1.0 / (total[st][i] + total[st][i+4]);
    243. 

  243.   }
    244. 

  244. }
    245. 

  245. 

  246. void CLASS canon_600_coeff()
    247. 

  247. {
    248. 

  248.   static const short table[6][12] = {
    249. 

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

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

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

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

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

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

  255.   int t=0, i, c;
    256. 

  256.   float mc, yc;
    257. 

  257. 

  258.   mc = pre_mul[1] / pre_mul[2];
    259. 

  259.   yc = pre_mul[3] / pre_mul[2];
    260. 

  260.   if (mc > 1 && mc <= 1.28 && yc < 0.8789) t=1;
    261. 

  261.   if (mc > 1.28 && mc <= 2) {
    262. 

  262.     if  (yc < 0.8789) t=3;
    263. 

  263.     else if (yc <= 2) t=4;
    264. 

  264.   }
    265. 

  265.   if (flash_used) t=5;
    266. 

  266.   for (raw_color = i=0; i < 3; i++)
    267. 

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

  268. }
    269. 

  269. 

  270. void CLASS canon_600_load_raw()
    271. 

  271. {
    272. 

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

  273.   ushort *pix;
    274. 

  274.   int irow, row;
    275. 

  275. 

  276.   for (irow=row=0; irow < height; irow++) {
    277. 

  277.     if (fread (data, 1, 1120, ifp) < 1120) derror();
    278. 

  278.     pix = raw_image + row*raw_width;
    279. 

  279.     for (dp=data; dp < data+1120;  dp+=10, pix+=8) {
    280. 

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

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

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

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

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

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

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

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

  288.     }
    289. 

  289.     if ((row+=2) > height) row = 1;
    290. 

  290.   }
    291. 

  291. }
    292. 

  292. 

  293. void CLASS canon_600_correct()
    294. 

  294. {
    295. 

  295.   int row, col, val;
    296. 

  296.   static const short mul[4][2] =
    297. 

  297.   { { 1141,1145 }, { 1128,1109 }, { 1178,1149 }, { 1128,1109 } };
    298. 

  298. 

  299.   for (row=0; row < height; row++)
    300. 

  300.     for (col=0; col < width; col++) {
    301. 

  301.       if ((val = BAYER(row,col) - black) < 0) val = 0;
    302. 

  302.       val = val * mul[row & 3][col & 1] >> 9;
    303. 

  303.       BAYER(row,col) = val;
    304. 

  304.     }
    305. 

  305.   canon_600_fixed_wb(1311);
    306. 

  306.   canon_600_auto_wb();
    307. 

  307.   canon_600_coeff();
    308. 

  308.   maximum = (0x3ff - black) * 1109 >> 9;
    309. 

  309.   black = 0;
    310. 

  310. }
    311. 

  311. 

  312. int CLASS canon_s2is()
    313. 

  313. {
    314. 

  314.   unsigned row;
    315. 

  315. 

  316.   for (row=0; row < 100; row++) {
    317. 

  317.     fseek (ifp, row*3340 + 3284, SEEK_SET);
    318. 

  318.     if (getc(ifp) > 15) return 1;
    319. 

  319.   }
    320. 

  320.   return 0;
    321. 

  321. }
    322. 

  322. 

  323. /*
    324. 

  324.    getbits(-1) initializes the buffer
    325. 

  325.    getbits(n) where 0 <= n <= 25 returns an n-bit integer
    326. 

  326.  */
    327. 

  327. unsigned CLASS getbithuff (int nbits, ushort *huff)
    328. 

  328. {
    329. 

  329. #ifdef LIBRAW_NOTHREADS
    330. 

  330.   static unsigned bitbuf=0;
    331. 

  331.   static int vbits=0, reset=0;
    332. 

  332. #else
    333. 

  333. #define bitbuf tls->getbits.bitbuf
    334. 

  334. #define vbits  tls->getbits.vbits
    335. 

  335. #define reset  tls->getbits.reset
    336. 

  336. #endif
    337. 

  337.   unsigned c;
    338. 

  338. 

  339.   if (nbits == -1)
    340. 

  340.     return bitbuf = vbits = reset = 0;
    341. 

  341.   if (nbits == 0 || vbits < 0) return 0;
    342. 

  342.   while (!reset && vbits < nbits && (c = fgetc(ifp)) != EOF &&
    343. 

  343.     !(reset = zero_after_ff && c == 0xff && fgetc(ifp))) {
    344. 

  344.     bitbuf = (bitbuf << 8) + (uchar) c;
    345. 

  345.     vbits += 8;
    346. 

  346.   }
    347. 

  347.   c = bitbuf << (32-vbits) >> (32-nbits);
    348. 

  348.   if (huff) {
    349. 

  349.     vbits -= huff[c] >> 8;
    350. 

  350.     c = (uchar) huff[c];
    351. 

  351.   } else
    352. 

  352.     vbits -= nbits;
    353. 

  353.   if (vbits < 0) derror();
    354. 

  354.   return c;
    355. 

  355. #ifndef LIBRAW_NOTHREADS
    356. 

  356. #undef bitbuf
    357. 

  357. #undef vbits
    358. 

  358. #undef reset
    359. 

  359. #endif
    360. 

  360. }
    361. 

  361. 

  362. #define getbits(n) getbithuff(n,0)
    363. 

  363. #define gethuff(h) getbithuff(*h,h+1)
    364. 

  364. 

  365. /*
    366. 

  366.    Construct a decode tree according the specification in *source.
    367. 

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

  368.    3-bit, etc.  Bytes after that are the leaf values.
    369. 

    370. 

  370.    For example, if the source is
    371. 

    372. 

  372.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    373. 

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

    375. 

  375.    then the code is
    376. 

    377. 

  377. 	00		0x04
    378. 

  378. 	010		0x03
    379. 

  379. 	011		0x05
    380. 

  380. 	100		0x06
    381. 

  381. 	101		0x02
    382. 

  382. 	1100		0x07
    383. 

  383. 	1101		0x01
    384. 

  384. 	11100		0x08
    385. 

  385. 	11101		0x09
    386. 

  386. 	11110		0x00
    387. 

  387. 	111110		0x0a
    388. 

  388. 	1111110		0x0b
    389. 

  389. 	1111111		0xff
    390. 

  390.  */
    391. 

  391. ushort * CLASS make_decoder_ref (const uchar **source)
    392. 

  392. {
    393. 

  393.   int max, len, h, i, j;
    394. 

  394.   const uchar *count;
    395. 

  395.   ushort *huff;
    396. 

  396. 

  397.   count = (*source += 16) - 17;
    398. 

  398.   for (max=16; max && !count[max]; max--);
    399. 

  399.   huff = (ushort *) calloc (1 + (1 << max), sizeof *huff);
    400. 

  400.   merror (huff, "make_decoder()");
    401. 

  401.   huff[0] = max;
    402. 

  402.   for (h=len=1; len <= max; len++)
    403. 

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

  404.       for (j=0; j < 1 << (max-len); j++)
    405. 

  405. 	if (h <= 1 << max)
    406. 

  406. 	  huff[h++] = len << 8 | **source;
    407. 

  407.   return huff;
    408. 

  408. }
    409. 

  409. 

  410. ushort * CLASS make_decoder (const uchar *source)
    411. 

  411. {
    412. 

  412.   return make_decoder_ref (&source);
    413. 

  413. }
    414. 

  414. 

  415. void CLASS crw_init_tables (unsigned table, ushort *huff[2])
    416. 

  416. {
    417. 

  417.   static const uchar first_tree[3][29] = {
    418. 

  418.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    419. 

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

  420.     { 0,2,2,3,1,1,1,1,2,0,0,0,0,0,0,0,
    421. 

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

  422.     { 0,0,6,3,1,1,2,0,0,0,0,0,0,0,0,0,
    423. 

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

  424.   };
    425. 

  425.   static const uchar second_tree[3][180] = {
    426. 

  426.     { 0,2,2,2,1,4,2,1,2,5,1,1,0,0,0,139,
    427. 

  427.       0x03,0x04,0x02,0x05,0x01,0x06,0x07,0x08,
    428. 

  428.       0x12,0x13,0x11,0x14,0x09,0x15,0x22,0x00,0x21,0x16,0x0a,0xf0,
    429. 

  429.       0x23,0x17,0x24,0x31,0x32,0x18,0x19,0x33,0x25,0x41,0x34,0x42,
    430. 

  430.       0x35,0x51,0x36,0x37,0x38,0x29,0x79,0x26,0x1a,0x39,0x56,0x57,
    431. 

  431.       0x28,0x27,0x52,0x55,0x58,0x43,0x76,0x59,0x77,0x54,0x61,0xf9,
    432. 

  432.       0x71,0x78,0x75,0x96,0x97,0x49,0xb7,0x53,0xd7,0x74,0xb6,0x98,
    433. 

  433.       0x47,0x48,0x95,0x69,0x99,0x91,0xfa,0xb8,0x68,0xb5,0xb9,0xd6,
    434. 

  434.       0xf7,0xd8,0x67,0x46,0x45,0x94,0x89,0xf8,0x81,0xd5,0xf6,0xb4,
    435. 

  435.       0x88,0xb1,0x2a,0x44,0x72,0xd9,0x87,0x66,0xd4,0xf5,0x3a,0xa7,
    436. 

  436.       0x73,0xa9,0xa8,0x86,0x62,0xc7,0x65,0xc8,0xc9,0xa1,0xf4,0xd1,
    437. 

  437.       0xe9,0x5a,0x92,0x85,0xa6,0xe7,0x93,0xe8,0xc1,0xc6,0x7a,0x64,
    438. 

  438.       0xe1,0x4a,0x6a,0xe6,0xb3,0xf1,0xd3,0xa5,0x8a,0xb2,0x9a,0xba,
    439. 

  439.       0x84,0xa4,0x63,0xe5,0xc5,0xf3,0xd2,0xc4,0x82,0xaa,0xda,0xe4,
    440. 

  440.       0xf2,0xca,0x83,0xa3,0xa2,0xc3,0xea,0xc2,0xe2,0xe3,0xff,0xff  },
    441. 

  441.     { 0,2,2,1,4,1,4,1,3,3,1,0,0,0,0,140,
    442. 

  442.       0x02,0x03,0x01,0x04,0x05,0x12,0x11,0x06,
    443. 

  443.       0x13,0x07,0x08,0x14,0x22,0x09,0x21,0x00,0x23,0x15,0x31,0x32,
    444. 

  444.       0x0a,0x16,0xf0,0x24,0x33,0x41,0x42,0x19,0x17,0x25,0x18,0x51,
    445. 

  445.       0x34,0x43,0x52,0x29,0x35,0x61,0x39,0x71,0x62,0x36,0x53,0x26,
    446. 

  446.       0x38,0x1a,0x37,0x81,0x27,0x91,0x79,0x55,0x45,0x28,0x72,0x59,
    447. 

  447.       0xa1,0xb1,0x44,0x69,0x54,0x58,0xd1,0xfa,0x57,0xe1,0xf1,0xb9,
    448. 

  448.       0x49,0x47,0x63,0x6a,0xf9,0x56,0x46,0xa8,0x2a,0x4a,0x78,0x99,
    449. 

  449.       0x3a,0x75,0x74,0x86,0x65,0xc1,0x76,0xb6,0x96,0xd6,0x89,0x85,
    450. 

  450.       0xc9,0xf5,0x95,0xb4,0xc7,0xf7,0x8a,0x97,0xb8,0x73,0xb7,0xd8,
    451. 

  451.       0xd9,0x87,0xa7,0x7a,0x48,0x82,0x84,0xea,0xf4,0xa6,0xc5,0x5a,
    452. 

  452.       0x94,0xa4,0xc6,0x92,0xc3,0x68,0xb5,0xc8,0xe4,0xe5,0xe6,0xe9,
    453. 

  453.       0xa2,0xa3,0xe3,0xc2,0x66,0x67,0x93,0xaa,0xd4,0xd5,0xe7,0xf8,
    454. 

  454.       0x88,0x9a,0xd7,0x77,0xc4,0x64,0xe2,0x98,0xa5,0xca,0xda,0xe8,
    455. 

  455.       0xf3,0xf6,0xa9,0xb2,0xb3,0xf2,0xd2,0x83,0xba,0xd3,0xff,0xff  },
    456. 

  456.     { 0,0,6,2,1,3,3,2,5,1,2,2,8,10,0,117,
    457. 

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

  458.       0x09,0x12,0x13,0x14,0x11,0x15,0x0a,0x16,0x17,0xf0,0x00,0x22,
    459. 

  459.       0x21,0x18,0x23,0x19,0x24,0x32,0x31,0x25,0x33,0x38,0x37,0x34,
    460. 

  460.       0x35,0x36,0x39,0x79,0x57,0x58,0x59,0x28,0x56,0x78,0x27,0x41,
    461. 

  461.       0x29,0x77,0x26,0x42,0x76,0x99,0x1a,0x55,0x98,0x97,0xf9,0x48,
    462. 

  462.       0x54,0x96,0x89,0x47,0xb7,0x49,0xfa,0x75,0x68,0xb6,0x67,0x69,
    463. 

  463.       0xb9,0xb8,0xd8,0x52,0xd7,0x88,0xb5,0x74,0x51,0x46,0xd9,0xf8,
    464. 

  464.       0x3a,0xd6,0x87,0x45,0x7a,0x95,0xd5,0xf6,0x86,0xb4,0xa9,0x94,
    465. 

  465.       0x53,0x2a,0xa8,0x43,0xf5,0xf7,0xd4,0x66,0xa7,0x5a,0x44,0x8a,
    466. 

  466.       0xc9,0xe8,0xc8,0xe7,0x9a,0x6a,0x73,0x4a,0x61,0xc7,0xf4,0xc6,
    467. 

  467.       0x65,0xe9,0x72,0xe6,0x71,0x91,0x93,0xa6,0xda,0x92,0x85,0x62,
    468. 

  468.       0xf3,0xc5,0xb2,0xa4,0x84,0xba,0x64,0xa5,0xb3,0xd2,0x81,0xe5,
    469. 

  469.       0xd3,0xaa,0xc4,0xca,0xf2,0xb1,0xe4,0xd1,0x83,0x63,0xea,0xc3,
    470. 

  470.       0xe2,0x82,0xf1,0xa3,0xc2,0xa1,0xc1,0xe3,0xa2,0xe1,0xff,0xff  }
    471. 

  471.   };
    472. 

  472.   if (table > 2) table = 2;
    473. 

  473.   huff[0] = make_decoder ( first_tree[table]);
    474. 

  474.   huff[1] = make_decoder (second_tree[table]);
    475. 

  475. }
    476. 

  476. 

  477. /*
    478. 

  478.    Return 0 if the image starts with compressed data,
    479. 

  479.    1 if it starts with uncompressed low-order bits.
    480. 

    481. 

  481.    In Canon compressed data, 0xff is always followed by 0x00.
    482. 

  482.  */
    483. 

  483. int CLASS canon_has_lowbits()
    484. 

  484. {
    485. 

  485.   uchar test[0x4000];
    486. 

  486.   int ret=1, i;
    487. 

  487. 

  488.   fseek (ifp, 0, SEEK_SET);
    489. 

  489.   fread (test, 1, sizeof test, ifp);
    490. 

  490.   for (i=540; i < sizeof test - 1; i++)
    491. 

  491.     if (test[i] == 0xff) {
    492. 

  492.       if (test[i+1]) return 1;
    493. 

  493.       ret=0;
    494. 

  494.     }
    495. 

  495.   return ret;
    496. 

  496. }
    497. 

  497. 

  498. void CLASS canon_load_raw()
    499. 

  499. {
    500. 

  500.   ushort *pixel, *prow, *huff[2];
    501. 

  501.   int nblocks, lowbits, i, c, row, r, save, val;
    502. 

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

  503. 

  504.   crw_init_tables (tiff_compress, huff);
    505. 

  505.   lowbits = canon_has_lowbits();
    506. 

  506.   if (!lowbits) maximum = 0x3ff;
    507. 

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

  508.   zero_after_ff = 1;
    509. 

  509.   getbits(-1);
    510. 

  510.   for (row=0; row < raw_height; row+=8) {
    511. 

  511.     pixel = raw_image + row*raw_width;
    512. 

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

  513.     for (block=0; block < nblocks; block++) {
    514. 

  514.       memset (diffbuf, 0, sizeof diffbuf);
    515. 

  515.       for (i=0; i < 64; i++ ) {
    516. 

  516. 	leaf = gethuff(huff[i > 0]);
    517. 

  517. 	if (leaf == 0 && i) break;
    518. 

  518. 	if (leaf == 0xff) continue;
    519. 

  519. 	i  += leaf >> 4;
    520. 

  520. 	len = leaf & 15;
    521. 

  521. 	if (len == 0) continue;
    522. 

  522. 	diff = getbits(len);
    523. 

  523. 	if ((diff & (1 << (len-1))) == 0)
    524. 

  524. 	  diff -= (1 << len) - 1;
    525. 

  525. 	if (i < 64) diffbuf[i] = diff;
    526. 

  526.       }
    527. 

  527.       diffbuf[0] += carry;
    528. 

  528.       carry = diffbuf[0];
    529. 

  529.       for (i=0; i < 64; i++ ) {
    530. 

  530. 	if (pnum++ % raw_width == 0)
    531. 

  531. 	  base[0] = base[1] = 512;
    532. 

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

  533. 	  derror();
    534. 

  534.       }
    535. 

  535.     }
    536. 

  536.     if (lowbits) {
    537. 

  537.       save = ftell(ifp);
    538. 

  538.       fseek (ifp, 26 + row*raw_width/4, SEEK_SET);
    539. 

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

  540. 	c = fgetc(ifp);
    541. 

  541. 	for (r=0; r < 8; r+=2, prow++) {
    542. 

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

  543. 	  if (raw_width == 2672 && val < 512) val += 2;
    544. 

  544. 	  *prow = val;
    545. 

  545. 	}
    546. 

  546.       }
    547. 

  547.       fseek (ifp, save, SEEK_SET);
    548. 

  548.     }
    549. 

  549.   }
    550. 

  550.   FORC(2) free (huff[c]);
    551. 

  551. }
    552. 

  552. #line 819 "dcraw/dcraw.c"
    553. 

  553. int CLASS ljpeg_start (struct jhead *jh, int info_only)
    554. 

  554. {
    555. 

  555.   int c, tag, len;
    556. 

  556.   uchar data[0x10000];
    557. 

  557.   const uchar *dp;
    558. 

  558. 

  559.   memset (jh, 0, sizeof *jh);
    560. 

  560.   jh->restart = INT_MAX;
    561. 

  561.   fread (data, 2, 1, ifp);
    562. 

  562.   if (data[1] != 0xd8) return 0;
    563. 

  563.   do {
    564. 

  564.     fread (data, 2, 2, ifp);
    565. 

  565.     tag =  data[0] << 8 | data[1];
    566. 

  566.     len = (data[2] << 8 | data[3]) - 2;
    567. 

  567.     if (tag <= 0xff00) return 0;
    568. 

  568.     fread (data, 1, len, ifp);
    569. 

  569.     switch (tag) {
    570. 

  570.       case 0xffc3:
    571. 

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

  572.       case 0xffc0:
    573. 

  573. 	jh->bits = data[0];
    574. 

  574. 	jh->high = data[1] << 8 | data[2];
    575. 

  575. 	jh->wide = data[3] << 8 | data[4];
    576. 

  576. 	jh->clrs = data[5] + jh->sraw;
    577. 

  577. 	if (len == 9 && !dng_version) getc(ifp);
    578. 

  578. 	break;
    579. 

  579.       case 0xffc4:
    580. 

  580. 	if (info_only) break;
    581. 

  581. 	for (dp = data; dp < data+len && (c = *dp++) < 4; )
    582. 

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

  583. 	break;
    584. 

  584.       case 0xffda:
    585. 

  585. 	jh->psv = data[1+data[0]*2];
    586. 

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

  587. 	break;
    588. 

  588.       case 0xffdd:
    589. 

  589. 	jh->restart = data[0] << 8 | data[1];
    590. 

  590.     }
    591. 

  591.   } while (tag != 0xffda);
    592. 

  592.   if (info_only) return 1;
    593. 

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

  594.   if (jh->sraw) {
    595. 

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

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

  597.   }
    598. 

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

  599.   merror (jh->row, "ljpeg_start()");
    600. 

  600.   return zero_after_ff = 1;
    601. 

  601. }
    602. 

  602. 

  603. void CLASS ljpeg_end (struct jhead *jh)
    604. 

  604. {
    605. 

  605.   int c;
    606. 

  606.   FORC4 if (jh->free[c]) free (jh->free[c]);
    607. 

  607.   free (jh->row);
    608. 

  608. }
    609. 

  609. 

  610. int CLASS ljpeg_diff (ushort *huff)
    611. 

  611. {
    612. 

  612.   int len, diff;
    613. 

  613. 

  614.   len = gethuff(huff);
    615. 

  615.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    616. 

  616.     return -32768;
    617. 

  617.   diff = getbits(len);
    618. 

  618.   if ((diff & (1 << (len-1))) == 0)
    619. 

  619.     diff -= (1 << len) - 1;
    620. 

  620.   return diff;
    621. 

  621. }
    622. 

  622. 

  623. #ifdef LIBRAW_LIBRARY_BUILD
    624. 

  624. int CLASS ljpeg_diff_new (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    625. 

  625. {
    626. 

  626.   int len, diff;
    627. 

  627. 

  628.   len = bits._gethuff_lj(buf,*huff,huff+1);
    629. 

  629.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    630. 

  630.     return -32768;
    631. 

  631.   diff = bits._getbits_lj(buf,len);
    632. 

  632.   if ((diff & (1 << (len-1))) == 0)
    633. 

  633.     diff -= (1 << len) - 1;
    634. 

  634.   return diff;
    635. 

  635. }
    636. 

  636. 

  637. int CLASS ljpeg_diff_pef (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    638. 

  638. {
    639. 

  639.   int len, diff;
    640. 

  640. 

  641.   len = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    642. 

  642.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    643. 

  643.     return -32768;
    644. 

  644.   diff = bits._getbits(buf,len,zero_after_ff);
    645. 

  645.   if ((diff & (1 << (len-1))) == 0)
    646. 

  646.     diff -= (1 << len) - 1;
    647. 

  647.   return diff;
    648. 

  648. }
    649. 

  649. 

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

  651. {
    652. 

  652.   int col, c, diff, pred, spred=0;
    653. 

  653.   ushort mark=0, *row[3];
    654. 

  654. 

  655.   if (jrow * jh->wide % jh->restart == 0) {
    656. 

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

  657.     if (jrow) {
    658. 

  658.         bytes->unseek2();
    659. 

  659.         do mark = (mark << 8) + (c = bytes->get_byte());
    660. 

  660.         while (c != EOF && mark >> 4 != 0xffd);
    661. 

  661.     }
    662. 

  662.     bits.reset();
    663. 

  663.   }
    664. 

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

  665.   for (col=0; col < jh->wide; col++)
    666. 

  666.     FORC(jh->clrs) {
    667. 

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

  668.       if (jh->sraw && c <= jh->sraw && (col | c))
    669. 

  669. 		    pred = spred;
    670. 

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

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

  672.       if (jrow && col) switch (jh->psv) {
    673. 

  673. 	case 1:	break;
    674. 

  674. 	case 2: pred = row[1][0];					break;
    675. 

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

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

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

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

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

  680. 	default: pred = 0;
    681. 

  681.       }
    682. 

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

  683.       if (c <= jh->sraw) spred = **row;
    684. 

  684.       row[0]++; row[1]++;
    685. 

  685.     }
    686. 

  686.   return row[2];
    687. 

  687. }
    688. 

  688. 

  689. #endif
    690. 

  690. 

  691. 

  692. ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
    693. 

  693. {
    694. 

  694.   int col, c, diff, pred, spred=0;
    695. 

  695.   ushort mark=0, *row[3];
    696. 

  696. 

  697.   if (jrow * jh->wide % jh->restart == 0) {
    698. 

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

  699.     if (jrow) {
    700. 

  700.       fseek (ifp, -2, SEEK_CUR);
    701. 

  701.       do mark = (mark << 8) + (c = fgetc(ifp));
    702. 

  702.       while (c != EOF && mark >> 4 != 0xffd);
    703. 

  703.     }
    704. 

  704.     getbits(-1);
    705. 

  705.   }
    706. 

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

  707.   for (col=0; col < jh->wide; col++)
    708. 

  708.     FORC(jh->clrs) {
    709. 

  709.       diff = ljpeg_diff (jh->huff[c]);
    710. 

  710.       if (jh->sraw && c <= jh->sraw && (col | c))
    711. 

  711. 		    pred = spred;
    712. 

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

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

  714.       if (jrow && col) switch (jh->psv) {
    715. 

  715. 	case 1:	break;
    716. 

  716. 	case 2: pred = row[1][0];					break;
    717. 

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

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

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

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

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

  722. 	default: pred = 0;
    723. 

  723.       }
    724. 

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

  725.       if (c <= jh->sraw) spred = **row;
    726. 

  726.       row[0]++; row[1]++;
    727. 

  727.     }
    728. 

  728.   return row[2];
    729. 

  729. }
    730. 

  730. 

  731. void CLASS lossless_jpeg_load_raw()
    732. 

  732. {
    733. 

  733.   int jwide, jrow, jcol, val, i, row=0, col=0;
    734. 

  734. #ifndef LIBRAW_LIBRARY_BUILD
    735. 

  735.   int jidx,j;
    736. 

  736. #endif
    737. 

  737.   struct jhead jh;
    738. 

  738.   ushort *rp;
    739. 

  739. 

  740. #ifdef LIBRAW_LIBRARY_BUILD
    741. 

  741.   int save_min = 0;
    742. 

  742.   unsigned slicesW[16],slicesWcnt=0,slices;
    743. 

  743.   unsigned *offset;
    744. 

  744.   unsigned t_y=0,t_x=0,t_s=0,slice=0,pixelsInSlice,pixno;
    745. 

  745.   if (!strcasecmp(make,"KODAK"))
    746. 

  746.       save_min = 1;
    747. 

  747. #endif
    748. 

  748. 

  749. #ifdef LIBRAW_LIBRARY_BUILD
    750. 

  750.   if (cr2_slice[0]>15)
    751. 

  751.       throw LIBRAW_EXCEPTION_IO_EOF; // change many slices
    752. 

  752. #else
    753. 

  753.   if (cr2_slice[0]>15)
    754. 

  754.   {
    755. 

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

  756.       return;
    757. 

  757.   }
    758. 

  758. #endif
    759. 

  759. 

  760. 

  761.   if (!ljpeg_start (&jh, 0)) return;
    762. 

  762.   jwide = jh.wide * jh.clrs;
    763. 

  763. 

  764. #ifdef LIBRAW_LIBRARY_BUILD
    765. 

  765.   if(cr2_slice[0])
    766. 

  766.       {
    767. 

  767.           for(i=0;i<cr2_slice[0];i++)
    768. 

  768.               slicesW[slicesWcnt++] = cr2_slice[1];
    769. 

  769.           slicesW[slicesWcnt++] = cr2_slice[2];
    770. 

  770.       }
    771. 

  771.   else
    772. 

  772.       {
    773. 

  773.           // not sliced
    774. 

  774.           slicesW[slicesWcnt++] = raw_width; // safe fallback
    775. 

  775.       }
    776. 

  776.        
    777. 

  777.   slices = slicesWcnt * jh.high;
    778. 

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

  779. 

  780.   for(slice=0;slice<slices;slice++)
    781. 

  781.       {
    782. 

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

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

  784.               throw LIBRAW_EXCEPTION_IO_BADFILE; 
    785. 

  785.           t_y++;
    786. 

  786.           if(t_y == jh.high)
    787. 

  787.               {
    788. 

  788.                   t_y = 0;
    789. 

  789.                   t_x += slicesW[t_s++];
    790. 

  790.               }
    791. 

  791.       }
    792. 

  792.   offset[slices] = offset[slices-1];
    793. 

  793.   slice = 1; // next slice
    794. 

  794.   pixno = offset[0]; 
    795. 

  795.   pixelsInSlice = slicesW[0];
    796. 

  796. #endif
    797. 

  797. 

  798. #ifdef LIBRAW_LIBRARY_BUILD
    799. 

  799.   LibRaw_byte_buffer *buf=NULL;
    800. 

  800.   if(data_size)
    801. 

  801.       buf = ifp->make_byte_buffer(data_size);
    802. 

  802.   LibRaw_bit_buffer bits;
    803. 

  803. #endif
    804. 

  804. 

  805.   for (jrow=0; jrow < jh.high; jrow++) {
    806. 

  806. #ifdef LIBRAW_LIBRARY_BUILD
    807. 

  807.       if (buf)
    808. 

  808.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    809. 

  809.       else
    810. 

  810. #endif
    811. 

  811.     rp = ljpeg_row (jrow, &jh);
    812. 

  812.     if (load_flags & 1)
    813. 

  813.       row = jrow & 1 ? height-1-jrow/2 : jrow/2;
    814. 

  814.     for (jcol=0; jcol < jwide; jcol++) {
    815. 

  815.       val = curve[*rp++];
    816. 

  816. #ifndef LIBRAW_LIBRARY_BUILD
    817. 

  817.       // slow dcraw way to calculate row/col
    818. 

  818.       if (cr2_slice[0]) {
    819. 

  819. 	jidx = jrow*jwide + jcol;
    820. 

  820. 	i = jidx / (cr2_slice[1]*jh.high);
    821. 

  821. 	if ((j = i >= cr2_slice[0]))
    822. 

  822. 		 i  = cr2_slice[0];
    823. 

  823. 	jidx -= i * (cr2_slice[1]*jh.high);
    824. 

  824. 	row = jidx / cr2_slice[1+j];
    825. 

  825. 	col = jidx % cr2_slice[1+j] + i*cr2_slice[1];
    826. 

  826.       }
    827. 

  827. #else
    828. 

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

  829.       if(buf) 
    830. 

  830.           {
    831. 

  831.               if(!(load_flags & 1))
    832. 

  832.                   row = pixno/raw_width;
    833. 

  833.               col = pixno % raw_width;
    834. 

  834.               pixno++;
    835. 

  835.               if (0 == --pixelsInSlice)
    836. 

  836.                   {
    837. 

  837.                       unsigned o = offset[slice++];
    838. 

  838.                       pixno = o & 0x0fffffff;
    839. 

  839.                       pixelsInSlice = slicesW[o>>28];
    840. 

  840.                   }
    841. 

  841.           }
    842. 

  842. #endif
    843. 

  843.       if (raw_width == 3984 && (col -= 2) < 0)
    844. 

  844. 	col += (row--,raw_width);
    845. 

  845.       if (row >= 0) RAW(row,col) = val;
    846. 

  846. #ifndef LIBRAW_LIBRARY_BUILD
    847. 

  847.       if (++col >= raw_width)
    848. 

  848. 	col = (row++,0);
    849. 

  849. #else
    850. 

  850.       if(!buf) // 1D or 1Ds case
    851. 

  851.          if (++col >= raw_width)
    852. 

  852.             col = (row++,0);
    853. 

  853. #endif
    854. 

  854.     }
    855. 

  855.   }
    856. 

  856.   ljpeg_end (&jh);
    857. 

  857. #ifdef LIBRAW_LIBRARY_BUILD
    858. 

  858.   if(buf)
    859. 

  859.       delete buf;
    860. 

  860.   free(offset);
    861. 

  861. #endif
    862. 

  862. }
    863. 

  863. 

  864. void CLASS canon_sraw_load_raw()
    865. 

  865. {
    866. 

  866.   struct jhead jh;
    867. 

  867.   short *rp=0, (*ip)[4];
    868. 

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

  869.   int v[3]={0,0,0}, ver, hue;
    870. 

  870.   char *cp;
    871. 

  871. 

  872.   if (!ljpeg_start (&jh, 0)) return;
    873. 

  873.   jwide = (jh.wide >>= 1) * jh.clrs;
    874. 

  874. 

  875. #ifdef LIBRAW_LIBRARY_BUILD
    876. 

  876.   if(!data_size)
    877. 

  877.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    878. 

  878.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    879. 

  879.   LibRaw_bit_buffer bits;
    880. 

  880. #endif
    881. 

  881. 

  882.   for (ecol=slice=0; slice <= cr2_slice[0]; slice++) {
    883. 

  883.     scol = ecol;
    884. 

  884.     ecol += cr2_slice[1] * 2 / jh.clrs;
    885. 

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

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

  887.       ip = (short (*)[4]) image + row*width;
    888. 

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

  889. 	if ((jcol %= jwide) == 0)
    890. 

  890. #ifdef LIBRAW_LIBRARY_BUILD
    891. 

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

  892. #else
    893. 

  893.             rp = (short *) ljpeg_row (jrow++, &jh);
    894. 

  894. #endif
    895. 

  895. 	if (col >= width) continue;
    896. 

  896. 	FORC (jh.clrs-2)
    897. 

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

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

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

  900.       }
    901. 

  901.     }
    902. 

  902.   }
    903. 

  903.   for (cp=model2; *cp && !isdigit(*cp); cp++);
    904. 

  904.   sscanf (cp, "%d.%d.%d", v, v+1, v+2);
    905. 

  905.   ver = (v[0]*1000 + v[1])*1000 + v[2];
    906. 

  906.   hue = (jh.sraw+1) << 2;
    907. 

  907.   if (unique_id >= 0x80000281 || (unique_id == 0x80000218 && ver > 1000006))
    908. 

  908.     hue = jh.sraw << 1;
    909. 

  909.   ip = (short (*)[4]) image;
    910. 

  910.   rp = ip[0];
    911. 

  911.   for (row=0; row < height; row++, ip+=width) {
    912. 

  912.     if (row & (jh.sraw >> 1))
    913. 

  913.       for (col=0; col < width; col+=2)
    914. 

  914. 	for (c=1; c < 3; c++)
    915. 

  915. 	  if (row == height-1)
    916. 

  916. 	       ip[col][c] =  ip[col-width][c];
    917. 

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

  918.     for (col=1; col < width; col+=2)
    919. 

  919.       for (c=1; c < 3; c++)
    920. 

  920. 	if (col == width-1)
    921. 

  921. 	     ip[col][c] =  ip[col-1][c];
    922. 

  922. 	else ip[col][c] = (ip[col-1][c] + ip[col+1][c] + 1) >> 1;
    923. 

  923.   }
    924. 

  924.   for ( ; rp < ip[0]; rp+=4) {
    925. 

  925.     if (unique_id == 0x80000218 ||
    926. 

  926. 	unique_id == 0x80000250 ||
    927. 

  927. 	unique_id == 0x80000261 ||
    928. 

  928. 	unique_id == 0x80000281 ||
    929. 

  929. 	unique_id == 0x80000287) {
    930. 

  930.       rp[1] = (rp[1] << 2) + hue;
    931. 

  931.       rp[2] = (rp[2] << 2) + hue;
    932. 

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

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

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

  935.     } else {
    936. 

  936.       if (unique_id < 0x80000218) rp[0] -= 512;
    937. 

  937.       pix[0] = rp[0] + rp[2];
    938. 

  938.       pix[2] = rp[0] + rp[1];
    939. 

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

  940.     }
    941. 

  941.     FORC3 rp[c] = CLIP(pix[c] * sraw_mul[c] >> 10);
    942. 

  942.   }
    943. 

  943. #ifdef LIBRAW_LIBRARY_BUILD
    944. 

  944.   delete buf;
    945. 

  945. #endif
    946. 

  946.   ljpeg_end (&jh);
    947. 

  947.   maximum = 0x3fff;
    948. 

  948. }
    949. 

  949. 

  950. #ifndef LIBRAW_LIBRARY_BUILD
    951. 

  951. void CLASS adobe_copy_pixel (unsigned row, unsigned col, ushort **rp)
    952. 

  952. {
    953. 

  953.   int c;
    954. 

  954. 

  955.   if (is_raw == 2 && shot_select) (*rp)++;
    956. 

  956.   if (raw_image) {
    957. 

  957.     if (row < raw_height && col < raw_width)
    958. 

  958.       RAW(row,col) = curve[**rp];
    959. 

  959.     *rp += is_raw;
    960. 

  960.   } else {
    961. 

  961.     if (row < height && col < width)
    962. 

  962.       FORC(tiff_samples)
    963. 

  963. 	image[row*width+col][c] = curve[(*rp)[c]];
    964. 

  964.     *rp += tiff_samples;
    965. 

  965.   }
    966. 

  966.   if (is_raw == 2 && shot_select) (*rp)--;
    967. 

  967. }
    968. 

  968. #else
    969. 

  969. void CLASS adobe_copy_pixel_raw (unsigned row, unsigned col, ushort **rp)
    970. 

  970. {
    971. 

  971.   if (is_raw == 2 && shot_select) (*rp)++;
    972. 

  972.   if (row < raw_height && col < raw_width)
    973. 

  973.     RAW(row,col) = curve[**rp];
    974. 

  974.   *rp += is_raw;
    975. 

  975.   if (is_raw == 2 && shot_select) (*rp)--;
    976. 

  976. }
    977. 

  977. void CLASS adobe_copy_pixel_color (unsigned row, unsigned col, ushort **rp)
    978. 

  978. {
    979. 

  979.   int c;
    980. 

  980. 

  981.   if (is_raw == 2 && shot_select) (*rp)++;
    982. 

  982.   if (row < height && col < width)
    983. 

  983.     FORC(tiff_samples)
    984. 

  984.       image[row*width+col][c] = curve[(*rp)[c]];
    985. 

  985.   *rp += tiff_samples;
    986. 

  986.   if (is_raw == 2 && shot_select) (*rp)--;
    987. 

  987. }
    988. 

  988. #endif
    989. 

  989. 

  990. 

  991. void CLASS lossless_dng_load_raw()
    992. 

  992. {
    993. 

  993.   unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col;
    994. 

  994.   struct jhead jh;
    995. 

  995.   ushort *rp;
    996. 

  996. 

  997.   while (trow < raw_height) {
    998. 

  998.     save = ftell(ifp);
    999. 

  999.     if (tile_length < INT_MAX)
    1000. 

  1000.       fseek (ifp, get4(), SEEK_SET);
    1001. 

  1001.     if (!ljpeg_start (&jh, 0)) break;
    1002. 

  1002.     jwide = jh.wide;
    1003. 

  1003.     if (filters) jwide *= jh.clrs;
    1004. 

  1004.     jwide /= is_raw;
    1005. 

  1005. #ifdef LIBRAW_LIBRARY_BUILD
    1006. 

  1006.     if(!data_size)
    1007. 

  1007.         throw LIBRAW_EXCEPTION_IO_BADFILE;
    1008. 

  1008.     LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1009. 

  1009.     LibRaw_bit_buffer bits;
    1010. 

  1010. #endif
    1011. 

  1011. 

  1012. #ifndef LIBRAW_LIBRARY_BUILD
    1013. 

  1013.     for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1014. 

  1014.       rp = ljpeg_row (jrow, &jh);
    1015. 

  1015.       for (jcol=0; jcol < jwide; jcol++) {
    1016. 

  1016. 	adobe_copy_pixel (trow+row, tcol+col, &rp);
    1017. 

  1017. 	if (++col >= tile_width || col >= raw_width)
    1018. 

  1018. 	  row += 1 + (col = 0);
    1019. 

  1019.       }
    1020. 

  1020.     }
    1021. 

  1021. #else
    1022. 

  1022.     if(raw_image)
    1023. 

  1023.       {
    1024. 

  1024.         for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1025. 

  1025. #ifdef LIBRAW_LIBRARY_BUILD
    1026. 

  1026.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    1027. 

  1027. #else
    1028. 

  1028.           rp = ljpeg_row (jrow, &jh);
    1029. 

  1029. #endif
    1030. 

  1030.           for (jcol=0; jcol < jwide; jcol++) {
    1031. 

  1031.             adobe_copy_pixel_raw (trow+row, tcol+col, &rp);
    1032. 

  1032.             if (++col >= tile_width || col >= raw_width)
    1033. 

  1033.               row += 1 + (col = 0);
    1034. 

  1034.           }
    1035. 

  1035.         }
    1036. 

  1036.       }
    1037. 

  1037.     else
    1038. 

  1038.       {
    1039. 

  1039.         for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1040. 

  1040. #ifdef LIBRAW_LIBRARY_BUILD
    1041. 

  1041.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    1042. 

  1042. #else
    1043. 

  1043.           rp = ljpeg_row (jrow, &jh);
    1044. 

  1044. #endif
    1045. 

  1045.           for (jcol=0; jcol < jwide; jcol++) {
    1046. 

  1046.             adobe_copy_pixel_color (trow+row, tcol+col, &rp);
    1047. 

  1047.             if (++col >= tile_width || col >= raw_width)
    1048. 

  1048.               row += 1 + (col = 0);
    1049. 

  1049.           }
    1050. 

  1050.         }
    1051. 

  1051.       }
    1052. 

  1052. #endif
    1053. 

  1053.     fseek (ifp, save+4, SEEK_SET);
    1054. 

  1054.     if ((tcol += tile_width) >= raw_width)
    1055. 

  1055.       trow += tile_length + (tcol = 0);
    1056. 

  1056.     ljpeg_end (&jh);
    1057. 

  1057. #ifdef LIBRAW_LIBRARY_BUILD
    1058. 

  1058.     delete buf;
    1059. 

  1059. #endif
    1060. 

  1060.   }
    1061. 

  1061. }
    1062. 

  1062. 

  1063. void CLASS packed_dng_load_raw()
    1064. 

  1064. {
    1065. 

  1065.   ushort *pixel, *rp;
    1066. 

  1066.   int row, col;
    1067. 

  1067. 

  1068.   pixel = (ushort *) calloc (raw_width * tiff_samples, sizeof *pixel);
    1069. 

  1069.   merror (pixel, "packed_dng_load_raw()");
    1070. 

  1070. 

  1071. #ifdef LIBRAW_LIBRARY_BUILD
    1072. 

  1072.   int dsz= raw_height*raw_width * tiff_samples * tiff_bps/8;
    1073. 

  1073.   LibRaw_byte_buffer *buf = NULL;
    1074. 

  1074.   if (tiff_bps != 16)
    1075. 

  1075.       {
    1076. 

  1076.           buf = ifp->make_byte_buffer(dsz);
    1077. 

  1077.       }
    1078. 

  1078.   LibRaw_bit_buffer bits;
    1079. 

  1079. #endif
    1080. 

  1080. 

  1081.   for (row=0; row < raw_height; row++) {
    1082. 

  1082.     if (tiff_bps == 16)
    1083. 

  1083.       read_shorts (pixel, raw_width * tiff_samples);
    1084. 

  1084.     else {
    1085. 

  1085. #ifdef LIBRAW_LIBRARY_BUILD
    1086. 

  1086.         bits.reset();
    1087. 

  1087.         for (col=0; col < raw_width * tiff_samples; col++)
    1088. 

  1088.             pixel[col] = bits._getbits(buf,tiff_bps,zero_after_ff);
    1089. 

  1089. 

  1090. #else
    1091. 

  1091.       getbits(-1);
    1092. 

  1092.       for (col=0; col < raw_width * tiff_samples; col++)
    1093. 

  1093. 	pixel[col] = getbits(tiff_bps);
    1094. 

  1094. #endif
    1095. 

  1095.     }
    1096. 

  1096. #ifndef LIBRAW_LIBRARY_BUILD
    1097. 

  1097.     for (rp=pixel, col=0; col < raw_width; col++)
    1098. 

  1098.       adobe_copy_pixel (row, col, &rp);
    1099. 

  1099. #else
    1100. 

  1100.     if(raw_image)
    1101. 

  1101.       for (rp=pixel, col=0; col < raw_width; col++)
    1102. 

  1102.         adobe_copy_pixel_raw (row, col, &rp);
    1103. 

  1103.     else
    1104. 

  1104.       for (rp=pixel, col=0; col < raw_width; col++)
    1105. 

  1105.         adobe_copy_pixel_color (row, col, &rp);
    1106. 

  1106. #endif
    1107. 

  1107.   }
    1108. 

  1108.   free (pixel);
    1109. 

  1109. #ifdef LIBRAW_LIBRARY_BUILD
    1110. 

  1110.     if(buf)
    1111. 

  1111.         delete buf;
    1112. 

  1112. #endif
    1113. 

  1113. }
    1114. 

  1114. 

  1115. void CLASS pentax_load_raw()
    1116. 

  1116. {
    1117. 

  1117.   ushort bit[2][15], huff[4097];
    1118. 

  1118.   int dep, row, col, diff, c, i;
    1119. 

  1119.   ushort vpred[2][2] = {{0,0},{0,0}}, hpred[2];
    1120. 

  1120. 

  1121.   fseek (ifp, meta_offset, SEEK_SET);
    1122. 

  1122.   dep = (get2() + 12) & 15;
    1123. 

  1123.   fseek (ifp, 12, SEEK_CUR);
    1124. 

  1124.   FORC(dep) bit[0][c] = get2();
    1125. 

  1125.   FORC(dep) bit[1][c] = fgetc(ifp);
    1126. 

  1126.   FORC(dep)
    1127. 

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

  1128.       huff[++i] = bit[1][c] << 8 | c;
    1129. 

  1129.   huff[0] = 12;
    1130. 

  1130.   fseek (ifp, data_offset, SEEK_SET);
    1131. 

  1131. #ifdef LIBRAW_LIBRARY_BUILD
    1132. 

  1132.   if(!data_size)
    1133. 

  1133.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1134. 

  1134.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1135. 

  1135.   LibRaw_bit_buffer bits;
    1136. 

  1136.   bits.reset();
    1137. 

  1137. #else
    1138. 

  1138.   getbits(-1);
    1139. 

  1139. #endif
    1140. 

  1140.   for (row=0; row < raw_height; row++)
    1141. 

  1141.     for (col=0; col < raw_width; col++) {
    1142. 

  1142. #ifdef LIBRAW_LIBRARY_BUILD
    1143. 

  1143.       diff = ljpeg_diff_pef(bits,buf,huff);
    1144. 

  1144. #else
    1145. 

  1145.       diff = ljpeg_diff (huff);
    1146. 

  1146. #endif
    1147. 

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

  1148.       else	   hpred[col & 1] += diff;
    1149. 

  1149.       RAW(row,col) = hpred[col & 1];
    1150. 

  1150.       if (hpred[col & 1] >> tiff_bps) derror();
    1151. 

  1151.     }
    1152. 

  1152. #ifdef LIBRAW_LIBRARY_BUILD
    1153. 

  1153.   delete buf;
    1154. 

  1154. #endif
    1155. 

  1155. }
    1156. 

  1156. 

  1157. void CLASS nikon_load_raw()
    1158. 

  1158. {
    1159. 

  1159.   static const uchar nikon_tree[][32] = {
    1160. 

  1160.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy */
    1161. 

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

  1162.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy after split */
    1163. 

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

  1164.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,  /* 12-bit lossless */
    1165. 

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

  1166.     { 0,1,4,3,1,1,1,1,1,2,0,0,0,0,0,0,	/* 14-bit lossy */
    1167. 

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

  1168.     { 0,1,5,1,1,1,1,1,1,1,2,0,0,0,0,0,	/* 14-bit lossy after split */
    1169. 

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

  1170.     { 0,1,4,2,2,3,1,2,0,0,0,0,0,0,0,0,	/* 14-bit lossless */
    1171. 

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

  1172.   ushort *huff, ver0, ver1, vpred[2][2], hpred[2], csize;
    1173. 

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

  1174. 

  1175.   fseek (ifp, meta_offset, SEEK_SET);
    1176. 

  1176.   ver0 = fgetc(ifp);
    1177. 

  1177.   ver1 = fgetc(ifp);
    1178. 

  1178.   if (ver0 == 0x49 || ver1 == 0x58)
    1179. 

  1179.     fseek (ifp, 2110, SEEK_CUR);
    1180. 

  1180.   if (ver0 == 0x46) tree = 2;
    1181. 

  1181.   if (tiff_bps == 14) tree += 3;
    1182. 

  1182.   read_shorts (vpred[0], 4);
    1183. 

  1183.   max = 1 << tiff_bps & 0x7fff;
    1184. 

  1184.   if ((csize = get2()) > 1)
    1185. 

  1185.     step = max / (csize-1);
    1186. 

  1186.   if (ver0 == 0x44 && ver1 == 0x20 && step > 0) {
    1187. 

  1187.     for (i=0; i < csize; i++)
    1188. 

  1188.       curve[i*step] = get2();
    1189. 

  1189.     for (i=0; i < max; i++)
    1190. 

  1190.       curve[i] = ( curve[i-i%step]*(step-i%step) +
    1191. 

  1191. 		   curve[i-i%step+step]*(i%step) ) / step;
    1192. 

  1192.     fseek (ifp, meta_offset+562, SEEK_SET);
    1193. 

  1193.     split = get2();
    1194. 

  1194.   } else if (ver0 != 0x46 && csize <= 0x4001)
    1195. 

  1195.     read_shorts (curve, max=csize);
    1196. 

  1196.   while (curve[max-2] == curve[max-1]) max--;
    1197. 

  1197.   huff = make_decoder (nikon_tree[tree]);
    1198. 

  1198.   fseek (ifp, data_offset, SEEK_SET);
    1199. 

  1199. #ifdef LIBRAW_LIBRARY_BUILD
    1200. 

  1200.   if(!data_size)
    1201. 

  1201.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1202. 

  1202.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1203. 

  1203.   LibRaw_bit_buffer bits;
    1204. 

  1204.   bits.reset();
    1205. 

  1205. #else
    1206. 

  1206.   getbits(-1);
    1207. 

  1207. #endif
    1208. 

  1208.   for (min=row=0; row < height; row++) {
    1209. 

  1209.     if (split && row == split) {
    1210. 

  1210.       free (huff);
    1211. 

  1211.       huff = make_decoder (nikon_tree[tree+1]);
    1212. 

  1212.       max += (min = 16) << 1;
    1213. 

  1213.     }
    1214. 

  1214.     for (col=0; col < raw_width; col++) {
    1215. 

  1215. #ifdef LIBRAW_LIBRARY_BUILD
    1216. 

  1216.         i = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    1217. 

  1217. #else
    1218. 

  1218.       i = gethuff(huff);
    1219. 

  1219. #endif
    1220. 

  1220.       len = i & 15;
    1221. 

  1221.       shl = i >> 4;
    1222. 

  1222. #ifdef LIBRAW_LIBRARY_BUILD
    1223. 

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

  1224. #else
    1225. 

  1225.       diff = ((getbits(len-shl) << 1) + 1) << shl >> 1;
    1226. 

  1226. #endif
    1227. 

  1227.       if ((diff & (1 << (len-1))) == 0)
    1228. 

  1228. 	diff -= (1 << len) - !shl;
    1229. 

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

  1230.       else	   hpred[col & 1] += diff;
    1231. 

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

  1232.       RAW(row,col) = curve[LIM((short)hpred[col & 1],0,0x3fff)];
    1233. 

  1233.     }
    1234. 

  1234.   }
    1235. 

  1235. #ifdef LIBRAW_LIBRARY_BUILD
    1236. 

  1236.   delete buf;
    1237. 

  1237. #endif
    1238. 

  1238.   free (huff);
    1239. 

  1239. }
    1240. 

  1240. 

  1241. /*
    1242. 

  1242.    Returns 1 for a Coolpix 995, 0 for anything else.
    1243. 

  1243.  */
    1244. 

  1244. int CLASS nikon_e995()
    1245. 

  1245. {
    1246. 

  1246.   int i, histo[256];
    1247. 

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

  1248. 

  1249.   memset (histo, 0, sizeof histo);
    1250. 

  1250.   fseek (ifp, -2000, SEEK_END);
    1251. 

  1251.   for (i=0; i < 2000; i++)
    1252. 

  1252.     histo[fgetc(ifp)]++;
    1253. 

  1253.   for (i=0; i < 4; i++)
    1254. 

  1254.     if (histo[often[i]] < 200)
    1255. 

  1255.       return 0;
    1256. 

  1256.   return 1;
    1257. 

  1257. }
    1258. 

  1258. 

  1259. /*
    1260. 

  1260.    Returns 1 for a Coolpix 2100, 0 for anything else.
    1261. 

  1261.  */
    1262. 

  1262. int CLASS nikon_e2100()
    1263. 

  1263. {
    1264. 

  1264.   uchar t[12];
    1265. 

  1265.   int i;
    1266. 

  1266. 

  1267.   fseek (ifp, 0, SEEK_SET);
    1268. 

  1268.   for (i=0; i < 1024; i++) {
    1269. 

  1269.     fread (t, 1, 12, ifp);
    1270. 

  1270.     if (((t[2] & t[4] & t[7] & t[9]) >> 4
    1271. 

  1271. 	& t[1] & t[6] & t[8] & t[11] & 3) != 3)
    1272. 

  1272.       return 0;
    1273. 

  1273.   }
    1274. 

  1274.   return 1;
    1275. 

  1275. }
    1276. 

  1276. 

  1277. void CLASS nikon_3700()
    1278. 

  1278. {
    1279. 

  1279.   int bits, i;
    1280. 

  1280.   uchar dp[24];
    1281. 

  1281.   static const struct {
    1282. 

  1282.     int bits;
    1283. 

  1283.     char t_make[12], t_model[15];
    1284. 

  1284.   } table[] = {
    1285. 

  1285.     { 0x00, "PENTAX",  "Optio 33WR" },
    1286. 

  1286.     { 0x03, "NIKON",   "E3200" },
    1287. 

  1287.     { 0x32, "NIKON",   "E3700" },
    1288. 

  1288.     { 0x33, "OLYMPUS", "C740UZ" } };
    1289. 

  1289. 

  1290.   fseek (ifp, 3072, SEEK_SET);
    1291. 

  1291.   fread (dp, 1, 24, ifp);
    1292. 

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

  1293.   for (i=0; i < sizeof table / sizeof *table; i++)
    1294. 

  1294.     if (bits == table[i].bits) {
    1295. 

  1295.       strcpy (make,  table[i].t_make );
    1296. 

  1296.       strcpy (model, table[i].t_model);
    1297. 

  1297.     }
    1298. 

  1298. }
    1299. 

  1299. 

  1300. /*
    1301. 

  1301.    Separates a Minolta DiMAGE Z2 from a Nikon E4300.
    1302. 

  1302.  */
    1303. 

  1303. int CLASS minolta_z2()
    1304. 

  1304. {
    1305. 

  1305.   int i, nz;
    1306. 

  1306.   char tail[424];
    1307. 

  1307. 

  1308.   fseek (ifp, -sizeof tail, SEEK_END);
    1309. 

  1309.   fread (tail, 1, sizeof tail, ifp);
    1310. 

  1310.   for (nz=i=0; i < sizeof tail; i++)
    1311. 

  1311.     if (tail[i]) nz++;
    1312. 

  1312.   return nz > 20;
    1313. 

  1313. }
    1314. 

  1314. #line 1585 "dcraw/dcraw.c"
    1315. 

  1315. void CLASS ppm_thumb()
    1316. 

  1316. {
    1317. 

  1317.   char *thumb;
    1318. 

  1318.   thumb_length = thumb_width*thumb_height*3;
    1319. 

  1319.   thumb = (char *) malloc (thumb_length);
    1320. 

  1320.   merror (thumb, "ppm_thumb()");
    1321. 

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

  1322.   fread  (thumb, 1, thumb_length, ifp);
    1323. 

  1323.   fwrite (thumb, 1, thumb_length, ofp);
    1324. 

  1324.   free (thumb);
    1325. 

  1325. }
    1326. 

  1326. 

  1327. void CLASS ppm16_thumb()
    1328. 

  1328. {
    1329. 

  1329.   int i;
    1330. 

  1330.   char *thumb;
    1331. 

  1331.   thumb_length = thumb_width*thumb_height*3;
    1332. 

  1332.   thumb = (char *) calloc (thumb_length,2);
    1333. 

  1333.   merror (thumb, "ppm16_thumb()");
    1334. 

  1334.   read_shorts ((ushort *) thumb, thumb_length);
    1335. 

  1335.   for (i=0; i < thumb_length; i++)
    1336. 

  1336.     thumb[i] = ((ushort *) thumb)[i] >> 8;
    1337. 

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

  1338.   fwrite (thumb, 1, thumb_length, ofp);
    1339. 

  1339.   free (thumb);
    1340. 

  1340. }
    1341. 

  1341. 

  1342. void CLASS layer_thumb()
    1343. 

  1343. {
    1344. 

  1344.   int i, c;
    1345. 

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

  1346. 

  1347.   colors = thumb_misc >> 5 & 7;
    1348. 

  1348.   thumb_length = thumb_width*thumb_height;
    1349. 

  1349.   thumb = (char *) calloc (colors, thumb_length);
    1350. 

  1350.   merror (thumb, "layer_thumb()");
    1351. 

  1351.   fprintf (ofp, "P%d\n%d %d\n255\n",
    1352. 

  1352. 	5 + (colors >> 1), thumb_width, thumb_height);
    1353. 

  1353.   fread (thumb, thumb_length, colors, ifp);
    1354. 

  1354.   for (i=0; i < thumb_length; i++)
    1355. 

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

  1356.   free (thumb);
    1357. 

  1357. }
    1358. 

  1358. 

  1359. void CLASS rollei_thumb()
    1360. 

  1360. {
    1361. 

  1361.   unsigned i;
    1362. 

  1362.   ushort *thumb;
    1363. 

  1363. 

  1364.   thumb_length = thumb_width * thumb_height;
    1365. 

  1365.   thumb = (ushort *) calloc (thumb_length, 2);
    1366. 

  1366.   merror (thumb, "rollei_thumb()");
    1367. 

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

  1368.   read_shorts (thumb, thumb_length);
    1369. 

  1369.   for (i=0; i < thumb_length; i++) {
    1370. 

  1370.     putc (thumb[i] << 3, ofp);
    1371. 

  1371.     putc (thumb[i] >> 5  << 2, ofp);
    1372. 

  1372.     putc (thumb[i] >> 11 << 3, ofp);
    1373. 

  1373.   }
    1374. 

  1374.   free (thumb);
    1375. 

  1375. }
    1376. 

  1376. 

  1377. void CLASS rollei_load_raw()
    1378. 

  1378. {
    1379. 

  1379.   uchar pixel[10];
    1380. 

  1380.   unsigned iten=0, isix, i, buffer=0, todo[16];
    1381. 

  1381. 

  1382.   isix = raw_width * raw_height * 5 / 8;
    1383. 

  1383.   while (fread (pixel, 1, 10, ifp) == 10) {
    1384. 

  1384.     for (i=0; i < 10; i+=2) {
    1385. 

  1385.       todo[i]   = iten++;
    1386. 

  1386.       todo[i+1] = pixel[i] << 8 | pixel[i+1];
    1387. 

  1387.       buffer    = pixel[i] >> 2 | buffer << 6;
    1388. 

  1388.     }
    1389. 

  1389.     for (   ; i < 16; i+=2) {
    1390. 

  1390.       todo[i]   = isix++;
    1391. 

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

  1392.     }
    1393. 

  1393.     for (i=0; i < 16; i+=2)
    1394. 

  1394.       raw_image[todo[i]] = (todo[i+1] & 0x3ff);
    1395. 

  1395.   }
    1396. 

  1396.   maximum = 0x3ff;
    1397. 

  1397. }
    1398. 

  1398. 

  1399. int CLASS raw (unsigned row, unsigned col)
    1400. 

  1400. {
    1401. 

  1401.   return (row < raw_height && col < raw_width) ? RAW(row,col) : 0;
    1402. 

  1402. }
    1403. 

  1403. 

  1404. void CLASS phase_one_flat_field (int is_float, int nc)
    1405. 

  1405. {
    1406. 

  1406.   ushort head[8];
    1407. 

  1407.   unsigned wide, y, x, c, rend, cend, row, col;
    1408. 

  1408.   float *mrow, num, mult[4];
    1409. 

  1409. 

  1410.   read_shorts (head, 8);
    1411. 

  1411.   wide = head[2] / head[4];
    1412. 

  1412.   mrow = (float *) calloc (nc*wide, sizeof *mrow);
    1413. 

  1413.   merror (mrow, "phase_one_flat_field()");
    1414. 

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

  1415.     for (x=0; x < wide; x++)
    1416. 

  1416.       for (c=0; c < nc; c+=2) {
    1417. 

  1417. 	num = is_float ? getreal(11) : get2()/32768.0;
    1418. 

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

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

  1420.       }
    1421. 

  1421.     if (y==0) continue;
    1422. 

  1422.     rend = head[1] + y*head[5];
    1423. 

  1423.     for (row = rend-head[5]; row < raw_height && row < rend; row++) {
    1424. 

  1424.       for (x=1; x < wide; x++) {
    1425. 

  1425. 	for (c=0; c < nc; c+=2) {
    1426. 

  1426. 	  mult[c] = mrow[c*wide+x-1];
    1427. 

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

  1428. 	}
    1429. 

  1429. 	cend = head[0] + x*head[4];
    1430. 

  1430. 	for (col = cend-head[4]; col < raw_width && col < cend; col++) {
    1431. 

  1431. 	  c = nc > 2 ? FC(row-top_margin,col-left_margin) : 0;
    1432. 

  1432. 	  if (!(c & 1)) {
    1433. 

  1433. 	    c = RAW(row,col) * mult[c];
    1434. 

  1434. 	    RAW(row,col) = LIM(c,0,65535);
    1435. 

  1435. 	  }
    1436. 

  1436. 	  for (c=0; c < nc; c+=2)
    1437. 

  1437. 	    mult[c] += mult[c+1];
    1438. 

  1438. 	}
    1439. 

  1439.       }
    1440. 

  1440.       for (x=0; x < wide; x++)
    1441. 

  1441. 	for (c=0; c < nc; c+=2)
    1442. 

  1442. 	  mrow[c*wide+x] += mrow[(c+1)*wide+x];
    1443. 

  1443.     }
    1444. 

  1444.   }
    1445. 

  1445.   free (mrow);
    1446. 

  1446. }
    1447. 

  1447. 

  1448. void CLASS phase_one_correct()
    1449. 

  1449. {
    1450. 

  1450.   unsigned entries, tag, data, save, col, row, type;
    1451. 

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

  1452.   int head[9], diff, mindiff=INT_MAX, off_412=0;
    1453. 

  1453.   static const signed char dir[12][2] =
    1454. 

  1454.     { {-1,-1}, {-1,1}, {1,-1}, {1,1}, {-2,0}, {0,-2}, {0,2}, {2,0},
    1455. 

  1455.       {-2,-2}, {-2,2}, {2,-2}, {2,2} };
    1456. 

  1456.   float poly[8], num, cfrac, frac, mult[2], *yval[2];
    1457. 

  1457.   ushort *xval[2];
    1458. 

  1458. 

  1459.   if (half_size || !meta_length) return;
    1460. 

  1460. #ifdef DCRAW_VERBOSE
    1461. 

  1461.   if (verbose) fprintf (stderr,_("Phase One correction...\n"));
    1462. 

  1462. #endif
    1463. 

  1463.   fseek (ifp, meta_offset, SEEK_SET);
    1464. 

  1464.   order = get2();
    1465. 

  1465.   fseek (ifp, 6, SEEK_CUR);
    1466. 

  1466.   fseek (ifp, meta_offset+get4(), SEEK_SET);
    1467. 

  1467.   entries = get4();  get4();
    1468. 

  1468.   while (entries--) {
    1469. 

  1469.     tag  = get4();
    1470. 

  1470.     len  = get4();
    1471. 

  1471.     data = get4();
    1472. 

  1472.     save = ftell(ifp);
    1473. 

  1473.     fseek (ifp, meta_offset+data, SEEK_SET);
    1474. 

  1474.     if (tag == 0x419) {				/* Polynomial curve */
    1475. 

  1475.       for (get4(), i=0; i < 8; i++)
    1476. 

  1476. 	poly[i] = getreal(11);
    1477. 

  1477.       poly[3] += (ph1.tag_210 - poly[7]) * poly[6] + 1;
    1478. 

  1478.       for (i=0; i < 0x10000; i++) {
    1479. 

  1479. 	num = (poly[5]*i + poly[3])*i + poly[1];
    1480. 

  1480. 	curve[i] = LIM(num,0,65535);
    1481. 

  1481.       } goto apply;				/* apply to right half */
    1482. 

  1482.     } else if (tag == 0x41a) {			/* Polynomial curve */
    1483. 

  1483.       for (i=0; i < 4; i++)
    1484. 

  1484. 	poly[i] = getreal(11);
    1485. 

  1485.       for (i=0; i < 0x10000; i++) {
    1486. 

  1486. 	for (num=0, j=4; j--; )
    1487. 

  1487. 	  num = num * i + poly[j];
    1488. 

  1488. 	curve[i] = LIM(num+i,0,65535);
    1489. 

  1489.       } apply:					/* apply to whole image */
    1490. 

  1490.       for (row=0; row < raw_height; row++)
    1491. 

  1491. 	for (col = (tag & 1)*ph1.split_col; col < raw_width; col++)
    1492. 

  1492. 	  RAW(row,col) = curve[RAW(row,col)];
    1493. 

  1493.     } else if (tag == 0x400) {			/* Sensor defects */
    1494. 

  1494.       while ((len -= 8) >= 0) {
    1495. 

  1495. 	col  = get2();
    1496. 

  1496. 	row  = get2();
    1497. 

  1497. 	type = get2(); get2();
    1498. 

  1498. 	if (col >= raw_width) continue;
    1499. 

  1499. 	if (type == 131)			/* Bad column */
    1500. 

  1500. 	  for (row=0; row < raw_height; row++)
    1501. 

  1501. 	    if (FC(row-top_margin,col-left_margin) == 1) {
    1502. 

  1502. 	      for (sum=i=0; i < 4; i++)
    1503. 

  1503. 		sum += val[i] = raw (row+dir[i][0], col+dir[i][1]);
    1504. 

  1504. 	      for (max=i=0; i < 4; i++) {
    1505. 

  1505. 		dev[i] = abs((val[i] << 2) - sum);
    1506. 

  1506. 		if (dev[max] < dev[i]) max = i;
    1507. 

  1507. 	      }
    1508. 

  1508. 	      RAW(row,col) = (sum - val[max])/3.0 + 0.5;
    1509. 

  1509. 	    } else {
    1510. 

  1510. 	      for (sum=0, i=8; i < 12; i++)
    1511. 

  1511. 		sum += raw (row+dir[i][0], col+dir[i][1]);
    1512. 

  1512. 	      RAW(row,col) = 0.5 + sum * 0.0732233 +
    1513. 

  1513. 		(raw(row,col-2) + raw(row,col+2)) * 0.3535534;
    1514. 

  1514. 	    }
    1515. 

  1515. 	else if (type == 129) {			/* Bad pixel */
    1516. 

  1516. 	  if (row >= raw_height) continue;
    1517. 

  1517. 	  j = (FC(row-top_margin,col-left_margin) != 1) * 4;
    1518. 

  1518. 	  for (sum=0, i=j; i < j+8; i++)
    1519. 

  1519. 	    sum += raw (row+dir[i][0], col+dir[i][1]);
    1520. 

  1520. 	  RAW(row,col) = (sum + 4) >> 3;
    1521. 

  1521. 	}
    1522. 

  1522.       }
    1523. 

  1523.     } else if (tag == 0x401) {			/* All-color flat fields */
    1524. 

  1524.       phase_one_flat_field (1, 2);
    1525. 

  1525.     } else if (tag == 0x416 || tag == 0x410) {
    1526. 

  1526.       phase_one_flat_field (0, 2);
    1527. 

  1527.     } else if (tag == 0x40b) {			/* Red+blue flat field */
    1528. 

  1528.       phase_one_flat_field (0, 4);
    1529. 

  1529.     } else if (tag == 0x412) {
    1530. 

  1530.       fseek (ifp, 36, SEEK_CUR);
    1531. 

  1531.       diff = abs (get2() - ph1.tag_21a);
    1532. 

  1532.       if (mindiff > diff) {
    1533. 

  1533. 	mindiff = diff;
    1534. 

  1534. 	off_412 = ftell(ifp) - 38;
    1535. 

  1535.       }
    1536. 

  1536.     }
    1537. 

  1537.     fseek (ifp, save, SEEK_SET);
    1538. 

  1538.   }
    1539. 

  1539.   if (off_412) {
    1540. 

  1540.     fseek (ifp, off_412, SEEK_SET);
    1541. 

  1541.     for (i=0; i < 9; i++) head[i] = get4() & 0x7fff;
    1542. 

  1542.     yval[0] = (float *) calloc (head[1]*head[3] + head[2]*head[4], 6);
    1543. 

  1543.     merror (yval[0], "phase_one_correct()");
    1544. 

  1544.     yval[1] = (float  *) (yval[0] + head[1]*head[3]);
    1545. 

  1545.     xval[0] = (ushort *) (yval[1] + head[2]*head[4]);
    1546. 

  1546.     xval[1] = (ushort *) (xval[0] + head[1]*head[3]);
    1547. 

  1547.     get2();
    1548. 

  1548.     for (i=0; i < 2; i++)
    1549. 

  1549.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1550. 

  1550. 	yval[i][j] = getreal(11);
    1551. 

  1551.     for (i=0; i < 2; i++)
    1552. 

  1552.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1553. 

  1553. 	xval[i][j] = get2();
    1554. 

  1554.     for (row=0; row < raw_height; row++)
    1555. 

  1555.       for (col=0; col < raw_width; col++) {
    1556. 

  1556. 	cfrac = (float) col * head[3] / raw_width;
    1557. 

  1557. 	cfrac -= cip = cfrac;
    1558. 

  1558. 	num = RAW(row,col) * 0.5;
    1559. 

  1559. 	for (i=cip; i < cip+2; i++) {
    1560. 

  1560. 	  for (k=j=0; j < head[1]; j++)
    1561. 

  1561. 	    if (num < xval[0][k = head[1]*i+j]) break;
    1562. 

  1562. 	  frac = (j == 0 || j == head[1]) ? 0 :
    1563. 

  1563. 		(xval[0][k] - num) / (xval[0][k] - xval[0][k-1]);
    1564. 

  1564. 	  mult[i-cip] = yval[0][k-1] * frac + yval[0][k] * (1-frac);
    1565. 

  1565. 	}
    1566. 

  1566. 	i = ((mult[0] * (1-cfrac) + mult[1] * cfrac) * row + num) * 2;
    1567. 

  1567. 	RAW(row,col) = LIM(i,0,65535);
    1568. 

  1568.       }
    1569. 

  1569.     free (yval[0]);
    1570. 

  1570.   }
    1571. 

  1571. }
    1572. 

  1572. 

  1573. void CLASS phase_one_load_raw()
    1574. 

  1574. {
    1575. 

  1575.   int a, b, i;
    1576. 

  1576.   ushort akey, bkey, t_mask;
    1577. 

  1577. 

  1578.   fseek (ifp, ph1.key_off, SEEK_SET);
    1579. 

  1579.   akey = get2();
    1580. 

  1580.   bkey = get2();
    1581. 

  1581.   t_mask = ph1.format == 1 ? 0x5555:0x1354;
    1582. 

  1582.   fseek (ifp, data_offset, SEEK_SET);
    1583. 

  1583.   read_shorts (raw_image, raw_width*raw_height);
    1584. 

  1584.   if (ph1.format)
    1585. 

  1585.     for (i=0; i < raw_width*raw_height; i+=2) {
    1586. 

  1586.       a = raw_image[i+0] ^ akey;
    1587. 

  1587.       b = raw_image[i+1] ^ bkey;
    1588. 

  1588.       raw_image[i+0] = (a & t_mask) | (b & ~t_mask);
    1589. 

  1589.       raw_image[i+1] = (b & t_mask) | (a & ~t_mask);
    1590. 

  1590.     }
    1591. 

  1591. }
    1592. 

  1592. 

  1593. unsigned CLASS ph1_bithuff (int nbits, ushort *huff)
    1594. 

  1594. {
    1595. 

  1595. #ifndef LIBRAW_NOTHREADS
    1596. 

  1596. #define bitbuf tls->ph1_bits.bitbuf
    1597. 

  1597. #define vbits  tls->ph1_bits.vbits    
    1598. 

  1598. #else
    1599. 

  1599.   static UINT64 bitbuf=0;
    1600. 

  1600.   static int vbits=0;
    1601. 

  1601. #endif
    1602. 

  1602.   unsigned c;
    1603. 

  1603. 

  1604.   if (nbits == -1)
    1605. 

  1605.     return bitbuf = vbits = 0;
    1606. 

  1606.   if (nbits == 0) return 0;
    1607. 

  1607.   if (vbits < nbits) {
    1608. 

  1608.     bitbuf = bitbuf << 32 | get4();
    1609. 

  1609.     vbits += 32;
    1610. 

  1610.   }
    1611. 

  1611.   c = bitbuf << (64-vbits) >> (64-nbits);
    1612. 

  1612.   if (huff) {
    1613. 

  1613.     vbits -= huff[c] >> 8;
    1614. 

  1614.     return (uchar) huff[c];
    1615. 

  1615.   }
    1616. 

  1616.   vbits -= nbits;
    1617. 

  1617.   return c;
    1618. 

  1618. #ifndef LIBRAW_NOTHREADS
    1619. 

  1619. #undef bitbuf
    1620. 

  1620. #undef vbits
    1621. 

  1621. #endif
    1622. 

  1622. }
    1623. 

  1623. #define ph1_bits(n) ph1_bithuff(n,0)
    1624. 

  1624. #define ph1_huff(h) ph1_bithuff(*h,h+1)
    1625. 

  1625. 

  1626. void CLASS phase_one_load_raw_c()
    1627. 

  1627. {
    1628. 

  1628.   static const int length[] = { 8,7,6,9,11,10,5,12,14,13 };
    1629. 

  1629.   int *offset, len[2], pred[2], row, col, i, j;
    1630. 

  1630.   ushort *pixel;
    1631. 

  1631.   short (*t_black)[2];
    1632. 

  1632. 

  1633.   pixel = (ushort *) calloc (raw_width + raw_height*4, 2);
    1634. 

  1634.   merror (pixel, "phase_one_load_raw_c()");
    1635. 

  1635.   offset = (int *) (pixel + raw_width);
    1636. 

  1636.   fseek (ifp, strip_offset, SEEK_SET);
    1637. 

  1637.   for (row=0; row < raw_height; row++)
    1638. 

  1638.     offset[row] = get4();
    1639. 

  1639.   t_black = (short (*)[2]) offset + raw_height;
    1640. 

  1640.   fseek (ifp, ph1.black_off, SEEK_SET);
    1641. 

  1641.   if (ph1.black_off)
    1642. 

  1642.       {
    1643. 

  1643.           read_shorts ((ushort *) t_black[0], raw_height*2);
    1644. 

  1644. #ifdef LIBRAW_LIBRARY_BUILD
    1645. 

  1645.           imgdata.rawdata.ph1_black = (short (*)[2])calloc(raw_height*2,sizeof(short));
    1646. 

  1646.           merror (imgdata.rawdata.ph1_black, "phase_one_load_raw_c()");
    1647. 

  1647.           memmove(imgdata.rawdata.ph1_black,(short *) t_black[0],raw_height*2*sizeof(short));
    1648. 

  1648. #endif
    1649. 

  1649.       }
    1650. 

  1650.   for (i=0; i < 256; i++)
    1651. 

  1651.     curve[i] = i*i / 3.969 + 0.5;
    1652. 

  1652.   for (row=0; row < raw_height; row++) {
    1653. 

  1653.     fseek (ifp, data_offset + offset[row], SEEK_SET);
    1654. 

  1654.     ph1_bits(-1);
    1655. 

  1655.     pred[0] = pred[1] = 0;
    1656. 

  1656.     for (col=0; col < raw_width; col++) {
    1657. 

  1657.       if (col >= (raw_width & -8))
    1658. 

  1658. 	len[0] = len[1] = 14;
    1659. 

  1659.       else if ((col & 7) == 0)
    1660. 

  1660. 	for (i=0; i < 2; i++) {
    1661. 

  1661. 	  for (j=0; j < 5 && !ph1_bits(1); j++);
    1662. 

  1662. 	  if (j--) len[i] = length[j*2 + ph1_bits(1)];
    1663. 

  1663. 	}
    1664. 

  1664.       if ((i = len[col & 1]) == 14)
    1665. 

  1665. 	pixel[col] = pred[col & 1] = ph1_bits(16);
    1666. 

  1666.       else
    1667. 

  1667. 	pixel[col] = pred[col & 1] += ph1_bits(i) + 1 - (1 << (i - 1));
    1668. 

  1668.       if (pred[col & 1] >> 16) derror();
    1669. 

  1669.       if (ph1.format == 5 && pixel[col] < 256)
    1670. 

  1670. 	pixel[col] = curve[pixel[col]];
    1671. 

  1671.     }
    1672. 

  1672.     for (col=0; col < raw_width; col++) {
    1673. 

  1673. #ifndef LIBRAW_LIBRARY_BUILD
    1674. 

  1674.       i = (pixel[col] << 2) - ph1.t_black + t_black[row][col >= ph1.split_col];
    1675. 

  1675.       if (i > 0) RAW(row,col) = i;
    1676. 

  1676. #else
    1677. 

  1677.       RAW(row,col) = pixel[col] << 2;
    1678. 

  1678. #endif
    1679. 

  1679.     }
    1680. 

  1680.   }
    1681. 

  1681.   free (pixel);
    1682. 

  1682.   maximum = 0xfffc - ph1.t_black;
    1683. 

  1683. }
    1684. 

  1684. 

  1685. void CLASS hasselblad_load_raw()
    1686. 

  1686. {
    1687. 

  1687.   struct jhead jh;
    1688. 

  1688.   int row, col, pred[2], len[2], diff, c;
    1689. 

  1689. 

  1690.   if (!ljpeg_start (&jh, 0)) return;
    1691. 

  1691.   order = 0x4949;
    1692. 

  1692.   ph1_bits(-1);
    1693. 

  1693.   for (row=0; row < raw_height; row++) {
    1694. 

  1694.     pred[0] = pred[1] = 0x8000 + load_flags;
    1695. 

  1695.     for (col=0; col < raw_width; col+=2) {
    1696. 

  1696.       FORC(2) len[c] = ph1_huff(jh.huff[0]);
    1697. 

  1697.       FORC(2) {
    1698. 

  1698. 	diff = ph1_bits(len[c]);
    1699. 

  1699. 	if ((diff & (1 << (len[c]-1))) == 0)
    1700. 

  1700. 	  diff -= (1 << len[c]) - 1;
    1701. 

  1701. 	if (diff == 65535) diff = -32768;
    1702. 

  1702. 	RAW(row,col+c) = pred[c] += diff;
    1703. 

  1703.       }
    1704. 

  1704.     }
    1705. 

  1705.   }
    1706. 

  1706.   ljpeg_end (&jh);
    1707. 

  1707.   maximum = 0xffff;
    1708. 

  1708. }
    1709. 

  1709. 

  1710. void CLASS leaf_hdr_load_raw()
    1711. 

  1711. {
    1712. 

  1712.   ushort *pixel=0;
    1713. 

  1713.   unsigned tile=0, r, c, row, col;
    1714. 

  1714. 

  1715.   if (!filters) {
    1716. 

  1716.     pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1717. 

  1717.     merror (pixel, "leaf_hdr_load_raw()");
    1718. 

  1718.   }
    1719. 

  1719.   FORC(tiff_samples)
    1720. 

  1720.     for (r=0; r < raw_height; r++) {
    1721. 

  1721.       if (r % tile_length == 0) {
    1722. 

  1722. 	fseek (ifp, data_offset + 4*tile++, SEEK_SET);
    1723. 

  1723. 	fseek (ifp, get4(), SEEK_SET);
    1724. 

  1724.       }
    1725. 

  1725.       if (filters && c != shot_select) continue;
    1726. 

  1726.       if (filters) pixel = raw_image + r*raw_width;
    1727. 

  1727.       read_shorts (pixel, raw_width);
    1728. 

  1728.       if (!filters && (row = r - top_margin) < height)
    1729. 

  1729. 	for (col=0; col < width; col++)
    1730. 

  1730. 	  image[row*width+col][c] = pixel[col+left_margin];
    1731. 

  1731.     }
    1732. 

  1732.   if (!filters) {
    1733. 

  1733.     maximum = 0xffff;
    1734. 

  1734.     raw_color = 1;
    1735. 

  1735.     free (pixel);
    1736. 

  1736.   }
    1737. 

  1737. }
    1738. 

  1738. 

  1739. void CLASS unpacked_load_raw()
    1740. 

  1740. {
    1741. 

  1741.   int row, col, bits=0;
    1742. 

  1742. 

  1743.   while (1 << ++bits < maximum);
    1744. 

  1744.   read_shorts (raw_image, raw_width*raw_height);
    1745. 

  1745.   for (row=0; row < raw_height; row++)
    1746. 

  1746.     for (col=0; col < raw_width; col++)
    1747. 

  1747.       if ((RAW(row,col) >>= load_flags) >> bits
    1748. 

  1748. 	&& (unsigned) (row-top_margin) < height
    1749. 

  1749. 	&& (unsigned) (col-left_margin) < width) derror();
    1750. 

  1750. }
    1751. 

  1751. 

  1752. void CLASS sinar_4shot_load_raw()
    1753. 

  1753. {
    1754. 

  1754.   ushort *pixel;
    1755. 

  1755.   unsigned shot, row, col, r, c;
    1756. 

  1756. 

  1757.   if ((shot = shot_select) || half_size) {
    1758. 

  1758.     if (shot) shot--;
    1759. 

  1759.     if (shot > 3) shot = 3;
    1760. 

  1760.     fseek (ifp, data_offset + shot*4, SEEK_SET);
    1761. 

  1761.     fseek (ifp, get4(), SEEK_SET);
    1762. 

  1762.     unpacked_load_raw();
    1763. 

  1763.     return;
    1764. 

  1764.   }
    1765. 

  1765. #ifndef LIBRAW_LIBRARY_BUILD
    1766. 

  1766.   free (raw_image);
    1767. 

  1767.   raw_image = 0;
    1768. 

  1768.   free (image);
    1769. 

  1769.   image = (ushort (*)[4])
    1770. 

  1770. 	calloc ((iheight=height)*(iwidth=width), sizeof *image);
    1771. 

  1771.   merror (image, "sinar_4shot_load_raw()");
    1772. 

  1772. #endif
    1773. 

  1773.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1774. 

  1774.   merror (pixel, "sinar_4shot_load_raw()");
    1775. 

  1775.   for (shot=0; shot < 4; shot++) {
    1776. 

  1776.     fseek (ifp, data_offset + shot*4, SEEK_SET);
    1777. 

  1777.     fseek (ifp, get4(), SEEK_SET);
    1778. 

  1778.     for (row=0; row < raw_height; row++) {
    1779. 

  1779.       read_shorts (pixel, raw_width);
    1780. 

  1780.       if ((r = row-top_margin - (shot >> 1 & 1)) >= height) continue;
    1781. 

  1781.       for (col=0; col < raw_width; col++) {
    1782. 

  1782. 	if ((c = col-left_margin - (shot & 1)) >= width) continue;
    1783. 

  1783. 	image[r*width+c][FC(row,col)] = pixel[col];
    1784. 

  1784.       }
    1785. 

  1785.     }
    1786. 

  1786.   }
    1787. 

  1787.   free (pixel);
    1788. 

  1788.   shrink = filters = 0;
    1789. 

  1789. }
    1790. 

  1790. 

  1791. void CLASS imacon_full_load_raw()
    1792. 

  1792. {
    1793. 

  1793.   int row, col;
    1794. 

  1794. 

  1795.   for (row=0; row < height; row++)
    1796. 

  1796.     for (col=0; col < width; col++)
    1797. 

  1797.       read_shorts (image[row*width+col], 3);
    1798. 

  1798. }
    1799. 

  1799. 

  1800. void CLASS packed_load_raw()
    1801. 

  1801. {
    1802. 

  1802.   int vbits=0, bwide, pwide, rbits, bite, half, irow, row, col, val, i;
    1803. 

  1803.   UINT64 bitbuf=0;
    1804. 

  1804. 

  1805.   if (raw_width * 8 >= width * tiff_bps)	/* Is raw_width in bytes? */
    1806. 

  1806.        pwide = (bwide = raw_width) * 8 / tiff_bps;
    1807. 

  1807.   else bwide = (pwide = raw_width) * tiff_bps / 8;
    1808. 

  1808.   rbits = bwide * 8 - pwide * tiff_bps;
    1809. 

  1809.   if (load_flags & 1) bwide = bwide * 16 / 15;
    1810. 

  1810.   bite = 8 + (load_flags & 24);
    1811. 

  1811.   half = (raw_height+1) >> 1;
    1812. 

  1812.   for (irow=0; irow < raw_height; irow++) {
    1813. 

  1813.     row = irow;
    1814. 

  1814.     if (load_flags & 2 &&
    1815. 

  1815. 	(row = irow % half * 2 + irow / half) == 1 &&
    1816. 

  1816. 	load_flags & 4) {
    1817. 

  1817.       if (vbits=0, tiff_compress)
    1818. 

  1818. 	fseek (ifp, data_offset - (-half*bwide & -2048), SEEK_SET);
    1819. 

  1819.       else {
    1820. 

  1820. 	fseek (ifp, 0, SEEK_END);
    1821. 

  1821. 	fseek (ifp, ftell(ifp) >> 3 << 2, SEEK_SET);
    1822. 

  1822.       }
    1823. 

  1823.     }
    1824. 

  1824.     for (col=0; col < pwide; col++) {
    1825. 

  1825.       for (vbits -= tiff_bps; vbits < 0; vbits += bite) {
    1826. 

  1826. 	bitbuf <<= bite;
    1827. 

  1827. 	for (i=0; i < bite; i+=8)
    1828. 

  1828. 	  bitbuf |= (unsigned) (fgetc(ifp) << i);
    1829. 

  1829.       }
    1830. 

  1830.       val = bitbuf << (64-tiff_bps-vbits) >> (64-tiff_bps);
    1831. 

  1831.       RAW(row,col ^ (load_flags >> 6)) = val;
    1832. 

  1832.       if (load_flags & 1 && (col % 10) == 9 &&
    1833. 

  1833. 	fgetc(ifp) && col < width+left_margin) derror();
    1834. 

  1834.     }
    1835. 

  1835.     vbits -= rbits;
    1836. 

  1836.   }
    1837. 

  1837. }
    1838. 

  1838. 

  1839. void CLASS nokia_load_raw()
    1840. 

  1840. {
    1841. 

  1841.   uchar  *data,  *dp;
    1842. 

  1842.   int rev, dwide, row, col, c;
    1843. 

  1843. 

  1844.   rev = 3 * (order == 0x4949);
    1845. 

  1845.   dwide = raw_width * 5 / 4;
    1846. 

  1846.   data = (uchar *) malloc (dwide*2);
    1847. 

  1847.   merror (data, "nokia_load_raw()");
    1848. 

  1848.   for (row=0; row < raw_height; row++) {
    1849. 

  1849.     if (fread (data+dwide, 1, dwide, ifp) < dwide) derror();
    1850. 

  1850.     FORC(dwide) data[c] = data[dwide+(c ^ rev)];
    1851. 

  1851.     for (dp=data, col=0; col < raw_width; dp+=5, col+=4)
    1852. 

  1852.       FORC4 RAW(row,col+c) = (dp[c] << 2) | (dp[4] >> (c << 1) & 3);
    1853. 

  1853.   }
    1854. 

  1854.   free (data);
    1855. 

  1855.   maximum = 0x3ff;
    1856. 

  1856. }
    1857. 

  1857. 

  1858. unsigned CLASS pana_bits (int nbits)
    1859. 

  1859. {
    1860. 

  1860. #ifndef LIBRAW_NOTHREADS
    1861. 

  1861. #define buf tls->pana_bits.buf
    1862. 

  1862. #define vbits tls->pana_bits.vbits   
    1863. 

  1863. #else
    1864. 

  1864.   static uchar buf[0x4000];
    1865. 

  1865.   static int vbits;
    1866. 

  1866. #endif
    1867. 

  1867.   int byte;
    1868. 

  1868. 

  1869.   if (!nbits) return vbits=0;
    1870. 

  1870.   if (!vbits) {
    1871. 

  1871.     fread (buf+load_flags, 1, 0x4000-load_flags, ifp);
    1872. 

  1872.     fread (buf, 1, load_flags, ifp);
    1873. 

  1873.   }
    1874. 

  1874.   vbits = (vbits - nbits) & 0x1ffff;
    1875. 

  1875.   byte = vbits >> 3 ^ 0x3ff0;
    1876. 

  1876.   return (buf[byte] | buf[byte+1] << 8) >> (vbits & 7) & ~(-1 << nbits);
    1877. 

  1877. #ifndef LIBRAW_NOTHREADS
    1878. 

  1878. #undef buf
    1879. 

  1879. #undef vbits
    1880. 

  1880. #endif
    1881. 

  1881. }
    1882. 

  1882. 

  1883. void CLASS panasonic_load_raw()
    1884. 

  1884. {
    1885. 

  1885.   int row, col, i, j, sh=0, pred[2], nonz[2];
    1886. 

  1886. 

  1887.   pana_bits(0);
    1888. 

  1888.   for (row=0; row < height; row++)
    1889. 

  1889.     for (col=0; col < raw_width; col++) {
    1890. 

  1890.       if ((i = col % 14) == 0)
    1891. 

  1891. 	pred[0] = pred[1] = nonz[0] = nonz[1] = 0;
    1892. 

  1892.       if (i % 3 == 2) sh = 4 >> (3 - pana_bits(2));
    1893. 

  1893.       if (nonz[i & 1]) {
    1894. 

  1894. 	if ((j = pana_bits(8))) {
    1895. 

  1895. 	  if ((pred[i & 1] -= 0x80 << sh) < 0 || sh == 4)
    1896. 

  1896. 	       pred[i & 1] &= ~(-1 << sh);
    1897. 

  1897. 	  pred[i & 1] += j << sh;
    1898. 

  1898. 	}
    1899. 

  1899.       } else if ((nonz[i & 1] = pana_bits(8)) || i > 11)
    1900. 

  1900. 	pred[i & 1] = nonz[i & 1] << 4 | pana_bits(4);
    1901. 

  1901.       if ((RAW(row,col) = pred[col & 1]) > 4098 && col < width) derror();
    1902. 

  1902.     }
    1903. 

  1903. }
    1904. 

  1904. 

  1905. void CLASS olympus_load_raw()
    1906. 

  1906. {
    1907. 

  1907.   ushort huff[4096];
    1908. 

  1908.   int row, col, nbits, sign, low, high, i, c, w, n, nw;
    1909. 

  1909.   int acarry[2][3], *carry, pred, diff;
    1910. 

  1910. 

  1911.   huff[n=0] = 0xc0c;
    1912. 

  1912.   for (i=12; i--; )
    1913. 

  1913.     FORC(2048 >> i) huff[++n] = (i+1) << 8 | i;
    1914. 

  1914.   fseek (ifp, 7, SEEK_CUR);
    1915. 

  1915. #ifdef LIBRAW_LIBRARY_BUILD
    1916. 

  1916.   if(!data_size)
    1917. 

  1917.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1918. 

  1918.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1919. 

  1919.   LibRaw_bit_buffer bits;
    1920. 

  1920.   bits.reset();
    1921. 

  1921. #else
    1922. 

  1922.   getbits(-1);
    1923. 

  1923. #endif
    1924. 

  1924.   for (row=0; row < height; row++) {
    1925. 

  1925.     memset (acarry, 0, sizeof acarry);
    1926. 

  1926.     for (col=0; col < raw_width; col++) {
    1927. 

  1927.       carry = acarry[col & 1];
    1928. 

  1928.       i = 2 * (carry[2] < 3);
    1929. 

  1929.       for (nbits=2+i; (ushort) carry[0] >> (nbits+i); nbits++);
    1930. 

  1930. #ifdef LIBRAW_LIBRARY_BUILD
    1931. 

  1931.       low = (sign = bits._getbits(buf,3,zero_after_ff)) & 3;
    1932. 

  1932.       sign = sign << 29 >> 31;
    1933. 

  1933.       if ((high = bits._gethuff(buf,12,huff,zero_after_ff)) == 12)
    1934. 

  1934.           high = bits._getbits(buf,16-nbits,zero_after_ff) >> 1;
    1935. 

  1935.       carry[0] = (high << nbits) | bits._getbits(buf,nbits,zero_after_ff);
    1936. 

  1936. #else
    1937. 

  1937.       low = (sign = getbits(3)) & 3;
    1938. 

  1938.       sign = sign << 29 >> 31;
    1939. 

  1939.       if ((high = getbithuff(12,huff)) == 12)
    1940. 

  1940. 	high = getbits(16-nbits) >> 1;
    1941. 

  1941.       carry[0] = (high << nbits) | getbits(nbits);
    1942. 

  1942. #endif
    1943. 

  1943.       diff = (carry[0] ^ sign) + carry[1];
    1944. 

  1944.       carry[1] = (diff*3 + carry[1]) >> 5;
    1945. 

  1945.       carry[2] = carry[0] > 16 ? 0 : carry[2]+1;
    1946. 

  1946.       if (col >= width) continue;
    1947. 

  1947.       if (row < 2 && col < 2) pred = 0;
    1948. 

  1948.       else if (row < 2) pred = RAW(row,col-2);
    1949. 

  1949.       else if (col < 2) pred = RAW(row-2,col);
    1950. 

  1950.       else {
    1951. 

  1951. 	w  = RAW(row,col-2);
    1952. 

  1952. 	n  = RAW(row-2,col);
    1953. 

  1953. 	nw = RAW(row-2,col-2);
    1954. 

  1954. 	if ((w < nw && nw < n) || (n < nw && nw < w)) {
    1955. 

  1955. 	  if (ABS(w-nw) > 32 || ABS(n-nw) > 32)
    1956. 

  1956. 	    pred = w + n - nw;
    1957. 

  1957. 	  else pred = (w + n) >> 1;
    1958. 

  1958. 	} else pred = ABS(w-nw) > ABS(n-nw) ? w : n;
    1959. 

  1959.       }
    1960. 

  1960.       if ((RAW(row,col) = pred + ((diff << 2) | low)) >> 12) derror();
    1961. 

  1961.     }
    1962. 

  1962.   }
    1963. 

  1963. #ifdef LIBRAW_LIBRARY_BUILD
    1964. 

  1964.   delete buf;
    1965. 

  1965. #endif
    1966. 

  1966. }
    1967. 

  1967. 

  1968. void CLASS minolta_rd175_load_raw()
    1969. 

  1969. {
    1970. 

  1970.   uchar pixel[768];
    1971. 

  1971.   unsigned irow, box, row, col;
    1972. 

  1972. 

  1973.   for (irow=0; irow < 1481; irow++) {
    1974. 

  1974.     if (fread (pixel, 1, 768, ifp) < 768) derror();
    1975. 

  1975.     box = irow / 82;
    1976. 

  1976.     row = irow % 82 * 12 + ((box < 12) ? box | 1 : (box-12)*2);
    1977. 

  1977.     switch (irow) {
    1978. 

  1978.       case 1477: case 1479: continue;
    1979. 

  1979.       case 1476: row = 984; break;
    1980. 

  1980.       case 1480: row = 985; break;
    1981. 

  1981.       case 1478: row = 985; box = 1;
    1982. 

  1982.     }
    1983. 

  1983.     if ((box < 12) && (box & 1)) {
    1984. 

  1984.       for (col=0; col < 1533; col++, row ^= 1)
    1985. 

  1985. 	if (col != 1) RAW(row,col) = (col+1) & 2 ?
    1986. 

  1986. 		   pixel[col/2-1] + pixel[col/2+1] : pixel[col/2] << 1;
    1987. 

  1987.       RAW(row,1)    = pixel[1]   << 1;
    1988. 

  1988.       RAW(row,1533) = pixel[765] << 1;
    1989. 

  1989.     } else
    1990. 

  1990.       for (col=row & 1; col < 1534; col+=2)
    1991. 

  1991. 	RAW(row,col) = pixel[col/2] << 1;
    1992. 

  1992.   }
    1993. 

  1993.   maximum = 0xff << 1;
    1994. 

  1994. }
    1995. 

  1995. 

  1996. void CLASS quicktake_100_load_raw()
    1997. 

  1997. {
    1998. 

  1998.   uchar pixel[484][644];
    1999. 

  1999.   static const short gstep[16] =
    2000. 

  2000.   { -89,-60,-44,-32,-22,-15,-8,-2,2,8,15,22,32,44,60,89 };
    2001. 

  2001.   static const short rstep[6][4] =
    2002. 

  2002.   { {  -3,-1,1,3  }, {  -5,-1,1,5  }, {  -8,-2,2,8  },
    2003. 

  2003.     { -13,-3,3,13 }, { -19,-4,4,19 }, { -28,-6,6,28 } };
    2004. 

  2004.   static const short t_curve[256] =
    2005. 

  2005.   { 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,
    2006. 

  2006.     28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,
    2007. 

  2007.     54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,74,75,76,77,78,
    2008. 

  2008.     79,80,81,82,83,84,86,88,90,92,94,97,99,101,103,105,107,110,112,114,116,
    2009. 

  2009.     118,120,123,125,127,129,131,134,136,138,140,142,144,147,149,151,153,155,
    2010. 

  2010.     158,160,162,164,166,168,171,173,175,177,179,181,184,186,188,190,192,195,
    2011. 

  2011.     197,199,201,203,205,208,210,212,214,216,218,221,223,226,230,235,239,244,
    2012. 

  2012.     248,252,257,261,265,270,274,278,283,287,291,296,300,305,309,313,318,322,
    2013. 

  2013.     326,331,335,339,344,348,352,357,361,365,370,374,379,383,387,392,396,400,
    2014. 

  2014.     405,409,413,418,422,426,431,435,440,444,448,453,457,461,466,470,474,479,
    2015. 

  2015.     483,487,492,496,500,508,519,531,542,553,564,575,587,598,609,620,631,643,
    2016. 

  2016.     654,665,676,687,698,710,721,732,743,754,766,777,788,799,810,822,833,844,
    2017. 

  2017.     855,866,878,889,900,911,922,933,945,956,967,978,989,1001,1012,1023 };
    2018. 

  2018.   int rb, row, col, sharp, val=0;
    2019. 

  2019. 

  2020.   getbits(-1);
    2021. 

  2021.   memset (pixel, 0x80, sizeof pixel);
    2022. 

  2022.   for (row=2; row < height+2; row++) {
    2023. 

  2023.     for (col=2+(row & 1); col < width+2; col+=2) {
    2024. 

  2024.       val = ((pixel[row-1][col-1] + 2*pixel[row-1][col+1] +
    2025. 

  2025. 		pixel[row][col-2]) >> 2) + gstep[getbits(4)];
    2026. 

  2026.       pixel[row][col] = val = LIM(val,0,255);
    2027. 

  2027.       if (col < 4)
    2028. 

  2028. 	pixel[row][col-2] = pixel[row+1][~row & 1] = val;
    2029. 

  2029.       if (row == 2)
    2030. 

  2030. 	pixel[row-1][col+1] = pixel[row-1][col+3] = val;
    2031. 

  2031.     }
    2032. 

  2032.     pixel[row][col] = val;
    2033. 

  2033.   }
    2034. 

  2034.   for (rb=0; rb < 2; rb++)
    2035. 

  2035.     for (row=2+rb; row < height+2; row+=2)
    2036. 

  2036.       for (col=3-(row & 1); col < width+2; col+=2) {
    2037. 

  2037. 	if (row < 4 || col < 4) sharp = 2;
    2038. 

  2038. 	else {
    2039. 

  2039. 	  val = ABS(pixel[row-2][col] - pixel[row][col-2])
    2040. 

  2040. 	      + ABS(pixel[row-2][col] - pixel[row-2][col-2])
    2041. 

  2041. 	      + ABS(pixel[row][col-2] - pixel[row-2][col-2]);
    2042. 

  2042. 	  sharp = val <  4 ? 0 : val <  8 ? 1 : val < 16 ? 2 :
    2043. 

  2043. 		  val < 32 ? 3 : val < 48 ? 4 : 5;
    2044. 

  2044. 	}
    2045. 

  2045. 	val = ((pixel[row-2][col] + pixel[row][col-2]) >> 1)
    2046. 

  2046. 	      + rstep[sharp][getbits(2)];
    2047. 

  2047. 	pixel[row][col] = val = LIM(val,0,255);
    2048. 

  2048. 	if (row < 4) pixel[row-2][col+2] = val;
    2049. 

  2049. 	if (col < 4) pixel[row+2][col-2] = val;
    2050. 

  2050.       }
    2051. 

  2051.   for (row=2; row < height+2; row++)
    2052. 

  2052.     for (col=3-(row & 1); col < width+2; col+=2) {
    2053. 

  2053.       val = ((pixel[row][col-1] + (pixel[row][col] << 2) +
    2054. 

  2054. 	      pixel[row][col+1]) >> 1) - 0x100;
    2055. 

  2055.       pixel[row][col] = LIM(val,0,255);
    2056. 

  2056.     }
    2057. 

  2057.   for (row=0; row < height; row++)
    2058. 

  2058.     for (col=0; col < width; col++)
    2059. 

  2059.       RAW(row,col) = t_curve[pixel[row+2][col+2]];
    2060. 

  2060.   maximum = 0x3ff;
    2061. 

  2061. }
    2062. 

  2062. 

  2063. #define radc_token(tree) ((signed char) getbithuff(8,huff[tree]))
    2064. 

  2064. 

  2065. #define FORYX for (y=1; y < 3; y++) for (x=col+1; x >= col; x--)
    2066. 

  2066. 

  2067. #define PREDICTOR (c ? (buf[c][y-1][x] + buf[c][y][x+1]) / 2 \
    2068. 

  2068. : (buf[c][y-1][x+1] + 2*buf[c][y-1][x] + buf[c][y][x+1]) / 4)
    2069. 

  2069. 

  2070. void CLASS kodak_radc_load_raw()
    2071. 

  2071. {
    2072. 

  2072.   static const char src[] = {
    2073. 

  2073.     1,1, 2,3, 3,4, 4,2, 5,7, 6,5, 7,6, 7,8,
    2074. 

  2074.     1,0, 2,1, 3,3, 4,4, 5,2, 6,7, 7,6, 8,5, 8,8,
    2075. 

  2075.     2,1, 2,3, 3,0, 3,2, 3,4, 4,6, 5,5, 6,7, 6,8,
    2076. 

  2076.     2,0, 2,1, 2,3, 3,2, 4,4, 5,6, 6,7, 7,5, 7,8,
    2077. 

  2077.     2,1, 2,4, 3,0, 3,2, 3,3, 4,7, 5,5, 6,6, 6,8,
    2078. 

  2078.     2,3, 3,1, 3,2, 3,4, 3,5, 3,6, 4,7, 5,0, 5,8,
    2079. 

  2079.     2,3, 2,6, 3,0, 3,1, 4,4, 4,5, 4,7, 5,2, 5,8,
    2080. 

  2080.     2,4, 2,7, 3,3, 3,6, 4,1, 4,2, 4,5, 5,0, 5,8,
    2081. 

  2081.     2,6, 3,1, 3,3, 3,5, 3,7, 3,8, 4,0, 5,2, 5,4,
    2082. 

  2082.     2,0, 2,1, 3,2, 3,3, 4,4, 4,5, 5,6, 5,7, 4,8,
    2083. 

  2083.     1,0, 2,2, 2,-2,
    2084. 

  2084.     1,-3, 1,3,
    2085. 

  2085.     2,-17, 2,-5, 2,5, 2,17,
    2086. 

  2086.     2,-7, 2,2, 2,9, 2,18,
    2087. 

  2087.     2,-18, 2,-9, 2,-2, 2,7,
    2088. 

  2088.     2,-28, 2,28, 3,-49, 3,-9, 3,9, 4,49, 5,-79, 5,79,
    2089. 

  2089.     2,-1, 2,13, 2,26, 3,39, 4,-16, 5,55, 6,-37, 6,76,
    2090. 

  2090.     2,-26, 2,-13, 2,1, 3,-39, 4,16, 5,-55, 6,-76, 6,37
    2091. 

  2091.   };
    2092. 

  2092.   ushort huff[19][256];
    2093. 

  2093.   int row, col, tree, nreps, rep, step, i, c, s, r, x, y, val;
    2094. 

  2094.   short last[3] = { 16,16,16 }, mul[3], buf[3][3][386];
    2095. 

  2095.   static const ushort pt[] =
    2096. 

  2096.     { 0,0, 1280,1344, 2320,3616, 3328,8000, 4095,16383, 65535,16383 };
    2097. 

  2097. 

  2098.   for (i=2; i < 12; i+=2)
    2099. 

  2099.     for (c=pt[i-2]; c <= pt[i]; c++)
    2100. 

  2100.       curve[c] = (float)
    2101. 

  2101. 	(c-pt[i-2]) / (pt[i]-pt[i-2]) * (pt[i+1]-pt[i-1]) + pt[i-1] + 0.5;
    2102. 

  2102.   for (s=i=0; i < sizeof src; i+=2)
    2103. 

  2103.     FORC(256 >> src[i])
    2104. 

  2104.       huff[0][s++] = src[i] << 8 | (uchar) src[i+1];
    2105. 

  2105.   s = kodak_cbpp == 243 ? 2 : 3;
    2106. 

  2106.   FORC(256) huff[18][c] = (8-s) << 8 | c >> s << s | 1 << (s-1);
    2107. 

  2107.   getbits(-1);
    2108. 

  2108.   for (i=0; i < sizeof(buf)/sizeof(short); i++)
    2109. 

  2109.     buf[0][0][i] = 2048;
    2110. 

  2110.   for (row=0; row < height; row+=4) {
    2111. 

  2111.     FORC3 mul[c] = getbits(6);
    2112. 

  2112.     FORC3 {
    2113. 

  2113.       val = ((0x1000000/last[c] + 0x7ff) >> 12) * mul[c];
    2114. 

  2114.       s = val > 65564 ? 10:12;
    2115. 

  2115.       x = ~(-1 << (s-1));
    2116. 

  2116.       val <<= 12-s;
    2117. 

  2117.       for (i=0; i < sizeof(buf[0])/sizeof(short); i++)
    2118. 

  2118. 	buf[c][0][i] = (buf[c][0][i] * val + x) >> s;
    2119. 

  2119.       last[c] = mul[c];
    2120. 

  2120.       for (r=0; r <= !c; r++) {
    2121. 

  2121. 	buf[c][1][width/2] = buf[c][2][width/2] = mul[c] << 7;
    2122. 

  2122. 	for (tree=1, col=width/2; col > 0; ) {
    2123. 

  2123. 	  if ((tree = radc_token(tree))) {
    2124. 

  2124. 	    col -= 2;
    2125. 

  2125. 	    if (tree == 8)
    2126. 

  2126. 	      FORYX buf[c][y][x] = (uchar) radc_token(18) * mul[c];
    2127. 

  2127. 	    else
    2128. 

  2128. 	      FORYX buf[c][y][x] = radc_token(tree+10) * 16 + PREDICTOR;
    2129. 

  2129. 	  } else
    2130. 

  2130. 	    do {
    2131. 

  2131. 	      nreps = (col > 2) ? radc_token(9) + 1 : 1;
    2132. 

  2132. 	      for (rep=0; rep < 8 && rep < nreps && col > 0; rep++) {
    2133. 

  2133. 		col -= 2;
    2134. 

  2134. 		FORYX buf[c][y][x] = PREDICTOR;
    2135. 

  2135. 		if (rep & 1) {
    2136. 

  2136. 		  step = radc_token(10) << 4;
    2137. 

  2137. 		  FORYX buf[c][y][x] += step;
    2138. 

  2138. 		}
    2139. 

  2139. 	      }
    2140. 

  2140. 	    } while (nreps == 9);
    2141. 

  2141. 	}
    2142. 

  2142. 	for (y=0; y < 2; y++)
    2143. 

  2143. 	  for (x=0; x < width/2; x++) {
    2144. 

  2144. 	    val = (buf[c][y+1][x] << 4) / mul[c];
    2145. 

  2145. 	    if (val < 0) val = 0;
    2146. 

  2146. 	    if (c) RAW(row+y*2+c-1,x*2+2-c) = val;
    2147. 

  2147. 	    else   RAW(row+r*2+y,x*2+y) = val;
    2148. 

  2148. 	  }
    2149. 

  2149. 	memcpy (buf[c][0]+!c, buf[c][2], sizeof buf[c][0]-2*!c);
    2150. 

  2150.       }
    2151. 

  2151.     }
    2152. 

  2152.     for (y=row; y < row+4; y++)
    2153. 

  2153.       for (x=0; x < width; x++)
    2154. 

  2154. 	if ((x+y) & 1) {
    2155. 

  2155. 	  r = x ? x-1 : x+1;
    2156. 

  2156. 	  s = x+1 < width ? x+1 : x-1;
    2157. 

  2157. 	  val = (RAW(y,x)-2048)*2 + (RAW(y,r)+RAW(y,s))/2;
    2158. 

  2158. 	  if (val < 0) val = 0;
    2159. 

  2159. 	  RAW(y,x) = val;
    2160. 

  2160. 	}
    2161. 

  2161.   }
    2162. 

  2162.   for (i=0; i < height*width; i++)
    2163. 

  2163.     raw_image[i] = curve[raw_image[i]];
    2164. 

  2164.   maximum = 0x3fff;
    2165. 

  2165. }
    2166. 

  2166. 

  2167. #undef FORYX
    2168. 

  2168. #undef PREDICTOR
    2169. 

  2169. 

  2170. #ifdef NO_JPEG
    2171. 

  2171. void CLASS kodak_jpeg_load_raw() {}
    2172. 

  2172. void CLASS lossy_dng_load_raw() {}
    2173. 

  2173. #else
    2174. 

  2174. 

  2175. #ifdef LIBRAW_LIBRARY_BUILD
    2176. 

  2176. void CLASS kodak_jpeg_load_raw() {}
    2177. 

  2177. #else
    2178. 

  2178. 

  2179. METHODDEF(boolean)
    2180. 

  2180. fill_input_buffer (j_decompress_ptr cinfo)
    2181. 

  2181. {
    2182. 

  2182. #ifndef LIBRAW_NOTHREADS
    2183. 

  2183. #define jpeg_buffer tls->jpeg_buffer
    2184. 

  2184. #else
    2185. 

  2185.   static uchar jpeg_buffer[4096];
    2186. 

  2186. #endif
    2187. 

  2187.   size_t nbytes;
    2188. 

  2188. 

  2189.   nbytes = fread (jpeg_buffer, 1, 4096, ifp);
    2190. 

  2190.   swab (jpeg_buffer, jpeg_buffer, nbytes);
    2191. 

  2191.   cinfo->src->next_input_byte = jpeg_buffer;
    2192. 

  2192.   cinfo->src->bytes_in_buffer = nbytes;
    2193. 

  2193.   return TRUE;
    2194. 

  2194. #ifndef LIBRAW_NOTHREADS
    2195. 

  2195. #undef jpeg_buffer
    2196. 

  2196. #endif
    2197. 

  2197. }
    2198. 

  2198. 

  2199. void CLASS kodak_jpeg_load_raw()
    2200. 

  2200. {
    2201. 

  2201.   struct jpeg_decompress_struct cinfo;
    2202. 

  2202.   struct jpeg_error_mgr jerr;
    2203. 

  2203.   JSAMPARRAY buf;
    2204. 

  2204.   JSAMPLE (*pixel)[3];
    2205. 

  2205.   int row, col;
    2206. 

  2206. 

  2207.   cinfo.err = jpeg_std_error (&jerr);
    2208. 

  2208.   jpeg_create_decompress (&cinfo);
    2209. 

  2209.   jpeg_stdio_src (&cinfo, ifp);
    2210. 

  2210.   cinfo.src->fill_input_buffer = fill_input_buffer;
    2211. 

  2211.   jpeg_read_header (&cinfo, TRUE);
    2212. 

  2212.   jpeg_start_decompress (&cinfo);
    2213. 

  2213.   if ((cinfo.output_width      != width  ) ||
    2214. 

  2214.       (cinfo.output_height*2   != height ) ||
    2215. 

  2215.       (cinfo.output_components != 3      )) {
    2216. 

  2216. #ifdef DCRAW_VERBOSE
    2217. 

  2217.     fprintf (stderr,_("%s: incorrect JPEG dimensions\n"), ifname);
    2218. 

  2218. #endif
    2219. 

  2219.     jpeg_destroy_decompress (&cinfo);
    2220. 

  2220. #ifdef LIBRAW_LIBRARY_BUILD
    2221. 

  2221.     throw LIBRAW_EXCEPTION_DECODE_JPEG;
    2222. 

  2222. #else
    2223. 

  2223.     longjmp (failure, 3);
    2224. 

  2224. #endif
    2225. 

  2225.   }
    2226. 

  2226.   buf = (*cinfo.mem->alloc_sarray)
    2227. 

  2227. 		((j_common_ptr) &cinfo, JPOOL_IMAGE, width*3, 1);
    2228. 

  2228. 

  2229.   while (cinfo.output_scanline < cinfo.output_height) {
    2230. 

  2230.     row = cinfo.output_scanline * 2;
    2231. 

  2231.     jpeg_read_scanlines (&cinfo, buf, 1);
    2232. 

  2232.     pixel = (JSAMPLE (*)[3]) buf[0];
    2233. 

  2233.     for (col=0; col < width; col+=2) {
    2234. 

  2234.       RAW(row+0,col+0) = pixel[col+0][1] << 1;
    2235. 

  2235.       RAW(row+1,col+1) = pixel[col+1][1] << 1;
    2236. 

  2236.       RAW(row+0,col+1) = pixel[col][0] + pixel[col+1][0];
    2237. 

  2237.       RAW(row+1,col+0) = pixel[col][2] + pixel[col+1][2];
    2238. 

  2238.     }
    2239. 

  2239.   }
    2240. 

  2240.   jpeg_finish_decompress (&cinfo);
    2241. 

  2241.   jpeg_destroy_decompress (&cinfo);
    2242. 

  2242.   maximum = 0xff << 1;
    2243. 

  2243. }
    2244. 

  2244. #endif
    2245. 

  2245. 

  2246. void CLASS lossy_dng_load_raw()
    2247. 

  2247. {
    2248. 

  2248.   struct jpeg_decompress_struct cinfo;
    2249. 

  2249.   struct jpeg_error_mgr jerr;
    2250. 

  2250.   JSAMPARRAY buf;
    2251. 

  2251.   JSAMPLE (*pixel)[3];
    2252. 

  2252.   unsigned sorder=order, ntags, opcode, deg, i, j, c;
    2253. 

  2253.   unsigned save=data_offset-4, trow=0, tcol=0, row, col;
    2254. 

  2254.   ushort t_curve[3][256];
    2255. 

  2255.   double coeff[9], tot;
    2256. 

  2256. 

  2257.   fseek (ifp, meta_offset, SEEK_SET);
    2258. 

  2258.   order = 0x4d4d;
    2259. 

  2259.   ntags = get4();
    2260. 

  2260.   while (ntags--) {
    2261. 

  2261.     opcode = get4(); get4(); get4();
    2262. 

  2262.     if (opcode != 8)
    2263. 

  2263.     { fseek (ifp, get4(), SEEK_CUR); continue; }
    2264. 

  2264.     fseek (ifp, 20, SEEK_CUR);
    2265. 

  2265.     if ((c = get4()) > 2) break;
    2266. 

  2266.     fseek (ifp, 12, SEEK_CUR);
    2267. 

  2267.     if ((deg = get4()) > 8) break;
    2268. 

  2268.     for (i=0; i <= deg && i < 9; i++)
    2269. 

  2269.       coeff[i] = getreal(12);
    2270. 

  2270.     for (i=0; i < 256; i++) {
    2271. 

  2271.       for (tot=j=0; j <= deg; j++)
    2272. 

  2272. 	tot += coeff[j] * pow(i/255.0, (int)j);
    2273. 

  2273.       t_curve[c][i] = tot*0xffff;
    2274. 

  2274.     }
    2275. 

  2275.   }
    2276. 

  2276.   order = sorder;
    2277. 

  2277.   cinfo.err = jpeg_std_error (&jerr);
    2278. 

  2278.   jpeg_create_decompress (&cinfo);
    2279. 

  2279.   while (trow < raw_height) {
    2280. 

  2280.     fseek (ifp, save+=4, SEEK_SET);
    2281. 

  2281.     if (tile_length < INT_MAX)
    2282. 

  2282.       fseek (ifp, get4(), SEEK_SET);
    2283. 

  2283. #ifdef LIBRAW_LIBRARY_BUILD
    2284. 

  2284.     if(libraw_internal_data.internal_data.input->jpeg_src(&cinfo) == -1)
    2285. 

  2285.       {
    2286. 

  2286.         jpeg_destroy_decompress(&cinfo);
    2287. 

  2287.         throw LIBRAW_EXCEPTION_DECODE_JPEG;
    2288. 

  2288.       }
    2289. 

  2289. #else
    2290. 

  2290.     jpeg_stdio_src (&cinfo, ifp);
    2291. 

  2291. #endif
    2292. 

  2292.     jpeg_read_header (&cinfo, TRUE);
    2293. 

  2293.     jpeg_start_decompress (&cinfo);
    2294. 

  2294.     buf = (*cinfo.mem->alloc_sarray)
    2295. 

  2295. 	((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width*3, 1);
    2296. 

  2296.     while (cinfo.output_scanline < cinfo.output_height &&
    2297. 

  2297. 	(row = trow + cinfo.output_scanline) < height) {
    2298. 

  2298.       jpeg_read_scanlines (&cinfo, buf, 1);
    2299. 

  2299.       pixel = (JSAMPLE (*)[3]) buf[0];
    2300. 

  2300.       for (col=0; col < cinfo.output_width && tcol+col < width; col++) {
    2301. 

  2301. 	FORC3 image[row*width+tcol+col][c] = t_curve[c][pixel[col][c]];
    2302. 

  2302.       }
    2303. 

  2303.     }
    2304. 

  2304.     jpeg_abort_decompress (&cinfo);
    2305. 

  2305.     if ((tcol += tile_width) >= raw_width)
    2306. 

  2306.       trow += tile_length + (tcol = 0);
    2307. 

  2307.   }
    2308. 

  2308.   jpeg_destroy_decompress (&cinfo);
    2309. 

  2309.   maximum = 0xffff;
    2310. 

  2310. }
    2311. 

  2311. #endif
    2312. 

  2312. 

  2313. void CLASS kodak_dc120_load_raw()
    2314. 

  2314. {
    2315. 

  2315.   static const int mul[4] = { 162, 192, 187,  92 };
    2316. 

  2316.   static const int add[4] = {   0, 636, 424, 212 };
    2317. 

  2317.   uchar pixel[848];
    2318. 

  2318.   int row, shift, col;
    2319. 

  2319. 

  2320.   for (row=0; row < height; row++) {
    2321. 

  2321.     if (fread (pixel, 1, 848, ifp) < 848) derror();
    2322. 

  2322.     shift = row * mul[row & 3] + add[row & 3];
    2323. 

  2323.     for (col=0; col < width; col++)
    2324. 

  2324.       RAW(row,col) = (ushort) pixel[(col + shift) % 848];
    2325. 

  2325.   }
    2326. 

  2326.   maximum = 0xff;
    2327. 

  2327. }
    2328. 

  2328. 

  2329. void CLASS eight_bit_load_raw()
    2330. 

  2330. {
    2331. 

  2331.   uchar *pixel;
    2332. 

  2332.   unsigned row, col;
    2333. 

  2333. 

  2334.   pixel = (uchar *) calloc (raw_width, sizeof *pixel);
    2335. 

  2335.   merror (pixel, "eight_bit_load_raw()");
    2336. 

  2336.   for (row=0; row < raw_height; row++) {
    2337. 

  2337.     if (fread (pixel, 1, raw_width, ifp) < raw_width) derror();
    2338. 

  2338.     for (col=0; col < raw_width; col++)
    2339. 

  2339.       RAW(row,col) = curve[pixel[col]];
    2340. 

  2340.   }
    2341. 

  2341.   free (pixel);
    2342. 

  2342.   maximum = curve[0xff];
    2343. 

  2343. }
    2344. 

  2344. 

  2345. void CLASS kodak_yrgb_load_raw()
    2346. 

  2346. {
    2347. 

  2347.   uchar *pixel;
    2348. 

  2348.   int row, col, y, cb, cr, rgb[3], c;
    2349. 

  2349. 

  2350.   pixel = (uchar *) calloc (raw_width, 3*sizeof *pixel);
    2351. 

  2351.   merror (pixel, "kodak_yrgb_load_raw()");
    2352. 

  2352.   for (row=0; row < height; row++) {
    2353. 

  2353.     if (~row & 1)
    2354. 

  2354.       if (fread (pixel, raw_width, 3, ifp) < 3) derror();
    2355. 

  2355.     for (col=0; col < raw_width; col++) {
    2356. 

  2356.       y  = pixel[width*2*(row & 1) + col];
    2357. 

  2357.       cb = pixel[width + (col & -2)]   - 128;
    2358. 

  2358.       cr = pixel[width + (col & -2)+1] - 128;
    2359. 

  2359.       rgb[1] = y-((cb + cr + 2) >> 2);
    2360. 

  2360.       rgb[2] = rgb[1] + cb;
    2361. 

  2361.       rgb[0] = rgb[1] + cr;
    2362. 

  2362.       FORC3 image[row*width+col][c] = curve[LIM(rgb[c],0,255)];
    2363. 

  2363.     }
    2364. 

  2364.   }
    2365. 

  2365.   free (pixel);
    2366. 

  2366.   maximum = curve[0xff];
    2367. 

  2367. }
    2368. 

  2368. 

  2369. void CLASS kodak_262_load_raw()
    2370. 

  2370. {
    2371. 

  2371.   static const uchar kodak_tree[2][26] =
    2372. 

  2372.   { { 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 },
    2373. 

  2373.     { 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 } };
    2374. 

  2374.   ushort *huff[2];
    2375. 

  2375.   uchar *pixel;
    2376. 

  2376.   int *strip, ns, c, row, col, chess, pi=0, pi1, pi2, pred, val;
    2377. 

  2377. 

  2378.   FORC(2) huff[c] = make_decoder (kodak_tree[c]);
    2379. 

  2379.   ns = (raw_height+63) >> 5;
    2380. 

  2380.   pixel = (uchar *) malloc (raw_width*32 + ns*4);
    2381. 

  2381.   merror (pixel, "kodak_262_load_raw()");
    2382. 

  2382.   strip = (int *) (pixel + raw_width*32);
    2383. 

  2383.   order = 0x4d4d;
    2384. 

  2384.   FORC(ns) strip[c] = get4();
    2385. 

  2385.   for (row=0; row < raw_height; row++) {
    2386. 

  2386.     if ((row & 31) == 0) {
    2387. 

  2387.       fseek (ifp, strip[row >> 5], SEEK_SET);
    2388. 

  2388.       getbits(-1);
    2389. 

  2389.       pi = 0;
    2390. 

  2390.     }
    2391. 

  2391.     for (col=0; col < raw_width; col++) {
    2392. 

  2392.       chess = (row + col) & 1;
    2393. 

  2393.       pi1 = chess ? pi-2           : pi-raw_width-1;
    2394. 

  2394.       pi2 = chess ? pi-2*raw_width : pi-raw_width+1;
    2395. 

  2395.       if (col <= chess) pi1 = -1;
    2396. 

  2396.       if (pi1 < 0) pi1 = pi2;
    2397. 

  2397.       if (pi2 < 0) pi2 = pi1;
    2398. 

  2398.       if (pi1 < 0 && col > 1) pi1 = pi2 = pi-2;
    2399. 

  2399.       pred = (pi1 < 0) ? 0 : (pixel[pi1] + pixel[pi2]) >> 1;
    2400. 

  2400.       pixel[pi] = val = pred + ljpeg_diff (huff[chess]);
    2401. 

  2401.       if (val >> 8) derror();
    2402. 

  2402.       val = curve[pixel[pi++]];
    2403. 

  2403.       RAW(row,col) = val;
    2404. 

  2404.     }
    2405. 

  2405.   }
    2406. 

  2406.   free (pixel);
    2407. 

  2407.   FORC(2) free (huff[c]);
    2408. 

  2408. }
    2409. 

  2409. 

  2410. int CLASS kodak_65000_decode (short *out, int bsize)
    2411. 

  2411. {
    2412. 

  2412.   uchar c, blen[768];
    2413. 

  2413.   ushort raw[6];
    2414. 

  2414.   INT64 bitbuf=0;
    2415. 

  2415.   int save, bits=0, i, j, len, diff;
    2416. 

  2416. 

  2417.   save = ftell(ifp);
    2418. 

  2418.   bsize = (bsize + 3) & -4;
    2419. 

  2419.   for (i=0; i < bsize; i+=2) {
    2420. 

  2420.     c = fgetc(ifp);
    2421. 

  2421.     if ((blen[i  ] = c & 15) > 12 ||
    2422. 

  2422. 	(blen[i+1] = c >> 4) > 12 ) {
    2423. 

  2423.       fseek (ifp, save, SEEK_SET);
    2424. 

  2424.       for (i=0; i < bsize; i+=8) {
    2425. 

  2425. 	read_shorts (raw, 6);
    2426. 

  2426. 	out[i  ] = raw[0] >> 12 << 8 | raw[2] >> 12 << 4 | raw[4] >> 12;
    2427. 

  2427. 	out[i+1] = raw[1] >> 12 << 8 | raw[3] >> 12 << 4 | raw[5] >> 12;
    2428. 

  2428. 	for (j=0; j < 6; j++)
    2429. 

  2429. 	  out[i+2+j] = raw[j] & 0xfff;
    2430. 

  2430.       }
    2431. 

  2431.       return 1;
    2432. 

  2432.     }
    2433. 

  2433.   }
    2434. 

  2434.   if ((bsize & 7) == 4) {
    2435. 

  2435.     bitbuf  = fgetc(ifp) << 8;
    2436. 

  2436.     bitbuf += fgetc(ifp);
    2437. 

  2437.     bits = 16;
    2438. 

  2438.   }
    2439. 

  2439.   for (i=0; i < bsize; i++) {
    2440. 

  2440.     len = blen[i];
    2441. 

  2441.     if (bits < len) {
    2442. 

  2442.       for (j=0; j < 32; j+=8)
    2443. 

  2443. 	bitbuf += (INT64) fgetc(ifp) << (bits+(j^8));
    2444. 

  2444.       bits += 32;
    2445. 

  2445.     }
    2446. 

  2446.     diff = bitbuf & (0xffff >> (16-len));
    2447. 

  2447.     bitbuf >>= len;
    2448. 

  2448.     bits -= len;
    2449. 

  2449.     if ((diff & (1 << (len-1))) == 0)
    2450. 

  2450.       diff -= (1 << len) - 1;
    2451. 

  2451.     out[i] = diff;
    2452. 

  2452.   }
    2453. 

  2453.   return 0;
    2454. 

  2454. }
    2455. 

  2455. 

  2456. void CLASS kodak_65000_load_raw()
    2457. 

  2457. {
    2458. 

  2458.   short buf[256];
    2459. 

  2459.   int row, col, len, pred[2], ret, i;
    2460. 

  2460. 

  2461.   for (row=0; row < height; row++)
    2462. 

  2462.     for (col=0; col < width; col+=256) {
    2463. 

  2463.       pred[0] = pred[1] = 0;
    2464. 

  2464.       len = MIN (256, width-col);
    2465. 

  2465.       ret = kodak_65000_decode (buf, len);
    2466. 

  2466.       for (i=0; i < len; i++)
    2467. 

  2467. 	if ((RAW(row,col+i) =	curve[ret ? buf[i] :
    2468. 

  2468. 		(pred[i & 1] += buf[i])]) >> 12) derror();
    2469. 

  2469.     }
    2470. 

  2470. }
    2471. 

  2471. 

  2472. void CLASS kodak_ycbcr_load_raw()
    2473. 

  2473. {
    2474. 

  2474.   short buf[384], *bp;
    2475. 

  2475.   int row, col, len, c, i, j, k, y[2][2], cb, cr, rgb[3];
    2476. 

  2476.   ushort *ip;
    2477. 

  2477. 

  2478.   for (row=0; row < height; row+=2)
    2479. 

  2479.     for (col=0; col < width; col+=128) {
    2480. 

  2480.       len = MIN (128, width-col);
    2481. 

  2481.       kodak_65000_decode (buf, len*3);
    2482. 

  2482.       y[0][1] = y[1][1] = cb = cr = 0;
    2483. 

  2483.       for (bp=buf, i=0; i < len; i+=2, bp+=2) {
    2484. 

  2484. 	cb += bp[4];
    2485. 

  2485. 	cr += bp[5];
    2486. 

  2486. 	rgb[1] = -((cb + cr + 2) >> 2);
    2487. 

  2487. 	rgb[2] = rgb[1] + cb;
    2488. 

  2488. 	rgb[0] = rgb[1] + cr;
    2489. 

  2489. 	for (j=0; j < 2; j++)
    2490. 

  2490. 	  for (k=0; k < 2; k++) {
    2491. 

  2491. 	    if ((y[j][k] = y[j][k^1] + *bp++) >> 10) derror();
    2492. 

  2492. 	    ip = image[(row+j)*width + col+i+k];
    2493. 

  2493. 	    FORC3 ip[c] = curve[LIM(y[j][k]+rgb[c], 0, 0xfff)];
    2494. 

  2494. 	  }
    2495. 

  2495.       }
    2496. 

  2496.     }
    2497. 

  2497. }
    2498. 

  2498. 

  2499. void CLASS kodak_rgb_load_raw()
    2500. 

  2500. {
    2501. 

  2501.   short buf[768], *bp;
    2502. 

  2502.   int row, col, len, c, i, rgb[3];
    2503. 

  2503.   ushort *ip=image[0];
    2504. 

  2504. 

  2505. #ifndef LIBRAW_LIBRARY_BUILD
    2506. 

  2506.   if (raw_image) free (raw_image);
    2507. 

  2507.   raw_image = 0;
    2508. 

  2508. #endif
    2509. 

  2509.   for (row=0; row < height; row++)
    2510. 

  2510.     for (col=0; col < width; col+=256) {
    2511. 

  2511.       len = MIN (256, width-col);
    2512. 

  2512.       kodak_65000_decode (buf, len*3);
    2513. 

  2513.       memset (rgb, 0, sizeof rgb);
    2514. 

  2514.       for (bp=buf, i=0; i < len; i++, ip+=4)
    2515. 

  2515. 	FORC3 if ((ip[c] = rgb[c] += *bp++) >> 12) derror();
    2516. 

  2516.     }
    2517. 

  2517. }
    2518. 

  2518. 

  2519. void CLASS kodak_thumb_load_raw()
    2520. 

  2520. {
    2521. 

  2521.   int row, col;
    2522. 

  2522.   colors = thumb_misc >> 5;
    2523. 

  2523.   for (row=0; row < height; row++)
    2524. 

  2524.     for (col=0; col < width; col++)
    2525. 

  2525.       read_shorts (image[row*width+col], colors);
    2526. 

  2526.   maximum = (1 << (thumb_misc & 31)) - 1;
    2527. 

  2527. }
    2528. 

  2528. 

  2529. void CLASS sony_decrypt (unsigned *data, int len, int start, int key)
    2530. 

  2530. {
    2531. 

  2531. #ifndef LIBRAW_NOTHREADS
    2532. 

  2532. #define pad tls->sony_decrypt.pad
    2533. 

  2533. #define p   tls->sony_decrypt.p
    2534. 

  2534. #else
    2535. 

  2535.   static unsigned pad[128], p;
    2536. 

  2536. #endif
    2537. 

  2537.   if (start) {
    2538. 

  2538.     for (p=0; p < 4; p++)
    2539. 

  2539.       pad[p] = key = key * 48828125 + 1;
    2540. 

  2540.     pad[3] = pad[3] << 1 | (pad[0]^pad[2]) >> 31;
    2541. 

  2541.     for (p=4; p < 127; p++)
    2542. 

  2542.       pad[p] = (pad[p-4]^pad[p-2]) << 1 | (pad[p-3]^pad[p-1]) >> 31;
    2543. 

  2543.     for (p=0; p < 127; p++)
    2544. 

  2544.       pad[p] = htonl(pad[p]);
    2545. 

  2545.   }
    2546. 

  2546.   while (len--)
    2547. 

  2547.     *data++ ^= pad[p++ & 127] = pad[(p+1) & 127] ^ pad[(p+65) & 127];
    2548. 

  2548. #ifndef LIBRAW_NOTHREADS
    2549. 

  2549. #undef pad
    2550. 

  2550. #undef p
    2551. 

  2551. #endif
    2552. 

  2552. }
    2553. 

  2553. 

  2554. void CLASS sony_load_raw()
    2555. 

  2555. {
    2556. 

  2556.   uchar head[40];
    2557. 

  2557.   ushort *pixel;
    2558. 

  2558.   unsigned i, key, row, col;
    2559. 

  2559. 

  2560.   fseek (ifp, 200896, SEEK_SET);
    2561. 

  2561.   fseek (ifp, (unsigned) fgetc(ifp)*4 - 1, SEEK_CUR);
    2562. 

  2562.   order = 0x4d4d;
    2563. 

  2563.   key = get4();
    2564. 

  2564.   fseek (ifp, 164600, SEEK_SET);
    2565. 

  2565.   fread (head, 1, 40, ifp);
    2566. 

  2566.   sony_decrypt ((unsigned int *) head, 10, 1, key);
    2567. 

  2567.   for (i=26; i-- > 22; )
    2568. 

  2568.     key = key << 8 | head[i];
    2569. 

  2569.   fseek (ifp, data_offset, SEEK_SET);
    2570. 

  2570.   for (row=0; row < raw_height; row++) {
    2571. 

  2571.     pixel = raw_image + row*raw_width;
    2572. 

  2572.     if (fread (pixel, 2, raw_width, ifp) < raw_width) derror();
    2573. 

  2573.     sony_decrypt ((unsigned int *) pixel, raw_width/2, !row, key);
    2574. 

  2574.     for (col=0; col < raw_width; col++)
    2575. 

  2575.       if ((pixel[col] = ntohs(pixel[col])) >> 14) derror();
    2576. 

  2576.   }
    2577. 

  2577.   maximum = 0x3ff0;
    2578. 

  2578. }
    2579. 

  2579. 

  2580. void CLASS sony_arw_load_raw()
    2581. 

  2581. {
    2582. 

  2582.   ushort huff[32768];
    2583. 

  2583.   static const ushort tab[18] =
    2584. 

  2584.   { 0xf11,0xf10,0xe0f,0xd0e,0xc0d,0xb0c,0xa0b,0x90a,0x809,
    2585. 

  2585.     0x708,0x607,0x506,0x405,0x304,0x303,0x300,0x202,0x201 };
    2586. 

  2586.   int i, c, n, col, row, len, diff, sum=0;
    2587. 

  2587. 

  2588.   for (n=i=0; i < 18; i++)
    2589. 

  2589.     FORC(32768 >> (tab[i] >> 8)) huff[n++] = tab[i];
    2590. 

  2590. #ifdef LIBRAW_LIBRARY_BUILD
    2591. 

  2591.   LibRaw_byte_buffer *buf=NULL;
    2592. 

  2592.   if(data_size)
    2593. 

  2593.       buf = ifp->make_byte_buffer(data_size);
    2594. 

  2594.   else
    2595. 

  2595.       getbits(-1);
    2596. 

  2596.       
    2597. 

  2597.   LibRaw_bit_buffer bits;
    2598. 

  2598.   bits.reset();
    2599. 

  2599. #else
    2600. 

  2600.   getbits(-1);
    2601. 

  2601. #endif
    2602. 

  2602.   for (col = raw_width; col--; )
    2603. 

  2603.     for (row=0; row < raw_height+1; row+=2) {
    2604. 

  2604.       if (row == raw_height) row = 1;
    2605. 

  2605. #ifdef LIBRAW_LIBRARY_BUILD
    2606. 

  2606.       if(data_size)
    2607. 

  2607.           {
    2608. 

  2608.               len = bits._gethuff(buf,15,huff,zero_after_ff);
    2609. 

  2609.               diff = bits._getbits(buf,len,zero_after_ff);
    2610. 

  2610.           }
    2611. 

  2611.       else
    2612. 

  2612.           {
    2613. 

  2613.               len = getbithuff(15,huff);
    2614. 

  2614.               diff = getbits(len);
    2615. 

  2615.           }
    2616. 

  2616. #else
    2617. 

  2617.       len = getbithuff(15,huff);
    2618. 

  2618.       diff = getbits(len);
    2619. 

  2619. #endif
    2620. 

  2620.       if ((diff & (1 << (len-1))) == 0)
    2621. 

  2621. 	diff -= (1 << len) - 1;
    2622. 

  2622.       if ((sum += diff) >> 12) derror();
    2623. 

  2623.       if (row < height) RAW(row,col) = sum;
    2624. 

  2624.     }
    2625. 

  2625. #ifdef LIBRAW_LIBRARY_BUILD
    2626. 

  2626.   if(buf) delete buf;
    2627. 

  2627. #endif
    2628. 

  2628. }
    2629. 

  2629. 

  2630. void CLASS sony_arw2_load_raw()
    2631. 

  2631. {
    2632. 

  2632.   uchar *data, *dp;
    2633. 

  2633.   ushort pix[16];
    2634. 

  2634.   int row, col, val, max, min, imax, imin, sh, bit, i;
    2635. 

  2635. 

  2636.   data = (uchar *) malloc (raw_width);
    2637. 

  2637.   merror (data, "sony_arw2_load_raw()");
    2638. 

  2638.   for (row=0; row < height; row++) {
    2639. 

  2639.     fread (data, 1, raw_width, ifp);
    2640. 

  2640.     for (dp=data, col=0; col < raw_width-30; dp+=16) {
    2641. 

  2641.       max = 0x7ff & (val = sget4(dp));
    2642. 

  2642.       min = 0x7ff & val >> 11;
    2643. 

  2643.       imax = 0x0f & val >> 22;
    2644. 

  2644.       imin = 0x0f & val >> 26;
    2645. 

  2645.       for (sh=0; sh < 4 && 0x80 << sh <= max-min; sh++);
    2646. 

  2646.       for (bit=30, i=0; i < 16; i++)
    2647. 

  2647. 	if      (i == imax) pix[i] = max;
    2648. 

  2648. 	else if (i == imin) pix[i] = min;
    2649. 

  2649. 	else {
    2650. 

  2650. 	  pix[i] = ((sget2(dp+(bit >> 3)) >> (bit & 7) & 0x7f) << sh) + min;
    2651. 

  2651. 	  if (pix[i] > 0x7ff) pix[i] = 0x7ff;
    2652. 

  2652. 	  bit += 7;
    2653. 

  2653. 	}
    2654. 

  2654. #ifdef LIBRAW_LIBRARY_BUILD
    2655. 

  2655.       if(imgdata.params.sony_arw2_hack)
    2656. 

  2656.           {
    2657. 

  2657.               for (i=0; i < 16; i++, col+=2)
    2658. 

  2658.                   RAW(row,col) = curve[pix[i] << 1];
    2659. 

  2659.           }
    2660. 

  2660.       else
    2661. 

  2661.           {
    2662. 

  2662.               for (i=0; i < 16; i++, col+=2)
    2663. 

  2663.                   RAW(row,col) = curve[pix[i] << 1] >> 2;
    2664. 

  2664.           }
    2665. 

  2665. #else
    2666. 

  2666.       for (i=0; i < 16; i++, col+=2)
    2667. 

  2667. 	RAW(row,col) = curve[pix[i] << 1] >> 2;
    2668. 

  2668. #endif
    2669. 

  2669.       col -= col & 1 ? 1:31;
    2670. 

  2670.     }
    2671. 

  2671.   }
    2672. 

  2672.   free (data);
    2673. 

  2673. #ifdef LIBRAW_LIBRARY_BUILD
    2674. 

  2674.   if(imgdata.params.sony_arw2_hack)
    2675. 

  2675.   {
    2676. 

  2676. 	black <<= 2;
    2677. 

  2677. 	maximum <<=2;
    2678. 

  2678.   }
    2679. 

  2679. #endif
    2680. 

  2680. }
    2681. 

  2681. 

  2682. #define HOLE(row) ((holes >> (((row) - raw_height) & 7)) & 1)
    2683. 

  2683. 

  2684. /* Kudos to Rich Taylor for figuring out SMaL's compression algorithm. */
    2685. 

  2685. void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
    2686. 

  2686. {
    2687. 

  2687.   uchar hist[3][13] = {
    2688. 

  2688.     { 7, 7, 0, 0, 63, 55, 47, 39, 31, 23, 15, 7, 0 },
    2689. 

  2689.     { 7, 7, 0, 0, 63, 55, 47, 39, 31, 23, 15, 7, 0 },
    2690. 

  2690.     { 3, 3, 0, 0, 63,     47,     31,     15,    0 } };
    2691. 

  2691.   int low, high=0xff, carry=0, nbits=8;
    2692. 

  2692.   int pix, s, count, bin, next, i, sym[3];
    2693. 

  2693.   uchar diff, pred[]={0,0};
    2694. 

  2694.   ushort data=0, range=0;
    2695. 

  2695. 

  2696.   fseek (ifp, seg[0][1]+1, SEEK_SET);
    2697. 

  2697.   getbits(-1);
    2698. 

  2698.   for (pix=seg[0][0]; pix < seg[1][0]; pix++) {
    2699. 

  2699.     for (s=0; s < 3; s++) {
    2700. 

  2700.       data = data << nbits | getbits(nbits);
    2701. 

  2701.       if (carry < 0)
    2702. 

  2702. 	carry = (nbits += carry+1) < 1 ? nbits-1 : 0;
    2703. 

  2703.       while (--nbits >= 0)
    2704. 

  2704. 	if ((data >> nbits & 0xff) == 0xff) break;
    2705. 

  2705.       if (nbits > 0)
    2706. 

  2706. 	  data = ((data & ((1 << (nbits-1)) - 1)) << 1) |
    2707. 

  2707. 	((data + (((data & (1 << (nbits-1)))) << 1)) & (-1 << nbits));
    2708. 

  2708.       if (nbits >= 0) {
    2709. 

  2709. 	data += getbits(1);
    2710. 

  2710. 	carry = nbits - 8;
    2711. 

  2711.       }
    2712. 

  2712.       count = ((((data-range+1) & 0xffff) << 2) - 1) / (high >> 4);
    2713. 

  2713.       for (bin=0; hist[s][bin+5] > count; bin++);
    2714. 

  2714. 		low = hist[s][bin+5] * (high >> 4) >> 2;
    2715. 

  2715.       if (bin) high = hist[s][bin+4] * (high >> 4) >> 2;
    2716. 

  2716.       high -= low;
    2717. 

  2717.       for (nbits=0; high << nbits < 128; nbits++);
    2718. 

  2718.       range = (range+low) << nbits;
    2719. 

  2719.       high <<= nbits;
    2720. 

  2720.       next = hist[s][1];
    2721. 

  2721.       if (++hist[s][2] > hist[s][3]) {
    2722. 

  2722. 	next = (next+1) & hist[s][0];
    2723. 

  2723. 	hist[s][3] = (hist[s][next+4] - hist[s][next+5]) >> 2;
    2724. 

  2724. 	hist[s][2] = 1;
    2725. 

  2725.       }
    2726. 

  2726.       if (hist[s][hist[s][1]+4] - hist[s][hist[s][1]+5] > 1) {
    2727. 

  2727. 	if (bin < hist[s][1])
    2728. 

  2728. 	  for (i=bin; i < hist[s][1]; i++) hist[s][i+5]--;
    2729. 

  2729. 	else if (next <= bin)
    2730. 

  2730. 	  for (i=hist[s][1]; i < bin; i++) hist[s][i+5]++;
    2731. 

  2731.       }
    2732. 

  2732.       hist[s][1] = next;
    2733. 

  2733.       sym[s] = bin;
    2734. 

  2734.     }
    2735. 

  2735.     diff = sym[2] << 5 | sym[1] << 2 | (sym[0] & 3);
    2736. 

  2736.     if (sym[0] & 4)
    2737. 

  2737.       diff = diff ? -diff : 0x80;
    2738. 

  2738.     if (ftell(ifp) + 12 >= seg[1][1])
    2739. 

  2739.       diff = 0;
    2740. 

  2740.     raw_image[pix] = pred[pix & 1] += diff;
    2741. 

  2741.     if (!(pix & 1) && HOLE(pix / raw_width)) pix += 2;
    2742. 

  2742.   }
    2743. 

  2743.   maximum = 0xff;
    2744. 

  2744. }
    2745. 

  2745. 

  2746. void CLASS smal_v6_load_raw()
    2747. 

  2747. {
    2748. 

  2748.   unsigned seg[2][2];
    2749. 

  2749. 

  2750.   fseek (ifp, 16, SEEK_SET);
    2751. 

  2751.   seg[0][0] = 0;
    2752. 

  2752.   seg[0][1] = get2();
    2753. 

  2753.   seg[1][0] = raw_width * raw_height;
    2754. 

  2754.   seg[1][1] = INT_MAX;
    2755. 

  2755.   smal_decode_segment (seg, 0);
    2756. 

  2756. }
    2757. 

  2757. 

  2758. int CLASS median4 (int *p)
    2759. 

  2759. {
    2760. 

  2760.   int min, max, sum, i;
    2761. 

  2761. 

  2762.   min = max = sum = p[0];
    2763. 

  2763.   for (i=1; i < 4; i++) {
    2764. 

  2764.     sum += p[i];
    2765. 

  2765.     if (min > p[i]) min = p[i];
    2766. 

  2766.     if (max < p[i]) max = p[i];
    2767. 

  2767.   }
    2768. 

  2768.   return (sum - min - max) >> 1;
    2769. 

  2769. }
    2770. 

  2770. 

  2771. void CLASS fill_holes (int holes)
    2772. 

  2772. {
    2773. 

  2773.   int row, col, val[4];
    2774. 

  2774. 

  2775.   for (row=2; row < height-2; row++) {
    2776. 

  2776.     if (!HOLE(row)) continue;
    2777. 

  2777.     for (col=1; col < width-1; col+=4) {
    2778. 

  2778.       val[0] = RAW(row-1,col-1);
    2779. 

  2779.       val[1] = RAW(row-1,col+1);
    2780. 

  2780.       val[2] = RAW(row+1,col-1);
    2781. 

  2781.       val[3] = RAW(row+1,col+1);
    2782. 

  2782.       RAW(row,col) = median4(val);
    2783. 

  2783.     }
    2784. 

  2784.     for (col=2; col < width-2; col+=4)
    2785. 

  2785.       if (HOLE(row-2) || HOLE(row+2))
    2786. 

  2786. 	RAW(row,col) = (RAW(row,col-2) + RAW(row,col+2)) >> 1;
    2787. 

  2787.       else {
    2788. 

  2788. 	val[0] = RAW(row,col-2);
    2789. 

  2789. 	val[1] = RAW(row,col+2);
    2790. 

  2790. 	val[2] = RAW(row-2,col);
    2791. 

  2791. 	val[3] = RAW(row+2,col);
    2792. 

  2792. 	RAW(row,col) = median4(val);
    2793. 

  2793.       }
    2794. 

  2794.   }
    2795. 

  2795. }
    2796. 

  2796. 

  2797. void CLASS smal_v9_load_raw()
    2798. 

  2798. {
    2799. 

  2799.   unsigned seg[256][2], offset, nseg, holes, i;
    2800. 

  2800. 

  2801.   fseek (ifp, 67, SEEK_SET);
    2802. 

  2802.   offset = get4();
    2803. 

  2803.   nseg = fgetc(ifp);
    2804. 

  2804.   fseek (ifp, offset, SEEK_SET);
    2805. 

  2805.   for (i=0; i < nseg*2; i++)
    2806. 

  2806.     seg[0][i] = get4() + data_offset*(i & 1);
    2807. 

  2807.   fseek (ifp, 78, SEEK_SET);
    2808. 

  2808.   holes = fgetc(ifp);
    2809. 

  2809.   fseek (ifp, 88, SEEK_SET);
    2810. 

  2810.   seg[nseg][0] = raw_height * raw_width;
    2811. 

  2811.   seg[nseg][1] = get4() + data_offset;
    2812. 

  2812.   for (i=0; i < nseg; i++)
    2813. 

  2813.     smal_decode_segment (seg+i, holes);
    2814. 

  2814.   if (holes) fill_holes (holes);
    2815. 

  2815. }
    2816. 

  2816. 

  2817. void CLASS redcine_load_raw()
    2818. 

  2818. {
    2819. 

  2819. #ifndef NO_JASPER
    2820. 

  2820.   int c, row, col;
    2821. 

  2821.   jas_stream_t *in;
    2822. 

  2822.   jas_image_t *jimg;
    2823. 

  2823.   jas_matrix_t *jmat;
    2824. 

  2824.   jas_seqent_t *data;
    2825. 

  2825.   ushort *img, *pix;
    2826. 

  2826. 

  2827.   jas_init();
    2828. 

  2828. #ifndef LIBRAW_LIBRARY_BUILD
    2829. 

  2829.   in = jas_stream_fopen (ifname, "rb");
    2830. 

  2830. #else
    2831. 

  2831.   in = (jas_stream_t*)ifp->make_jas_stream();
    2832. 

  2832.   if(!in)
    2833. 

  2833.           throw LIBRAW_EXCEPTION_DECODE_JPEG2000;
    2834. 

  2834. #endif
    2835. 

  2835.   jas_stream_seek (in, data_offset+20, SEEK_SET);
    2836. 

  2836.   jimg = jas_image_decode (in, -1, 0);
    2837. 

  2837. #ifndef LIBRAW_LIBRARY_BUILD
    2838. 

  2838.   if (!jimg) longjmp (failure, 3);
    2839. 

  2839. #else
    2840. 

  2840.   if(!jimg)
    2841. 

  2841.       {
    2842. 

  2842.           jas_stream_close (in);
    2843. 

  2843.           throw LIBRAW_EXCEPTION_DECODE_JPEG2000;
    2844. 

  2844.       }
    2845. 

  2845. #endif
    2846. 

  2846.   jmat = jas_matrix_create (height/2, width/2);
    2847. 

  2847.   merror (jmat, "redcine_load_raw()");
    2848. 

  2848.   img = (ushort *) calloc ((height+2)*(width+2), 2);
    2849. 

  2849.   merror (img, "redcine_load_raw()");
    2850. 

  2850.   FORC4 {
    2851. 

  2851.     jas_image_readcmpt (jimg, c, 0, 0, width/2, height/2, jmat);
    2852. 

  2852.     data = jas_matrix_getref (jmat, 0, 0);
    2853. 

  2853.     for (row = c >> 1; row < height; row+=2)
    2854. 

  2854.       for (col = c & 1; col < width; col+=2)
    2855. 

  2855. 	img[(row+1)*(width+2)+col+1] = data[(row/2)*(width/2)+col/2];
    2856. 

  2856.   }
    2857. 

  2857.   for (col=1; col <= width; col++) {
    2858. 

  2858.     img[col] = img[2*(width+2)+col];
    2859. 

  2859.     img[(height+1)*(width+2)+col] = img[(height-1)*(width+2)+col];
    2860. 

  2860.   }
    2861. 

  2861.   for (row=0; row < height+2; row++) {
    2862. 

  2862.     img[row*(width+2)] = img[row*(width+2)+2];
    2863. 

  2863.     img[(row+1)*(width+2)-1] = img[(row+1)*(width+2)-3];
    2864. 

  2864.   }
    2865. 

  2865.   for (row=1; row <= height; row++) {
    2866. 

  2866.     pix = img + row*(width+2) + (col = 1 + (FC(row,1) & 1));
    2867. 

  2867.     for (   ; col <= width; col+=2, pix+=2) {
    2868. 

  2868.       c = (((pix[0] - 0x800) << 3) +
    2869. 

  2869. 	pix[-(width+2)] + pix[width+2] + pix[-1] + pix[1]) >> 2;
    2870. 

  2870.       pix[0] = LIM(c,0,4095);
    2871. 

  2871.     }
    2872. 

  2872.   }
    2873. 

  2873.   for (row=0; row < height; row++)
    2874. 

  2874.     for (col=0; col < width; col++)
    2875. 

  2875.       RAW(row,col) = curve[img[(row+1)*(width+2)+col+1]];
    2876. 

  2876.   free (img);
    2877. 

  2877.   jas_matrix_destroy (jmat);
    2878. 

  2878.   jas_image_destroy (jimg);
    2879. 

  2879.   jas_stream_close (in);
    2880. 

  2880. #endif
    2881. 

  2881. }
    2882. 

  2882. #line 3860 "dcraw/dcraw.c"
    2883. 

  2883. void CLASS crop_masked_pixels()
    2884. 

  2884. {
    2885. 

  2885.   int row, col;
    2886. 

  2886.   unsigned 
    2887. 

  2887. #ifndef LIBRAW_LIBRARY_BUILD
    2888. 

  2888.     r, raw_pitch = raw_width*2,
    2889. 

  2889. #endif
    2890. 

  2890.     c, m, mblack[8], zero, val;
    2891. 

  2891. 

  2892. #ifndef LIBRAW_LIBRARY_BUILD
    2893. 

  2893.   if (load_raw == &CLASS phase_one_load_raw ||
    2894. 

  2894.       load_raw == &CLASS phase_one_load_raw_c)
    2895. 

  2895.     phase_one_correct();
    2896. 

  2896.   if (fuji_width) {
    2897. 

  2897.     for (row=0; row < raw_height-top_margin*2; row++) {
    2898. 

  2898.       for (col=0; col < fuji_width << !fuji_layout; col++) {
    2899. 

  2899. 	if (fuji_layout) {
    2900. 

  2900. 	  r = fuji_width - 1 - col + (row >> 1);
    2901. 

  2901. 	  c = col + ((row+1) >> 1);
    2902. 

  2902. 	} else {
    2903. 

  2903. 	  r = fuji_width - 1 + row - (col >> 1);
    2904. 

  2904. 	  c = row + ((col+1) >> 1);
    2905. 

  2905. 	}
    2906. 

  2906. 	if (r < height && c < width)
    2907. 

  2907. 	  BAYER(r,c) = RAW(row+top_margin,col+left_margin);
    2908. 

  2908.       }
    2909. 

  2909.     }
    2910. 

  2910.   } else {
    2911. 

  2911.     for (row=0; row < height; row++)
    2912. 

  2912.       for (col=0; col < width; col++)
    2913. 

  2913. 	BAYER2(row,col) = RAW(row+top_margin,col+left_margin);
    2914. 

  2914.   }
    2915. 

  2915. #endif
    2916. 

  2916.   if (mask[0][3]) goto mask_set;
    2917. 

  2917.   if (load_raw == &CLASS canon_load_raw ||
    2918. 

  2918.       load_raw == &CLASS lossless_jpeg_load_raw) {
    2919. 

  2919.     mask[0][1] = mask[1][1] = 2;
    2920. 

  2920.     mask[0][3] = -2;
    2921. 

  2921.     goto sides;
    2922. 

  2922.   }
    2923. 

  2923.   if (load_raw == &CLASS canon_600_load_raw ||
    2924. 

  2924.       load_raw == &CLASS sony_load_raw ||
    2925. 

  2925.      (load_raw == &CLASS eight_bit_load_raw && strncmp(model,"DC2",3)) ||
    2926. 

  2926.       load_raw == &CLASS kodak_262_load_raw ||
    2927. 

  2927.      (load_raw == &CLASS packed_load_raw && (load_flags & 32))) {
    2928. 

  2928. sides:
    2929. 

  2929.     mask[0][0] = mask[1][0] = top_margin;
    2930. 

  2930.     mask[0][2] = mask[1][2] = top_margin+height;
    2931. 

  2931.     mask[0][3] += left_margin;
    2932. 

  2932.     mask[1][1] += left_margin+width;
    2933. 

  2933.     mask[1][3] += raw_width;
    2934. 

  2934.   }
    2935. 

  2935.   if (load_raw == &CLASS nokia_load_raw) {
    2936. 

  2936.     mask[0][2] = top_margin;
    2937. 

  2937.     mask[0][3] = width;
    2938. 

  2938.   }
    2939. 

  2939. mask_set:
    2940. 

  2940.   memset (mblack, 0, sizeof mblack);
    2941. 

  2941.   for (zero=m=0; m < 8; m++)
    2942. 

  2942.     for (row=mask[m][0]; row < mask[m][2]; row++)
    2943. 

  2943.       for (col=mask[m][1]; col < mask[m][3]; col++) {
    2944. 

  2944. 	c = FC(row-top_margin,col-left_margin);
    2945. 

  2945. 	mblack[c] += val = raw_image[(row)*raw_pitch/2+(col)];
    2946. 

  2946. 	mblack[4+c]++;
    2947. 

  2947. 	zero += !val;
    2948. 

  2948.       }
    2949. 

  2949.   if (load_raw == &CLASS canon_600_load_raw && width < raw_width) {
    2950. 

  2950.     black = (mblack[0]+mblack[1]+mblack[2]+mblack[3]) /
    2951. 

  2951. 	    (mblack[4]+mblack[5]+mblack[6]+mblack[7]) - 4;
    2952. 

  2952. #ifndef LIBRAW_LIBRARY_BUILD
    2953. 

  2953.     canon_600_correct();
    2954. 

  2954. #endif
    2955. 

  2955.   } else if (zero < mblack[4] && mblack[5] && mblack[6] && mblack[7])
    2956. 

  2956.     FORC4 cblack[c] = mblack[c] / mblack[4+c];
    2957. 

  2957. }
    2958. 

  2958. 

  2959. void CLASS remove_zeroes()
    2960. 

  2960. {
    2961. 

  2961.   unsigned row, col, tot, n, r, c;
    2962. 

  2962. 

  2963. #ifdef LIBRAW_LIBRARY_BUILD
    2964. 

  2964.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,0,2);
    2965. 

  2965. #endif
    2966. 

  2966. 

  2967.   for (row=0; row < height; row++)
    2968. 

  2968.     for (col=0; col < width; col++)
    2969. 

  2969.       if (BAYER(row,col) == 0) {
    2970. 

  2970. 	tot = n = 0;
    2971. 

  2971. 	for (r = row-2; r <= row+2; r++)
    2972. 

  2972. 	  for (c = col-2; c <= col+2; c++)
    2973. 

  2973. 	    if (r < height && c < width &&
    2974. 

  2974. 		FC(r,c) == FC(row,col) && BAYER(r,c))
    2975. 

  2975. 	      tot += (n++,BAYER(r,c));
    2976. 

  2976. 	if (n) BAYER(row,col) = tot/n;
    2977. 

  2977.       }
    2978. 

  2978. #ifdef LIBRAW_LIBRARY_BUILD
    2979. 

  2979.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,1,2);
    2980. 

  2980. #endif
    2981. 

  2981. }
    2982. 

  2982. #line 4125 "dcraw/dcraw.c"
    2983. 

  2983. void CLASS gamma_curve (double pwr, double ts, int mode, int imax)
    2984. 

  2984. {
    2985. 

  2985.   int i;
    2986. 

  2986.   double g[6], bnd[2]={0,0}, r;
    2987. 

  2987. 

  2988.   g[0] = pwr;
    2989. 

  2989.   g[1] = ts;
    2990. 

  2990.   g[2] = g[3] = g[4] = 0;
    2991. 

  2991.   bnd[g[1] >= 1] = 1;
    2992. 

  2992.   if (g[1] && (g[1]-1)*(g[0]-1) <= 0) {
    2993. 

  2993.     for (i=0; i < 48; i++) {
    2994. 

  2994.       g[2] = (bnd[0] + bnd[1])/2;
    2995. 

  2995.       if (g[0]) bnd[(pow(g[2]/g[1],-g[0]) - 1)/g[0] - 1/g[2] > -1] = g[2];
    2996. 

  2996.       else	bnd[g[2]/exp(1-1/g[2]) < g[1]] = g[2];
    2997. 

  2997.     }
    2998. 

  2998.     g[3] = g[2] / g[1];
    2999. 

  2999.     if (g[0]) g[4] = g[2] * (1/g[0] - 1);
    3000. 

  3000.   }
    3001. 

  3001.   if (g[0]) g[5] = 1 / (g[1]*SQR(g[3])/2 - g[4]*(1 - g[3]) +
    3002. 

  3002. 		(1 - pow(g[3],1+g[0]))*(1 + g[4])/(1 + g[0])) - 1;
    3003. 

  3003.   else      g[5] = 1 / (g[1]*SQR(g[3])/2 + 1
    3004. 

  3004. 		- g[2] - g[3] -	g[2]*g[3]*(log(g[3]) - 1)) - 1;
    3005. 

  3005.   if (!mode--) {
    3006. 

  3006.     memcpy (gamm, g, sizeof gamm);
    3007. 

  3007.     return;
    3008. 

  3008.   }
    3009. 

  3009.   for (i=0; i < 0x10000; i++) {
    3010. 

  3010.     curve[i] = 0xffff;
    3011. 

  3011.     if ((r = (double) i / imax) < 1)
    3012. 

  3012.       curve[i] = 0x10000 * ( mode
    3013. 

  3013. 	? (r < g[3] ? r*g[1] : (g[0] ? pow( r,g[0])*(1+g[4])-g[4]    : log(r)*g[2]+1))
    3014. 

  3014. 	: (r < g[2] ? r/g[1] : (g[0] ? pow((r+g[4])/(1+g[4]),1/g[0]) : exp((r-1)/g[2]))));
    3015. 

  3015.   }
    3016. 

  3016. }
    3017. 

  3017. 

  3018. void CLASS pseudoinverse (double (*in)[3], double (*out)[3], int size)
    3019. 

  3019. {
    3020. 

  3020.   double work[3][6], num;
    3021. 

  3021.   int i, j, k;
    3022. 

  3022. 

  3023.   for (i=0; i < 3; i++) {
    3024. 

  3024.     for (j=0; j < 6; j++)
    3025. 

  3025.       work[i][j] = j == i+3;
    3026. 

  3026.     for (j=0; j < 3; j++)
    3027. 

  3027.       for (k=0; k < size; k++)
    3028. 

  3028. 	work[i][j] += in[k][i] * in[k][j];
    3029. 

  3029.   }
    3030. 

  3030.   for (i=0; i < 3; i++) {
    3031. 

  3031.     num = work[i][i];
    3032. 

  3032.     for (j=0; j < 6; j++)
    3033. 

  3033.       work[i][j] /= num;
    3034. 

  3034.     for (k=0; k < 3; k++) {
    3035. 

  3035.       if (k==i) continue;
    3036. 

  3036.       num = work[k][i];
    3037. 

  3037.       for (j=0; j < 6; j++)
    3038. 

  3038. 	work[k][j] -= work[i][j] * num;
    3039. 

  3039.     }
    3040. 

  3040.   }
    3041. 

  3041.   for (i=0; i < size; i++)
    3042. 

  3042.     for (j=0; j < 3; j++)
    3043. 

  3043.       for (out[i][j]=k=0; k < 3; k++)
    3044. 

  3044. 	out[i][j] += work[j][k+3] * in[i][k];
    3045. 

  3045. }
    3046. 

  3046. 

  3047. void CLASS cam_xyz_coeff (double cam_xyz[4][3])
    3048. 

  3048. {
    3049. 

  3049.   double cam_rgb[4][3], inverse[4][3], num;
    3050. 

  3050.   int i, j, k;
    3051. 

  3051. 

  3052.   for (i=0; i < colors; i++)		/* Multiply out XYZ colorspace */
    3053. 

  3053.     for (j=0; j < 3; j++)
    3054. 

  3054.       for (cam_rgb[i][j] = k=0; k < 3; k++)
    3055. 

  3055. 	cam_rgb[i][j] += cam_xyz[i][k] * xyz_rgb[k][j];
    3056. 

  3056. 

  3057.   for (i=0; i < colors; i++) {		/* Normalize cam_rgb so that */
    3058. 

  3058.     for (num=j=0; j < 3; j++)		/* cam_rgb * (1,1,1) is (1,1,1,1) */
    3059. 

  3059.       num += cam_rgb[i][j];
    3060. 

  3060.     for (j=0; j < 3; j++)
    3061. 

  3061.       cam_rgb[i][j] /= num;
    3062. 

  3062.     pre_mul[i] = 1 / num;
    3063. 

  3063.   }
    3064. 

  3064.   pseudoinverse (cam_rgb, inverse, colors);
    3065. 

  3065.   for (raw_color = i=0; i < 3; i++)
    3066. 

  3066.     for (j=0; j < colors; j++)
    3067. 

  3067.       rgb_cam[i][j] = inverse[j][i];
    3068. 

  3068. }
    3069. 

  3069. 

  3070. #ifdef COLORCHECK
    3071. 

  3071. void CLASS colorcheck()
    3072. 

  3072. {
    3073. 

  3073. #define NSQ 24
    3074. 

  3074. // Coordinates of the GretagMacbeth ColorChecker squares
    3075. 

  3075. // width, height, 1st_column, 1st_row
    3076. 

  3076.   int cut[NSQ][4];			// you must set these
    3077. 

  3077. // ColorChecker Chart under 6500-kelvin illumination
    3078. 

  3078.   static const double gmb_xyY[NSQ][3] = {
    3079. 

  3079.     { 0.400, 0.350, 10.1 },		// Dark Skin
    3080. 

  3080.     { 0.377, 0.345, 35.8 },		// Light Skin
    3081. 

  3081.     { 0.247, 0.251, 19.3 },		// Blue Sky
    3082. 

  3082.     { 0.337, 0.422, 13.3 },		// Foliage
    3083. 

  3083.     { 0.265, 0.240, 24.3 },		// Blue Flower
    3084. 

  3084.     { 0.261, 0.343, 43.1 },		// Bluish Green
    3085. 

  3085.     { 0.506, 0.407, 30.1 },		// Orange
    3086. 

  3086.     { 0.211, 0.175, 12.0 },		// Purplish Blue
    3087. 

  3087.     { 0.453, 0.306, 19.8 },		// Moderate Red
    3088. 

  3088.     { 0.285, 0.202, 6.6 },		// Purple
    3089. 

  3089.     { 0.380, 0.489, 44.3 },		// Yellow Green
    3090. 

  3090.     { 0.473, 0.438, 43.1 },		// Orange Yellow
    3091. 

  3091.     { 0.187, 0.129, 6.1 },		// Blue
    3092. 

  3092.     { 0.305, 0.478, 23.4 },		// Green
    3093. 

  3093.     { 0.539, 0.313, 12.0 },		// Red
    3094. 

  3094.     { 0.448, 0.470, 59.1 },		// Yellow
    3095. 

  3095.     { 0.364, 0.233, 19.8 },		// Magenta
    3096. 

  3096.     { 0.196, 0.252, 19.8 },		// Cyan
    3097. 

  3097.     { 0.310, 0.316, 90.0 },		// White
    3098. 

  3098.     { 0.310, 0.316, 59.1 },		// Neutral 8
    3099. 

  3099.     { 0.310, 0.316, 36.2 },		// Neutral 6.5
    3100. 

  3100.     { 0.310, 0.316, 19.8 },		// Neutral 5
    3101. 

  3101.     { 0.310, 0.316, 9.0 },		// Neutral 3.5
    3102. 

  3102.     { 0.310, 0.316, 3.1 } };		// Black
    3103. 

  3103.   double gmb_cam[NSQ][4], gmb_xyz[NSQ][3];
    3104. 

  3104.   double inverse[NSQ][3], cam_xyz[4][3], num;
    3105. 

  3105.   int c, i, j, k, sq, row, col, count[4];
    3106. 

  3106. 

  3107.   memset (gmb_cam, 0, sizeof gmb_cam);
    3108. 

  3108.   for (sq=0; sq < NSQ; sq++) {
    3109. 

  3109.     FORCC count[c] = 0;
    3110. 

  3110.     for   (row=cut[sq][3]; row < cut[sq][3]+cut[sq][1]; row++)
    3111. 

  3111.       for (col=cut[sq][2]; col < cut[sq][2]+cut[sq][0]; col++) {
    3112. 

  3112. 	c = FC(row,col);
    3113. 

  3113. 	if (c >= colors) c -= 2;
    3114. 

  3114. 	gmb_cam[sq][c] += BAYER(row,col);
    3115. 

  3115. 	count[c]++;
    3116. 

  3116.       }
    3117. 

  3117.     FORCC gmb_cam[sq][c] = gmb_cam[sq][c]/count[c] - black;
    3118. 

  3118.     gmb_xyz[sq][0] = gmb_xyY[sq][2] * gmb_xyY[sq][0] / gmb_xyY[sq][1];
    3119. 

  3119.     gmb_xyz[sq][1] = gmb_xyY[sq][2];
    3120. 

  3120.     gmb_xyz[sq][2] = gmb_xyY[sq][2] *
    3121. 

  3121. 		(1 - gmb_xyY[sq][0] - gmb_xyY[sq][1]) / gmb_xyY[sq][1];
    3122. 

  3122.   }
    3123. 

  3123.   pseudoinverse (gmb_xyz, inverse, NSQ);
    3124. 

  3124.   for (i=0; i < colors; i++)
    3125. 

  3125.     for (j=0; j < 3; j++)
    3126. 

  3126.       for (cam_xyz[i][j] = k=0; k < NSQ; k++)
    3127. 

  3127. 	cam_xyz[i][j] += gmb_cam[k][i] * inverse[k][j];
    3128. 

  3128.   cam_xyz_coeff (cam_xyz);
    3129. 

  3129.   if (verbose) {
    3130. 

  3130.     printf ("    { \"%s %s\", %d,\n\t{", make, model, black);
    3131. 

  3131.     num = 10000 / (cam_xyz[1][0] + cam_xyz[1][1] + cam_xyz[1][2]);
    3132. 

  3132.     FORCC for (j=0; j < 3; j++)
    3133. 

  3133.       printf ("%c%d", (c | j) ? ',':' ', (int) (cam_xyz[c][j] * num + 0.5));
    3134. 

  3134.     puts (" } },");
    3135. 

  3135.   }
    3136. 

  3136. #undef NSQ
    3137. 

  3137. }
    3138. 

  3138. #endif
    3139. 

  3139. 

  3140. void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
    3141. 

  3141. {
    3142. 

  3142.   int i;
    3143. 

  3143.   for (i=0; i < sc; i++)
    3144. 

  3144.     temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
    3145. 

  3145.   for (; i+sc < size; i++)
    3146. 

  3146.     temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
    3147. 

  3147.   for (; i < size; i++)
    3148. 

  3148.     temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
    3149. 

  3149. }
    3150. 

  3150. 

  3151. #if !defined(LIBRAW_USE_OPENMP)
    3152. 

  3152. void CLASS wavelet_denoise()
    3153. 

  3153. {
    3154. 

  3154.   float *fimg=0, *temp, thold, mul[2], avg, diff;
    3155. 

  3155.   int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
    3156. 

  3156.   ushort *window[4];
    3157. 

  3157.   static const float noise[] =
    3158. 

  3158.   { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
    3159. 

  3159. 

  3160. #ifdef DCRAW_VERBOSE
    3161. 

  3161.   if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
    3162. 

  3162. #endif
    3163. 

  3163. 

  3164.   while (maximum << scale < 0x10000) scale++;
    3165. 

  3165.   maximum <<= --scale;
    3166. 

  3166.   black <<= scale;
    3167. 

  3167.   FORC4 cblack[c] <<= scale;
    3168. 

  3168.   if ((size = iheight*iwidth) < 0x15550000)
    3169. 

  3169.     fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
    3170. 

  3170.   merror (fimg, "wavelet_denoise()");
    3171. 

  3171.   temp = fimg + size*3;
    3172. 

  3172.   if ((nc = colors) == 3 && filters) nc++;
    3173. 

  3173.   FORC(nc) {			/* denoise R,G1,B,G3 individually */
    3174. 

  3174.     for (i=0; i < size; i++)
    3175. 

  3175.       fimg[i] = 256 * sqrt((double)(image[i][c] << scale));
    3176. 

  3176.     for (hpass=lev=0; lev < 5; lev++) {
    3177. 

  3177.       lpass = size*((lev & 1)+1);
    3178. 

  3178.       for (row=0; row < iheight; row++) {
    3179. 

  3179. 	hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
    3180. 

  3180. 	for (col=0; col < iwidth; col++)
    3181. 

  3181. 	  fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
    3182. 

  3182.       }
    3183. 

  3183.       for (col=0; col < iwidth; col++) {
    3184. 

  3184. 	hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
    3185. 

  3185. 	for (row=0; row < iheight; row++)
    3186. 

  3186. 	  fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
    3187. 

  3187.       }
    3188. 

  3188.       thold = threshold * noise[lev];
    3189. 

  3189.       for (i=0; i < size; i++) {
    3190. 

  3190. 	fimg[hpass+i] -= fimg[lpass+i];
    3191. 

  3191. 	if	(fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
    3192. 

  3192. 	else if (fimg[hpass+i] >  thold) fimg[hpass+i] -= thold;
    3193. 

  3193. 	else	 fimg[hpass+i] = 0;
    3194. 

  3194. 	if (hpass) fimg[i] += fimg[hpass+i];
    3195. 

  3195.       }
    3196. 

  3196.       hpass = lpass;
    3197. 

  3197.     }
    3198. 

  3198.     for (i=0; i < size; i++)
    3199. 

  3199.       image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
    3200. 

  3200.   }
    3201. 

  3201.   if (filters && colors == 3) {  /* pull G1 and G3 closer together */
    3202. 

  3202.     for (row=0; row < 2; row++) {
    3203. 

  3203.       mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
    3204. 

  3204.       blk[row] = cblack[FC(row,0) | 1];
    3205. 

  3205.     }
    3206. 

  3206.     for (i=0; i < 4; i++)
    3207. 

  3207.       window[i] = (ushort *) fimg + width*i;
    3208. 

  3208.     for (wlast=-1, row=1; row < height-1; row++) {
    3209. 

  3209.       while (wlast < row+1) {
    3210. 

  3210. 	for (wlast++, i=0; i < 4; i++)
    3211. 

  3211. 	  window[(i+3) & 3] = window[i];
    3212. 

  3212. 	for (col = FC(wlast,1) & 1; col < width; col+=2)
    3213. 

  3213. 	  window[2][col] = BAYER(wlast,col);
    3214. 

  3214.       }
    3215. 

  3215.       thold = threshold/512;
    3216. 

  3216.       for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
    3217. 

  3217. 	avg = ( window[0][col-1] + window[0][col+1] +
    3218. 

  3218. 		window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
    3219. 

  3219. 	      * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
    3220. 

  3220. 	avg = avg < 0 ? 0 : sqrt(avg);
    3221. 

  3221. 	diff = sqrt((double)BAYER(row,col)) - avg;
    3222. 

  3222. 	if      (diff < -thold) diff += thold;
    3223. 

  3223. 	else if (diff >  thold) diff -= thold;
    3224. 

  3224. 	else diff = 0;
    3225. 

  3225. 	BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
    3226. 

  3226.       }
    3227. 

  3227.     }
    3228. 

  3228.   }
    3229. 

  3229.   free (fimg);
    3230. 

  3230. }
    3231. 

  3231. #else /* LIBRAW_USE_OPENMP */
    3232. 

  3232. void CLASS wavelet_denoise()
    3233. 

  3233. {
    3234. 

  3234.   float *fimg=0, *temp, thold, mul[2], avg, diff;
    3235. 

  3235.    int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
    3236. 

  3236.   ushort *window[4];
    3237. 

  3237.   static const float noise[] =
    3238. 

  3238.   { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
    3239. 

  3239. 

  3240. #ifdef DCRAW_VERBOSE
    3241. 

  3241.   if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
    3242. 

  3242. #endif
    3243. 

  3243. 

  3244.   while (maximum << scale < 0x10000) scale++;
    3245. 

  3245.   maximum <<= --scale;
    3246. 

  3246.   black <<= scale;
    3247. 

  3247.   FORC4 cblack[c] <<= scale;
    3248. 

  3248.   if ((size = iheight*iwidth) < 0x15550000)
    3249. 

  3249.     fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
    3250. 

  3250.   merror (fimg, "wavelet_denoise()");
    3251. 

  3251.   temp = fimg + size*3;
    3252. 

  3252.   if ((nc = colors) == 3 && filters) nc++;
    3253. 

  3253. #ifdef LIBRAW_LIBRARY_BUILD
    3254. 

  3254. #pragma omp parallel default(shared) private(i,col,row,thold,lev,lpass,hpass,temp,c) firstprivate(scale,size) 
    3255. 

  3255. #endif
    3256. 

  3256.   {
    3257. 

  3257.       temp = (float*)malloc( (iheight + iwidth) * sizeof *fimg);
    3258. 

  3258.     FORC(nc) {			/* denoise R,G1,B,G3 individually */
    3259. 

  3259. #ifdef LIBRAW_LIBRARY_BUILD
    3260. 

  3260. #pragma omp for
    3261. 

  3261. #endif
    3262. 

  3262.       for (i=0; i < size; i++)
    3263. 

  3263.         fimg[i] = 256 * sqrt((double)(image[i][c] << scale));
    3264. 

  3264.       for (hpass=lev=0; lev < 5; lev++) {
    3265. 

  3265. 	lpass = size*((lev & 1)+1);
    3266. 

  3266. #ifdef LIBRAW_LIBRARY_BUILD
    3267. 

  3267. #pragma omp for
    3268. 

  3268. #endif
    3269. 

  3269. 	for (row=0; row < iheight; row++) {
    3270. 

  3270. 	  hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
    3271. 

  3271. 	  for (col=0; col < iwidth; col++)
    3272. 

  3272. 	    fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
    3273. 

  3273. 	}
    3274. 

  3274. #ifdef LIBRAW_LIBRARY_BUILD
    3275. 

  3275. #pragma omp for
    3276. 

  3276. #endif
    3277. 

  3277. 	for (col=0; col < iwidth; col++) {
    3278. 

  3278. 	  hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
    3279. 

  3279. 	  for (row=0; row < iheight; row++)
    3280. 

  3280. 	    fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
    3281. 

  3281. 	}
    3282. 

  3282. 	thold = threshold * noise[lev];
    3283. 

  3283. #ifdef LIBRAW_LIBRARY_BUILD
    3284. 

  3284. #pragma omp for
    3285. 

  3285. #endif
    3286. 

  3286. 	for (i=0; i < size; i++) {
    3287. 

  3287. 	  fimg[hpass+i] -= fimg[lpass+i];
    3288. 

  3288. 	  if	(fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
    3289. 

  3289. 	  else if (fimg[hpass+i] >  thold) fimg[hpass+i] -= thold;
    3290. 

  3290. 	  else	 fimg[hpass+i] = 0;
    3291. 

  3291. 	  if (hpass) fimg[i] += fimg[hpass+i];
    3292. 

  3292. 	}
    3293. 

  3293. 	hpass = lpass;
    3294. 

  3294.       }
    3295. 

  3295. #ifdef LIBRAW_LIBRARY_BUILD
    3296. 

  3296. #pragma omp for
    3297. 

  3297. #endif
    3298. 

  3298.       for (i=0; i < size; i++)
    3299. 

  3299. 	image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
    3300. 

  3300.     }
    3301. 

  3301.     free(temp);
    3302. 

  3302.   } /* end omp parallel */
    3303. 

  3303. /* the following loops are hard to parallize, no idea yes,
    3304. 

  3304.  * problem is wlast which is carrying dependency
    3305. 

  3305.  * second part should be easyer, but did not yet get it right.
    3306. 

  3306.  */
    3307. 

  3307.   if (filters && colors == 3) {  /* pull G1 and G3 closer together */
    3308. 

  3308.    for (row=0; row < 2; row++){
    3309. 

  3309.       mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
    3310. 

  3310.       blk[row] = cblack[FC(row,0) | 1];
    3311. 

  3311.    }
    3312. 

  3312.     for (i=0; i < 4; i++)
    3313. 

  3313.       window[i] = (ushort *) fimg + width*i;
    3314. 

  3314.     for (wlast=-1, row=1; row < height-1; row++) {
    3315. 

  3315.       while (wlast < row+1) {
    3316. 

  3316. 	for (wlast++, i=0; i < 4; i++)
    3317. 

  3317. 	  window[(i+3) & 3] = window[i];
    3318. 

  3318. 	for (col = FC(wlast,1) & 1; col < width; col+=2)
    3319. 

  3319. 	  window[2][col] = BAYER(wlast,col);
    3320. 

  3320.       }
    3321. 

  3321.       thold = threshold/512;
    3322. 

  3322.       for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
    3323. 

  3323. 	avg = ( window[0][col-1] + window[0][col+1] +
    3324. 

  3324. 		window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
    3325. 

  3325. 	      * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
    3326. 

  3326. 	avg = avg < 0 ? 0 : sqrt(avg);
    3327. 

  3327. 	diff = sqrt((double)BAYER(row,col)) - avg;
    3328. 

  3328. 	if      (diff < -thold) diff += thold;
    3329. 

  3329. 	else if (diff >  thold) diff -= thold;
    3330. 

  3330. 	else diff = 0;
    3331. 

  3331. 	BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
    3332. 

  3332.       }
    3333. 

  3333.     }
    3334. 

  3334.   }
    3335. 

  3335.   free (fimg);
    3336. 

  3336. }
    3337. 

  3337. 

  3338. #endif
    3339. 

  3339. 

  3340. // green equilibration
    3341. 

  3341. void CLASS green_matching()
    3342. 

  3342. {
    3343. 

  3343.   int i,j;
    3344. 

  3344.   double m1,m2,c1,c2;
    3345. 

  3345.   int o1_1,o1_2,o1_3,o1_4;
    3346. 

  3346.   int o2_1,o2_2,o2_3,o2_4;
    3347. 

  3347.   ushort (*img)[4];
    3348. 

  3348.   const int margin = 3;
    3349. 

  3349.   int oj = 2, oi = 2;
    3350. 

  3350.   float f;
    3351. 

  3351.   const float thr = 0.01f;
    3352. 

  3352.   if(half_size || shrink) return;
    3353. 

  3353.   if(FC(oj, oi) != 3) oj++;
    3354. 

  3354.   if(FC(oj, oi) != 3) oi++;
    3355. 

  3355.   if(FC(oj, oi) != 3) oj--;
    3356. 

  3356. 

  3357.   img = (ushort (*)[4]) calloc (height*width, sizeof *image);
    3358. 

  3358.   merror (img, "green_matching()");
    3359. 

  3359.   memcpy(img,image,height*width*sizeof *image);
    3360. 

  3360. 

  3361.   for(j=oj;j<height-margin;j+=2)
    3362. 

  3362.     for(i=oi;i<width-margin;i+=2){
    3363. 

  3363.       o1_1=img[(j-1)*width+i-1][1];
    3364. 

  3364.       o1_2=img[(j-1)*width+i+1][1];
    3365. 

  3365.       o1_3=img[(j+1)*width+i-1][1];
    3366. 

  3366.       o1_4=img[(j+1)*width+i+1][1];
    3367. 

  3367.       o2_1=img[(j-2)*width+i][3];
    3368. 

  3368.       o2_2=img[(j+2)*width+i][3];
    3369. 

  3369.       o2_3=img[j*width+i-2][3];
    3370. 

  3370.       o2_4=img[j*width+i+2][3];
    3371. 

  3371. 

  3372.       m1=(o1_1+o1_2+o1_3+o1_4)/4.0;
    3373. 

  3373.       m2=(o2_1+o2_2+o2_3+o2_4)/4.0;
    3374. 

  3374. 

  3375.       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;
    3376. 

  3376.       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;
    3377. 

  3377.       if((img[j*width+i][3]<maximum*0.95)&&(c1<maximum*thr)&&(c2<maximum*thr))
    3378. 

  3378.       {
    3379. 

  3379.         f = image[j*width+i][3]*m1/m2;
    3380. 

  3380.         image[j*width+i][3]=f>0xffff?0xffff:f;
    3381. 

  3381.       }
    3382. 

  3382.     }
    3383. 

  3383.   free(img);
    3384. 

  3384. }
    3385. 

  3385. 

  3386. void CLASS scale_colors()
    3387. 

  3387. {
    3388. 

  3388.   unsigned bottom, right, size, row, col, ur, uc, i, x, y, c, sum[8];
    3389. 

  3389.   int val, dark, sat;
    3390. 

  3390.   double dsum[8], dmin, dmax;
    3391. 

  3391.   float scale_mul[4], fr, fc;
    3392. 

  3392.   ushort *img=0, *pix;
    3393. 

  3393. 

  3394. #ifdef LIBRAW_LIBRARY_BUILD
    3395. 

  3395.   RUN_CALLBACK(LIBRAW_PROGRESS_SCALE_COLORS,0,2);
    3396. 

  3396. #endif
    3397. 

  3397. 

  3398.   if (user_mul[0])
    3399. 

  3399.     memcpy (pre_mul, user_mul, sizeof pre_mul);
    3400. 

  3400.   if (use_auto_wb || (use_camera_wb && cam_mul[0] == -1)) {
    3401. 

  3401.     memset (dsum, 0, sizeof dsum);
    3402. 

  3402.     bottom = MIN (greybox[1]+greybox[3], height);
    3403. 

  3403.     right  = MIN (greybox[0]+greybox[2], width);
    3404. 

  3404.     for (row=greybox[1]; row < bottom; row += 8)
    3405. 

  3405.       for (col=greybox[0]; col < right; col += 8) {
    3406. 

  3406. 	memset (sum, 0, sizeof sum);
    3407. 

  3407. 	for (y=row; y < row+8 && y < bottom; y++)
    3408. 

  3408. 	  for (x=col; x < col+8 && x < right; x++)
    3409. 

  3409. 	    FORC4 {
    3410. 

  3410. 	      if (filters) {
    3411. 

  3411. 		c = fcol(y,x);
    3412. 

  3412. 		val = BAYER2(y,x);
    3413. 

  3413. 	      } else
    3414. 

  3414. 		val = image[y*width+x][c];
    3415. 

  3415. 	      if (val > maximum-25) goto skip_block;
    3416. 

  3416. 	      if ((val -= cblack[c]) < 0) val = 0;
    3417. 

  3417. 	      sum[c] += val;
    3418. 

  3418. 	      sum[c+4]++;
    3419. 

  3419. 	      if (filters) break;
    3420. 

  3420. 	    }
    3421. 

  3421. 	FORC(8) dsum[c] += sum[c];
    3422. 

  3422. skip_block: ;
    3423. 

  3423.       }
    3424. 

  3424.     FORC4 if (dsum[c]) pre_mul[c] = dsum[c+4] / dsum[c];
    3425. 

  3425.   }
    3426. 

  3426.   if (use_camera_wb && cam_mul[0] != -1) {
    3427. 

  3427.     memset (sum, 0, sizeof sum);
    3428. 

  3428.     for (row=0; row < 8; row++)
    3429. 

  3429.       for (col=0; col < 8; col++) {
    3430. 

  3430. 	c = FC(row,col);
    3431. 

  3431. 	if ((val = white[row][col] - cblack[c]) > 0)
    3432. 

  3432. 	  sum[c] += val;
    3433. 

  3433. 	sum[c+4]++;
    3434. 

  3434.       }
    3435. 

  3435.     if (sum[0] && sum[1] && sum[2] && sum[3])
    3436. 

  3436.       FORC4 pre_mul[c] = (float) sum[c+4] / sum[c];
    3437. 

  3437.     else if (cam_mul[0] && cam_mul[2])
    3438. 

  3438.       memcpy (pre_mul, cam_mul, sizeof pre_mul);
    3439. 

  3439.     else
    3440. 

  3440.       {
    3441. 

  3441. #ifdef LIBRAW_LIBRARY_BUILD
    3442. 

  3442.             imgdata.process_warnings |= LIBRAW_WARN_BAD_CAMERA_WB;
    3443. 

  3443. #endif
    3444. 

  3444. #ifdef DCRAW_VERBOSE
    3445. 

  3445.             fprintf (stderr,_("%s: Cannot use camera white balance.\n"), ifname);
    3446. 

  3446. #endif
    3447. 

  3447.       }
    3448. 

  3448.   }
    3449. 

  3449.   if (pre_mul[3] == 0) pre_mul[3] = colors < 4 ? pre_mul[1] : 1;
    3450. 

  3450.   dark = black;
    3451. 

  3451.   sat = maximum;
    3452. 

  3452.   if (threshold) wavelet_denoise();
    3453. 

  3453.   maximum -= black;
    3454. 

  3454.   for (dmin=DBL_MAX, dmax=c=0; c < 4; c++) {
    3455. 

  3455.     if (dmin > pre_mul[c])
    3456. 

  3456. 	dmin = pre_mul[c];
    3457. 

  3457.     if (dmax < pre_mul[c])
    3458. 

  3458. 	dmax = pre_mul[c];
    3459. 

  3459.   }
    3460. 

  3460.   if (!highlight) dmax = dmin;
    3461. 

  3461.   FORC4 scale_mul[c] = (pre_mul[c] /= dmax) * 65535.0 / maximum;
    3462. 

  3462. #ifdef DCRAW_VERBOSE
    3463. 

  3463.   if (verbose) {
    3464. 

  3464.     fprintf (stderr,
    3465. 

  3465.       _("Scaling with darkness %d, saturation %d, and\nmultipliers"), dark, sat);
    3466. 

  3466.     FORC4 fprintf (stderr, " %f", pre_mul[c]);
    3467. 

  3467.     fputc ('\n', stderr);
    3468. 

  3468.   }
    3469. 

  3469. #endif
    3470. 

  3470.   size = iheight*iwidth;
    3471. 

  3471. #ifdef LIBRAW_LIBRARY_BUILD
    3472. 

  3472.   scale_colors_loop(scale_mul);
    3473. 

  3473. #else
    3474. 

  3474.   for (i=0; i < size*4; i++) {
    3475. 

  3475.     val = image[0][i];
    3476. 

  3476.     if (!val) continue;
    3477. 

  3477.     val -= cblack[i & 3];
    3478. 

  3478.     val *= scale_mul[i & 3];
    3479. 

  3479.     image[0][i] = CLIP(val);
    3480. 

  3480.   }
    3481. 

  3481. #endif
    3482. 

  3482.   if ((aber[0] != 1 || aber[2] != 1) && colors == 3) {
    3483. 

  3483. #ifdef DCRAW_VERBOSE
    3484. 

  3484.     if (verbose)
    3485. 

  3485.       fprintf (stderr,_("Correcting chromatic aberration...\n"));
    3486. 

  3486. #endif
    3487. 

  3487.     for (c=0; c < 4; c+=2) {
    3488. 

  3488.       if (aber[c] == 1) continue;
    3489. 

  3489.       img = (ushort *) malloc (size * sizeof *img);
    3490. 

  3490.       merror (img, "scale_colors()");
    3491. 

  3491.       for (i=0; i < size; i++)
    3492. 

  3492. 	img[i] = image[i][c];
    3493. 

  3493.       for (row=0; row < iheight; row++) {
    3494. 

  3494. 	ur = fr = (row - iheight*0.5) * aber[c] + iheight*0.5;
    3495. 

  3495. 	if (ur > iheight-2) continue;
    3496. 

  3496. 	fr -= ur;
    3497. 

  3497. 	for (col=0; col < iwidth; col++) {
    3498. 

  3498. 	  uc = fc = (col - iwidth*0.5) * aber[c] + iwidth*0.5;
    3499. 

  3499. 	  if (uc > iwidth-2) continue;
    3500. 

  3500. 	  fc -= uc;
    3501. 

  3501. 	  pix = img + ur*iwidth + uc;
    3502. 

  3502. 	  image[row*iwidth+col][c] =
    3503. 

  3503. 	    (pix[     0]*(1-fc) + pix[       1]*fc) * (1-fr) +
    3504. 

  3504. 	    (pix[iwidth]*(1-fc) + pix[iwidth+1]*fc) * fr;
    3505. 

  3505. 	}
    3506. 

  3506.       }
    3507. 

  3507.       free(img);
    3508. 

  3508.     }
    3509. 

  3509.   }
    3510. 

  3510. #ifdef LIBRAW_LIBRARY_BUILD
    3511. 

  3511.   RUN_CALLBACK(LIBRAW_PROGRESS_SCALE_COLORS,1,2);
    3512. 

  3512. #endif
    3513. 

  3513. }
    3514. 

  3514. 

  3515. void CLASS pre_interpolate()
    3516. 

  3516. {
    3517. 

  3517.   ushort (*img)[4];
    3518. 

  3518.   int row, col, c;
    3519. 

  3519. #ifdef LIBRAW_LIBRARY_BUILD
    3520. 

  3520.   RUN_CALLBACK(LIBRAW_PROGRESS_PRE_INTERPOLATE,0,2);
    3521. 

  3521. #endif
    3522. 

  3522.   if (shrink) {
    3523. 

  3523.     if (half_size) {
    3524. 

  3524.       height = iheight;
    3525. 

  3525.       width  = iwidth;
    3526. 

  3526.     } else {
    3527. 

  3527.       img = (ushort (*)[4]) calloc (height*width, sizeof *img);
    3528. 

  3528.       merror (img, "pre_interpolate()");
    3529. 

  3529.       for (row=0; row < height; row++)
    3530. 

  3530. 	for (col=0; col < width; col++) {
    3531. 

  3531. 	  c = fcol(row,col);
    3532. 

  3532. 	  img[row*width+col][c] = image[(row >> 1)*iwidth+(col >> 1)][c];
    3533. 

  3533. 	}
    3534. 

  3534.       free (image);
    3535. 

  3535.       image = img;
    3536. 

  3536.       shrink = 0;
    3537. 

  3537.     }
    3538. 

  3538.   }
    3539. 

  3539.   if (filters > 1000 && colors == 3) {
    3540. 

  3540.     if (four_color_rgb && colors++)
    3541. 

  3541.       mix_green = !half_size;
    3542. 

  3542.     else {
    3543. 

  3543.       for (row = FC(1,0) >> 1; row < height; row+=2)
    3544. 

  3544. 	for (col = FC(row,1) & 1; col < width; col+=2)
    3545. 

  3545. 	  image[row*width+col][1] = image[row*width+col][3];
    3546. 

  3546.       filters &= ~((filters & 0x55555555) << 1);
    3547. 

  3547.     }
    3548. 

  3548.   }
    3549. 

  3549.   if (half_size) filters = 0;
    3550. 

  3550. #ifdef LIBRAW_LIBRARY_BUILD
    3551. 

  3551.   RUN_CALLBACK(LIBRAW_PROGRESS_PRE_INTERPOLATE,1,2);
    3552. 

  3552. #endif
    3553. 

  3553. }
    3554. 

  3554. 

  3555. void CLASS border_interpolate (int border)
    3556. 

  3556. {
    3557. 

  3557.   unsigned row, col, y, x, f, c, sum[8];
    3558. 

  3558. 

  3559.   for (row=0; row < height; row++)
    3560. 

  3560.     for (col=0; col < width; col++) {
    3561. 

  3561.       if (col==border && row >= border && row < height-border)
    3562. 

  3562. 	col = width-border;
    3563. 

  3563.       memset (sum, 0, sizeof sum);
    3564. 

  3564.       for (y=row-1; y != row+2; y++)
    3565. 

  3565. 	for (x=col-1; x != col+2; x++)
    3566. 

  3566. 	  if (y < height && x < width) {
    3567. 

  3567. 	    f = fcol(y,x);
    3568. 

  3568. 	    sum[f] += image[y*width+x][f];
    3569. 

  3569. 	    sum[f+4]++;
    3570. 

  3570. 	  }
    3571. 

  3571.       f = fcol(row,col);
    3572. 

  3572.       FORCC if (c != f && sum[c+4])
    3573. 

  3573. 	image[row*width+col][c] = sum[c] / sum[c+4];
    3574. 

  3574.     }
    3575. 

  3575. }
    3576. 

  3576. 

  3577. void CLASS lin_interpolate_loop(int code[16][16][32],int size)
    3578. 

  3578. {
    3579. 

  3579.   int row;
    3580. 

  3580.   for (row=1; row < height-1; row++)
    3581. 

  3581.     {
    3582. 

  3582.       int col,*ip;
    3583. 

  3583.       ushort *pix;
    3584. 

  3584.       for (col=1; col < width-1; col++) {
    3585. 

  3585.         int i;
    3586. 

  3586.         int sum[4];
    3587. 

  3587.         pix = image[row*width+col];
    3588. 

  3588.         ip = code[row % size][col % size];
    3589. 

  3589.         memset (sum, 0, sizeof sum);
    3590. 

  3590.         for (i=*ip++; i--; ip+=3)
    3591. 

  3591.           sum[ip[2]] += pix[ip[0]] << ip[1];
    3592. 

  3592.         for (i=colors; --i; ip+=2)
    3593. 

  3593.           pix[ip[0]] = sum[ip[0]] * ip[1] >> 8;
    3594. 

  3594.       }
    3595. 

  3595.     }
    3596. 

  3596. }
    3597. 

  3597. 

  3598. void CLASS lin_interpolate()
    3599. 

  3599. {
    3600. 

  3600.   int code[16][16][32], size=16, *ip, sum[4];
    3601. 

  3601.   int f, c, x, y, row, col, shift, color;
    3602. 

  3602. 

  3603. 

  3604. #ifdef DCRAW_VERBOSE
    3605. 

  3605.   if (verbose) fprintf (stderr,_("Bilinear interpolation...\n"));
    3606. 

  3606. #endif
    3607. 

  3607. #ifdef LIBRAW_LIBRARY_BUILD
    3608. 

  3608.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,0,3);
    3609. 

  3609. #endif
    3610. 

  3610. 

  3611.   if (filters == 2) size = 6;
    3612. 

  3612.   border_interpolate(1);
    3613. 

  3613.   for (row=0; row < size; row++)
    3614. 

  3614.     for (col=0; col < size; col++) {
    3615. 

  3615.       ip = code[row][col]+1;
    3616. 

  3616.       f = fcol(row,col);
    3617. 

  3617.       memset (sum, 0, sizeof sum);
    3618. 

  3618.       for (y=-1; y <= 1; y++)
    3619. 

  3619. 	for (x=-1; x <= 1; x++) {
    3620. 

  3620. 	  shift = (y==0) + (x==0);
    3621. 

  3621. 	  color = fcol(row+y,col+x);
    3622. 

  3622. 	  if (color == f) continue;
    3623. 

  3623. 	  *ip++ = (width*y + x)*4 + color;
    3624. 

  3624. 	  *ip++ = shift;
    3625. 

  3625. 	  *ip++ = color;
    3626. 

  3626. 	  sum[color] += 1 << shift;
    3627. 

  3627. 	}
    3628. 

  3628.       code[row][col][0] = (ip - code[row][col]) / 3;
    3629. 

  3629.       FORCC
    3630. 

  3630. 	if (c != f) {
    3631. 

  3631. 	  *ip++ = c;
    3632. 

  3632. 	  *ip++ = 256 / sum[c];
    3633. 

  3633. 	}
    3634. 

  3634.     }
    3635. 

  3635. #ifdef LIBRAW_LIBRARY_BUILD
    3636. 

  3636.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,1,3);
    3637. 

  3637. #endif
    3638. 

  3638.   lin_interpolate_loop(code,size);
    3639. 

  3639. #ifdef LIBRAW_LIBRARY_BUILD
    3640. 

  3640.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,2,3);
    3641. 

  3641. #endif
    3642. 

  3642. }
    3643. 

  3643. 

  3644. /*
    3645. 

  3645.    This algorithm is officially called:
    3646. 

    3647. 

  3647.    "Interpolation using a Threshold-based variable number of gradients"
    3648. 

    3649. 

  3649.    described in http://scien.stanford.edu/pages/labsite/1999/psych221/projects/99/tingchen/algodep/vargra.html
    3650. 

    3651. 

  3651.    I've extended the basic idea to work with non-Bayer filter arrays.
    3652. 

  3652.    Gradients are numbered clockwise from NW=0 to W=7.
    3653. 

  3653.  */
    3654. 

  3654. void CLASS vng_interpolate()
    3655. 

  3655. {
    3656. 

  3656.   static const signed char *cp, terms[] = {
    3657. 

  3657.     -2,-2,+0,-1,0,0x01, -2,-2,+0,+0,1,0x01, -2,-1,-1,+0,0,0x01,
    3658. 

  3658.     -2,-1,+0,-1,0,0x02, -2,-1,+0,+0,0,0x03, -2,-1,+0,+1,1,0x01,
    3659. 

  3659.     -2,+0,+0,-1,0,0x06, -2,+0,+0,+0,1,0x02, -2,+0,+0,+1,0,0x03,
    3660. 

  3660.     -2,+1,-1,+0,0,0x04, -2,+1,+0,-1,1,0x04, -2,+1,+0,+0,0,0x06,
    3661. 

  3661.     -2,+1,+0,+1,0,0x02, -2,+2,+0,+0,1,0x04, -2,+2,+0,+1,0,0x04,
    3662. 

  3662.     -1,-2,-1,+0,0,0x80, -1,-2,+0,-1,0,0x01, -1,-2,+1,-1,0,0x01,
    3663. 

  3663.     -1,-2,+1,+0,1,0x01, -1,-1,-1,+1,0,0x88, -1,-1,+1,-2,0,0x40,
    3664. 

  3664.     -1,-1,+1,-1,0,0x22, -1,-1,+1,+0,0,0x33, -1,-1,+1,+1,1,0x11,
    3665. 

  3665.     -1,+0,-1,+2,0,0x08, -1,+0,+0,-1,0,0x44, -1,+0,+0,+1,0,0x11,
    3666. 

  3666.     -1,+0,+1,-2,1,0x40, -1,+0,+1,-1,0,0x66, -1,+0,+1,+0,1,0x22,
    3667. 

  3667.     -1,+0,+1,+1,0,0x33, -1,+0,+1,+2,1,0x10, -1,+1,+1,-1,1,0x44,
    3668. 

  3668.     -1,+1,+1,+0,0,0x66, -1,+1,+1,+1,0,0x22, -1,+1,+1,+2,0,0x10,
    3669. 

  3669.     -1,+2,+0,+1,0,0x04, -1,+2,+1,+0,1,0x04, -1,+2,+1,+1,0,0x04,
    3670. 

  3670.     +0,-2,+0,+0,1,0x80, +0,-1,+0,+1,1,0x88, +0,-1,+1,-2,0,0x40,
    3671. 

  3671.     +0,-1,+1,+0,0,0x11, +0,-1,+2,-2,0,0x40, +0,-1,+2,-1,0,0x20,
    3672. 

  3672.     +0,-1,+2,+0,0,0x30, +0,-1,+2,+1,1,0x10, +0,+0,+0,+2,1,0x08,
    3673. 

  3673.     +0,+0,+2,-2,1,0x40, +0,+0,+2,-1,0,0x60, +0,+0,+2,+0,1,0x20,
    3674. 

  3674.     +0,+0,+2,+1,0,0x30, +0,+0,+2,+2,1,0x10, +0,+1,+1,+0,0,0x44,
    3675. 

  3675.     +0,+1,+1,+2,0,0x10, +0,+1,+2,-1,1,0x40, +0,+1,+2,+0,0,0x60,
    3676. 

  3676.     +0,+1,+2,+1,0,0x20, +0,+1,+2,+2,0,0x10, +1,-2,+1,+0,0,0x80,
    3677. 

  3677.     +1,-1,+1,+1,0,0x88, +1,+0,+1,+2,0,0x08, +1,+0,+2,-1,0,0x40,
    3678. 

  3678.     +1,+0,+2,+1,0,0x10
    3679. 

  3679.   }, chood[] = { -1,-1, -1,0, -1,+1, 0,+1, +1,+1, +1,0, +1,-1, 0,-1 };
    3680. 

  3680.   ushort (*brow[5])[4], *pix;
    3681. 

  3681.   int prow=8, pcol=2, *ip, *code[16][16], gval[8], gmin, gmax, sum[4];
    3682. 

  3682.   int row, col, x, y, x1, x2, y1, y2, t, weight, grads, color, diag;
    3683. 

  3683.   int g, diff, thold, num, c;
    3684. 

  3684. 

  3685.   lin_interpolate();
    3686. 

  3686. #ifdef DCRAW_VERBOSE
    3687. 

  3687.   if (verbose) fprintf (stderr,_("VNG interpolation...\n"));
    3688. 

  3688. #endif
    3689. 

  3689. 

  3690.   if (filters == 1) prow = pcol = 16;
    3691. 

  3691.   if (filters == 2) prow = pcol =  6;
    3692. 

  3692.   ip = (int *) calloc (prow*pcol, 1280);
    3693. 

  3693.   merror (ip, "vng_interpolate()");
    3694. 

  3694.   for (row=0; row < prow; row++)		/* Precalculate for VNG */
    3695. 

  3695.     for (col=0; col < pcol; col++) {
    3696. 

  3696.       code[row][col] = ip;
    3697. 

  3697.       for (cp=terms, t=0; t < 64; t++) {
    3698. 

  3698. 	y1 = *cp++;  x1 = *cp++;
    3699. 

  3699. 	y2 = *cp++;  x2 = *cp++;
    3700. 

  3700. 	weight = *cp++;
    3701. 

  3701. 	grads = *cp++;
    3702. 

  3702. 	color = fcol(row+y1,col+x1);
    3703. 

  3703. 	if (fcol(row+y2,col+x2) != color) continue;
    3704. 

  3704. 	diag = (fcol(row,col+1) == color && fcol(row+1,col) == color) ? 2:1;
    3705. 

  3705. 	if (abs(y1-y2) == diag && abs(x1-x2) == diag) continue;
    3706. 

  3706. 	*ip++ = (y1*width + x1)*4 + color;
    3707. 

  3707. 	*ip++ = (y2*width + x2)*4 + color;
    3708. 

  3708. 	*ip++ = weight;
    3709. 

  3709. 	for (g=0; g < 8; g++)
    3710. 

  3710. 	  if (grads & 1<<g) *ip++ = g;
    3711. 

  3711. 	*ip++ = -1;
    3712. 

  3712.       }
    3713. 

  3713.       *ip++ = INT_MAX;
    3714. 

  3714.       for (cp=chood, g=0; g < 8; g++) {
    3715. 

  3715. 	y = *cp++;  x = *cp++;
    3716. 

  3716. 	*ip++ = (y*width + x) * 4;
    3717. 

  3717. 	color = fcol(row,col);
    3718. 

  3718. 	if (fcol(row+y,col+x) != color && fcol(row+y*2,col+x*2) == color)
    3719. 

  3719. 	  *ip++ = (y*width + x) * 8 + color;
    3720. 

  3720. 	else
    3721. 

  3721. 	  *ip++ = 0;
    3722. 

  3722.       }
    3723. 

  3723.     }
    3724. 

  3724.   brow[4] = (ushort (*)[4]) calloc (width*3, sizeof **brow);
    3725. 

  3725.   merror (brow[4], "vng_interpolate()");
    3726. 

  3726.   for (row=0; row < 3; row++)
    3727. 

  3727.     brow[row] = brow[4] + row*width;
    3728. 

  3728.   for (row=2; row < height-2; row++) {		/* Do VNG interpolation */
    3729. 

  3729. #ifdef LIBRAW_LIBRARY_BUILD
    3730. 

  3730.       if(!((row-2)%256))RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,(row-2)/256+1,((height-3)/256)+1);
    3731. 

  3731. #endif
    3732. 

  3732.     for (col=2; col < width-2; col++) {
    3733. 

  3733.       pix = image[row*width+col];
    3734. 

  3734.       ip = code[row % prow][col % pcol];
    3735. 

  3735.       memset (gval, 0, sizeof gval);
    3736. 

  3736.       while ((g = ip[0]) != INT_MAX) {		/* Calculate gradients */
    3737. 

  3737. 	diff = ABS(pix[g] - pix[ip[1]]) << ip[2];
    3738. 

  3738. 	gval[ip[3]] += diff;
    3739. 

  3739. 	ip += 5;
    3740. 

  3740. 	if ((g = ip[-1]) == -1) continue;
    3741. 

  3741. 	gval[g] += diff;
    3742. 

  3742. 	while ((g = *ip++) != -1)
    3743. 

  3743. 	  gval[g] += diff;
    3744. 

  3744.       }
    3745. 

  3745.       ip++;
    3746. 

  3746.       gmin = gmax = gval[0];			/* Choose a threshold */
    3747. 

  3747.       for (g=1; g < 8; g++) {
    3748. 

  3748. 	if (gmin > gval[g]) gmin = gval[g];
    3749. 

  3749. 	if (gmax < gval[g]) gmax = gval[g];
    3750. 

  3750.       }
    3751. 

  3751.       if (gmax == 0) {
    3752. 

  3752. 	memcpy (brow[2][col], pix, sizeof *image);
    3753. 

  3753. 	continue;
    3754. 

  3754.       }
    3755. 

  3755.       thold = gmin + (gmax >> 1);
    3756. 

  3756.       memset (sum, 0, sizeof sum);
    3757. 

  3757.       color = fcol(row,col);
    3758. 

  3758.       for (num=g=0; g < 8; g++,ip+=2) {		/* Average the neighbors */
    3759. 

  3759. 	if (gval[g] <= thold) {
    3760. 

  3760. 	  FORCC
    3761. 

  3761. 	    if (c == color && ip[1])
    3762. 

  3762. 	      sum[c] += (pix[c] + pix[ip[1]]) >> 1;
    3763. 

  3763. 	    else
    3764. 

  3764. 	      sum[c] += pix[ip[0] + c];
    3765. 

  3765. 	  num++;
    3766. 

  3766. 	}
    3767. 

  3767.       }
    3768. 

  3768.       FORCC {					/* Save to buffer */
    3769. 

  3769. 	t = pix[color];
    3770. 

  3770. 	if (c != color)
    3771. 

  3771. 	  t += (sum[c] - sum[color]) / num;
    3772. 

  3772. 	brow[2][col][c] = CLIP(t);
    3773. 

  3773.       }
    3774. 

  3774.     }
    3775. 

  3775.     if (row > 3)				/* Write buffer to image */
    3776. 

  3776.       memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image);
    3777. 

  3777.     for (g=0; g < 4; g++)
    3778. 

  3778.       brow[(g-1) & 3] = brow[g];
    3779. 

  3779.   }
    3780. 

  3780.   memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image);
    3781. 

  3781.   memcpy (image[(row-1)*width+2], brow[1]+2, (width-4)*sizeof *image);
    3782. 

  3782.   free (brow[4]);
    3783. 

  3783.   free (code[0][0]);
    3784. 

  3784. }
    3785. 

  3785. 

  3786. /*
    3787. 

  3787.    Patterned Pixel Grouping Interpolation by Alain Desbiolles
    3788. 

  3788. */
    3789. 

  3789. void CLASS ppg_interpolate()
    3790. 

  3790. {
    3791. 

  3791.   int dir[5] = { 1, width, -1, -width, 1 };
    3792. 

  3792.   int row, col, diff[2], guess[2], c, d, i;
    3793. 

  3793.   ushort (*pix)[4];
    3794. 

  3794. 

  3795.   border_interpolate(3);
    3796. 

  3796. #ifdef DCRAW_VERBOSE
    3797. 

  3797.   if (verbose) fprintf (stderr,_("PPG interpolation...\n"));
    3798. 

  3798. #endif
    3799. 

  3799. 

  3800. /*  Fill in the green layer with gradients and pattern recognition: */
    3801. 

  3801. #ifdef LIBRAW_LIBRARY_BUILD
    3802. 

  3802.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,0,3);
    3803. 

  3803. #ifdef LIBRAW_USE_OPENMP
    3804. 

  3804. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    3805. 

  3805. #endif
    3806. 

  3806. #endif
    3807. 

  3807.   for (row=3; row < height-3; row++)
    3808. 

  3808.     for (col=3+(FC(row,3) & 1), c=FC(row,col); col < width-3; col+=2) {
    3809. 

  3809.       pix = image + row*width+col;
    3810. 

  3810.       for (i=0; (d=dir[i]) > 0; i++) {
    3811. 

  3811. 	guess[i] = (pix[-d][1] + pix[0][c] + pix[d][1]) * 2
    3812. 

  3812. 		      - pix[-2*d][c] - pix[2*d][c];
    3813. 

  3813. 	diff[i] = ( ABS(pix[-2*d][c] - pix[ 0][c]) +
    3814. 

  3814. 		    ABS(pix[ 2*d][c] - pix[ 0][c]) +
    3815. 

  3815. 		    ABS(pix[  -d][1] - pix[ d][1]) ) * 3 +
    3816. 

  3816. 		  ( ABS(pix[ 3*d][1] - pix[ d][1]) +
    3817. 

  3817. 		    ABS(pix[-3*d][1] - pix[-d][1]) ) * 2;
    3818. 

  3818.       }
    3819. 

  3819.       d = dir[i = diff[0] > diff[1]];
    3820. 

  3820.       pix[0][1] = ULIM(guess[i] >> 2, pix[d][1], pix[-d][1]);
    3821. 

  3821.     }
    3822. 

  3822. /*  Calculate red and blue for each green pixel:		*/
    3823. 

  3823. #ifdef LIBRAW_LIBRARY_BUILD
    3824. 

  3824.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,1,3);
    3825. 

  3825. #ifdef LIBRAW_USE_OPENMP
    3826. 

  3826. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    3827. 

  3827. #endif
    3828. 

  3828. #endif
    3829. 

  3829.   for (row=1; row < height-1; row++)
    3830. 

  3830.     for (col=1+(FC(row,2) & 1), c=FC(row,col+1); col < width-1; col+=2) {
    3831. 

  3831.       pix = image + row*width+col;
    3832. 

  3832.       for (i=0; (d=dir[i]) > 0; c=2-c, i++)
    3833. 

  3833. 	pix[0][c] = CLIP((pix[-d][c] + pix[d][c] + 2*pix[0][1]
    3834. 

  3834. 			- pix[-d][1] - pix[d][1]) >> 1);
    3835. 

  3835.     }
    3836. 

  3836. /*  Calculate blue for red pixels and vice versa:		*/
    3837. 

  3837. #ifdef LIBRAW_LIBRARY_BUILD
    3838. 

  3838.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,2,3);
    3839. 

  3839. #ifdef LIBRAW_USE_OPENMP
    3840. 

  3840. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    3841. 

  3841. #endif
    3842. 

  3842. #endif
    3843. 

  3843.   for (row=1; row < height-1; row++)
    3844. 

  3844.     for (col=1+(FC(row,1) & 1), c=2-FC(row,col); col < width-1; col+=2) {
    3845. 

  3845.       pix = image + row*width+col;
    3846. 

  3846.       for (i=0; (d=dir[i]+dir[i+1]) > 0; i++) {
    3847. 

  3847. 	diff[i] = ABS(pix[-d][c] - pix[d][c]) +
    3848. 

  3848. 		  ABS(pix[-d][1] - pix[0][1]) +
    3849. 

  3849. 		  ABS(pix[ d][1] - pix[0][1]);
    3850. 

  3850. 	guess[i] = pix[-d][c] + pix[d][c] + 2*pix[0][1]
    3851. 

  3851. 		 - pix[-d][1] - pix[d][1];
    3852. 

  3852.       }
    3853. 

  3853.       if (diff[0] != diff[1])
    3854. 

  3854. 	pix[0][c] = CLIP(guess[diff[0] > diff[1]] >> 1);
    3855. 

  3855.       else
    3856. 

  3856. 	pix[0][c] = CLIP((guess[0]+guess[1]) >> 2);
    3857. 

  3857.     }
    3858. 

  3858. }
    3859. 

  3859. 

  3860. #ifdef LIBRAW_LIBRARY_BUILD
    3861. 

  3861. /*
    3862. 

  3862.    Adaptive Homogeneity-Directed interpolation is based on
    3863. 

  3863.    the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
    3864. 

  3864.  */
    3865. 

  3865. #define TS 256		/* Tile Size */
    3866. 

  3866. static float dcraw_cbrt[0x10000] = {-1.0f};
    3867. 

  3867. 

  3868. static inline float calc_64cbrt(float f)
    3869. 

  3869. {
    3870. 

  3870.   unsigned u;
    3871. 

  3871.   static float lower = dcraw_cbrt[0];
    3872. 

  3872.   static float upper = dcraw_cbrt[0xffff];
    3873. 

  3873. 

  3874.   if (f <= 0) {
    3875. 

  3875.     return lower;
    3876. 

  3876.   }
    3877. 

  3877. 

  3878.   u = (unsigned) f;
    3879. 

  3879.   if (u >= 0xffff) {
    3880. 

  3880.     return upper;
    3881. 

  3881.   }
    3882. 

  3882.   return dcraw_cbrt[u];
    3883. 

  3883. }
    3884. 

  3884. void CLASS ahd_interpolate_green_h_and_v(int top, int left, ushort (*out_rgb)[TS][TS][3])
    3885. 

  3885. {
    3886. 

  3886.   int row, col;
    3887. 

  3887.   int c, val;
    3888. 

  3888.   ushort (*pix)[4];
    3889. 

  3889.   const int rowlimit = MIN(top+TS, height-2);
    3890. 

  3890.   const int collimit = MIN(left+TS, width-2);
    3891. 

  3891. 

  3892.   for (row = top; row < rowlimit; row++) {
    3893. 

  3893.     col = left + (FC(row,left) & 1);
    3894. 

  3894.     for (c = FC(row,col); col < collimit; col+=2) {
    3895. 

  3895.       pix = image + row*width+col;
    3896. 

  3896.       val = ((pix[-1][1] + pix[0][c] + pix[1][1]) * 2
    3897. 

  3897.             - pix[-2][c] - pix[2][c]) >> 2;
    3898. 

  3898.       out_rgb[0][row-top][col-left][1] = ULIM(val,pix[-1][1],pix[1][1]);
    3899. 

  3899.       val = ((pix[-width][1] + pix[0][c] + pix[width][1]) * 2
    3900. 

  3900.             - pix[-2*width][c] - pix[2*width][c]) >> 2;
    3901. 

  3901.       out_rgb[1][row-top][col-left][1] = ULIM(val,pix[-width][1],pix[width][1]);
    3902. 

  3902.     }
    3903. 

  3903.   }
    3904. 

  3904. }
    3905. 

  3905. 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])
    3906. 

  3906. {
    3907. 

  3907.   unsigned row, col;
    3908. 

  3908.   int c, val;
    3909. 

  3909.   ushort (*pix)[4];
    3910. 

  3910.   ushort (*rix)[3];
    3911. 

  3911.   short (*lix)[3];
    3912. 

  3912.   float xyz[3];
    3913. 

  3913.   const unsigned num_pix_per_row = 4*width;
    3914. 

  3914.   const unsigned rowlimit = MIN(top+TS-1, height-3);
    3915. 

  3915.   const unsigned collimit = MIN(left+TS-1, width-3);
    3916. 

  3916.   ushort *pix_above;
    3917. 

  3917.   ushort *pix_below;
    3918. 

  3918.   int t1, t2;
    3919. 

  3919. 

  3920.   for (row = top+1; row < rowlimit; row++) {
    3921. 

  3921.     pix = image + row*width + left;
    3922. 

  3922.     rix = &inout_rgb[row-top][0];
    3923. 

  3923.     lix = &out_lab[row-top][0];
    3924. 

  3924. 

  3925.     for (col = left+1; col < collimit; col++) {
    3926. 

  3926.       pix++;
    3927. 

  3927.       pix_above = &pix[0][0] - num_pix_per_row;
    3928. 

  3928.       pix_below = &pix[0][0] + num_pix_per_row;
    3929. 

  3929.       rix++;
    3930. 

  3930.       lix++;
    3931. 

  3931. 

  3932.       c = 2 - FC(row, col);
    3933. 

  3933. 

  3934.       if (c == 1) {
    3935. 

  3935.         c = FC(row+1,col);
    3936. 

  3936. 	t1 = 2-c;
    3937. 

  3937.         val = pix[0][1] + (( pix[-1][t1] + pix[1][t1]
    3938. 

  3938.               - rix[-1][1] - rix[1][1] ) >> 1);
    3939. 

  3939.         rix[0][t1] = CLIP(val);
    3940. 

  3940.         val = pix[0][1] + (( pix_above[c] + pix_below[c]
    3941. 

  3941.               - rix[-TS][1] - rix[TS][1] ) >> 1);
    3942. 

  3942.       } else {
    3943. 

  3943. 	t1 = -4+c; /* -4+c: pixel of color c to the left */
    3944. 

  3944. 	t2 = 4+c; /* 4+c: pixel of color c to the right */
    3945. 

  3945.         val = rix[0][1] + (( pix_above[t1] + pix_above[t2]
    3946. 

  3946.               + pix_below[t1] + pix_below[t2]
    3947. 

  3947.               - rix[-TS-1][1] - rix[-TS+1][1]
    3948. 

  3948.               - rix[+TS-1][1] - rix[+TS+1][1] + 1) >> 2);
    3949. 

  3949.       }
    3950. 

  3950.       rix[0][c] = CLIP(val);
    3951. 

  3951.       c = FC(row,col);
    3952. 

  3952.       rix[0][c] = pix[0][c];
    3953. 

  3953.       xyz[0] = xyz[1] = xyz[2] = 0.5;
    3954. 

  3954.       FORC3 {
    3955. 

  3955. 	/*
    3956. 

  3956. 	 * Technically this ought to be FORCC, but the rest of
    3957. 

  3957. 	 * ahd_interpolate() assumes 3 colors so let's help the compiler.
    3958. 

  3958. 	 */
    3959. 

  3959.         xyz[0] += xyz_cam[0][c] * rix[0][c];
    3960. 

  3960.         xyz[1] += xyz_cam[1][c] * rix[0][c];
    3961. 

  3961.         xyz[2] += xyz_cam[2][c] * rix[0][c];
    3962. 

  3962.       }
    3963. 

  3963.       FORC3 {
    3964. 

  3964. 	xyz[c] = calc_64cbrt(xyz[c]);
    3965. 

  3965.       }
    3966. 

  3966.       lix[0][0] = (116 * xyz[1] - 16);
    3967. 

  3967.       lix[0][1] = 500 * (xyz[0] - xyz[1]);
    3968. 

  3968.       lix[0][2] = 200 * (xyz[1] - xyz[2]);
    3969. 

  3969.     }
    3970. 

  3970.   }
    3971. 

  3971. }
    3972. 

  3972. 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])
    3973. 

  3973. {
    3974. 

  3974.   int direction;
    3975. 

  3975.   for (direction = 0; direction < 2; direction++) {
    3976. 

  3976.     ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(top, left, inout_rgb[direction], out_lab[direction], xyz_cam);
    3977. 

  3977.   }
    3978. 

  3978. }
    3979. 

  3979. void CLASS ahd_interpolate_build_homogeneity_map(int top, int left, short (*lab)[TS][TS][3], char (*out_homogeneity_map)[TS][2])
    3980. 

  3980. {
    3981. 

  3981.   int row, col;
    3982. 

  3982.   int tr, tc;
    3983. 

  3983.   int direction;
    3984. 

  3984.   int i;
    3985. 

  3985.   short (*lix)[3];
    3986. 

  3986.   short (*lixs[2])[3];
    3987. 

  3987.   short *adjacent_lix;
    3988. 

  3988.   unsigned ldiff[2][4], abdiff[2][4], leps, abeps;
    3989. 

  3989.   static const int dir[4] = { -1, 1, -TS, TS };
    3990. 

  3990.   const int rowlimit = MIN(top+TS-2, height-4);
    3991. 

  3991.   const int collimit = MIN(left+TS-2, width-4);
    3992. 

  3992.   int homogeneity;
    3993. 

  3993.   char (*homogeneity_map_p)[2];
    3994. 

  3994. 

  3995.   memset (out_homogeneity_map, 0, 2*TS*TS);
    3996. 

  3996. 

  3997.   for (row=top+2; row < rowlimit; row++) {
    3998. 

  3998.     tr = row-top;
    3999. 

  3999.     homogeneity_map_p = &out_homogeneity_map[tr][1];
    4000. 

  4000.     for (direction=0; direction < 2; direction++) {
    4001. 

  4001.       lixs[direction] = &lab[direction][tr][1];
    4002. 

  4002.     }
    4003. 

  4003. 

  4004.     for (col=left+2; col < collimit; col++) {
    4005. 

  4005.       tc = col-left;
    4006. 

  4006.       homogeneity_map_p++;
    4007. 

  4007. 

  4008.       for (direction=0; direction < 2; direction++) {
    4009. 

  4009.         lix = ++lixs[direction];
    4010. 

  4010.         for (i=0; i < 4; i++) {
    4011. 

  4011. 	  adjacent_lix = lix[dir[i]];
    4012. 

  4012.           ldiff[direction][i] = ABS(lix[0][0]-adjacent_lix[0]);
    4013. 

  4013.           abdiff[direction][i] = SQR(lix[0][1]-adjacent_lix[1])
    4014. 

  4014.             + SQR(lix[0][2]-adjacent_lix[2]);
    4015. 

  4015.         }
    4016. 

  4016.       }
    4017. 

  4017.       leps = MIN(MAX(ldiff[0][0],ldiff[0][1]),
    4018. 

  4018.           MAX(ldiff[1][2],ldiff[1][3]));
    4019. 

  4019.       abeps = MIN(MAX(abdiff[0][0],abdiff[0][1]),
    4020. 

  4020.           MAX(abdiff[1][2],abdiff[1][3]));
    4021. 

  4021.       for (direction=0; direction < 2; direction++) {
    4022. 

  4022. 	homogeneity = 0;
    4023. 

  4023.         for (i=0; i < 4; i++) {
    4024. 

  4024.           if (ldiff[direction][i] <= leps && abdiff[direction][i] <= abeps) {
    4025. 

  4025. 	    homogeneity++;
    4026. 

  4026. 	  }
    4027. 

  4027. 	}
    4028. 

  4028. 	homogeneity_map_p[0][direction] = homogeneity;
    4029. 

  4029.       }
    4030. 

  4030.     }
    4031. 

  4031.   }
    4032. 

  4032. }
    4033. 

  4033. void CLASS ahd_interpolate_combine_homogeneous_pixels(int top, int left, ushort (*rgb)[TS][TS][3], char (*homogeneity_map)[TS][2])
    4034. 

  4034. {
    4035. 

  4035.   int row, col;
    4036. 

  4036.   int tr, tc;
    4037. 

  4037.   int i, j;
    4038. 

  4038.   int direction;
    4039. 

  4039.   int hm[2];
    4040. 

  4040.   int c;
    4041. 

  4041.   const int rowlimit = MIN(top+TS-3, height-5);
    4042. 

  4042.   const int collimit = MIN(left+TS-3, width-5);
    4043. 

  4043. 

  4044.   ushort (*pix)[4];
    4045. 

  4045.   ushort (*rix[2])[3];
    4046. 

  4046. 

  4047.   for (row=top+3; row < rowlimit; row++) {
    4048. 

  4048.     tr = row-top;
    4049. 

  4049.     pix = &image[row*width+left+2];
    4050. 

  4050.     for (direction = 0; direction < 2; direction++) {
    4051. 

  4051.       rix[direction] = &rgb[direction][tr][2];
    4052. 

  4052.     }
    4053. 

  4053. 

  4054.     for (col=left+3; col < collimit; col++) {
    4055. 

  4055.       tc = col-left;
    4056. 

  4056.       pix++;
    4057. 

  4057.       for (direction = 0; direction < 2; direction++) {
    4058. 

  4058.         rix[direction]++;
    4059. 

  4059.       }
    4060. 

  4060. 

  4061.       for (direction=0; direction < 2; direction++) {
    4062. 

  4062.         hm[direction] = 0;
    4063. 

  4063.         for (i=tr-1; i <= tr+1; i++) {
    4064. 

  4064.           for (j=tc-1; j <= tc+1; j++) {
    4065. 

  4065.             hm[direction] += homogeneity_map[i][j][direction];
    4066. 

  4066.           }
    4067. 

  4067.         }
    4068. 

  4068.       }
    4069. 

  4069.       if (hm[0] != hm[1]) {
    4070. 

  4070.         memcpy(pix[0], rix[hm[1] > hm[0]][0], 3 * sizeof(ushort));
    4071. 

  4071.       } else {
    4072. 

  4072.         FORC3 {
    4073. 

  4073.           pix[0][c] = (rix[0][0][c] + rix[1][0][c]) >> 1;
    4074. 

  4074.         }
    4075. 

  4075.       }
    4076. 

  4076.     }
    4077. 

  4077.   }
    4078. 

  4078. }
    4079. 

  4079. void CLASS ahd_interpolate()
    4080. 

  4080. {
    4081. 

  4081.   int i, j, k, top, left;
    4082. 

  4082.   float xyz_cam[3][4],r;
    4083. 

  4083.   char *buffer;
    4084. 

  4084.   ushort (*rgb)[TS][TS][3];
    4085. 

  4085.   short (*lab)[TS][TS][3];
    4086. 

  4086.   char (*homo)[TS][2];
    4087. 

  4087.   int terminate_flag = 0;
    4088. 

  4088. 

  4089.   if(dcraw_cbrt[0]<-0.1){
    4090. 

  4090.       for (i=0x10000-1; i >=0; i--) {
    4091. 

  4091.           r = i / 65535.0;
    4092. 

  4092.           dcraw_cbrt[i] = 64.0*(r > 0.008856 ? pow((double)r,1/3.0) : 7.787*r + 16/116.0);
    4093. 

  4093.       }
    4094. 

  4094.   }
    4095. 

  4095. 

  4096. #ifdef DCRAW_VERBOSE
    4097. 

  4097.   if (verbose) fprintf (stderr,_("AHD interpolation...\n"));
    4098. 

  4098. #endif
    4099. 

  4099. 

  4100.   for (i=0; i < 3; i++) {
    4101. 

  4101.     for (j=0; j < colors; j++) {
    4102. 

  4102.       xyz_cam[i][j] = 0;
    4103. 

  4103.       for (k=0; k < 3; k++) {
    4104. 

  4104.         xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
    4105. 

  4105.       }
    4106. 

  4106.     }
    4107. 

  4107.   }
    4108. 

  4108. 

  4109.   border_interpolate(5);
    4110. 

  4110. 

  4111. #ifdef LIBRAW_LIBRARY_BUILD
    4112. 

  4112. #ifdef LIBRAW_USE_OPENMP
    4113. 

  4113. #pragma omp parallel private(buffer,rgb,lab,homo,top,left,i,j,k) shared(xyz_cam,terminate_flag)
    4114. 

  4114. #endif
    4115. 

  4115. #endif
    4116. 

  4116.   {
    4117. 

  4117.     buffer = (char *) malloc (26*TS*TS);		/* 1664 kB */
    4118. 

  4118.     merror (buffer, "ahd_interpolate()");
    4119. 

  4119.     rgb  = (ushort(*)[TS][TS][3]) buffer;
    4120. 

  4120.     lab  = (short (*)[TS][TS][3])(buffer + 12*TS*TS);
    4121. 

  4121.     homo = (char  (*)[TS][2])    (buffer + 24*TS*TS);
    4122. 

  4122. 

  4123. #ifdef LIBRAW_LIBRARY_BUILD
    4124. 

  4124. #ifdef LIBRAW_USE_OPENMP
    4125. 

  4125. #pragma omp for schedule(dynamic)
    4126. 

  4126. #endif
    4127. 

  4127. #endif
    4128. 

  4128.     for (top=2; top < height-5; top += TS-6){
    4129. 

  4129. #ifdef LIBRAW_LIBRARY_BUILD
    4130. 

  4130. #ifdef LIBRAW_USE_OPENMP
    4131. 

  4131.         if(0== omp_get_thread_num())
    4132. 

  4132. #endif
    4133. 

  4133.            if(callbacks.progress_cb) {                                     
    4134. 

  4134.                int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,LIBRAW_PROGRESS_INTERPOLATE,top-2,height-7);
    4135. 

  4135.                if(rr)
    4136. 

  4136.                    terminate_flag = 1;
    4137. 

  4137.            }
    4138. 

  4138. #endif
    4139. 

  4139.         for (left=2; !terminate_flag && (left < width-5); left += TS-6) {
    4140. 

  4140.             ahd_interpolate_green_h_and_v(top, left, rgb);
    4141. 

  4141.             ahd_interpolate_r_and_b_and_convert_to_cielab(top, left, rgb, lab, xyz_cam);
    4142. 

  4142.             ahd_interpolate_build_homogeneity_map(top, left, lab, homo);
    4143. 

  4143.             ahd_interpolate_combine_homogeneous_pixels(top, left, rgb, homo);
    4144. 

  4144.       }
    4145. 

  4145.     }
    4146. 

  4146.     free (buffer);
    4147. 

  4147.   }
    4148. 

  4148. #ifdef LIBRAW_LIBRARY_BUILD 
    4149. 

  4149.   if(terminate_flag)
    4150. 

  4150.       throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
    4151. 

  4151. #endif
    4152. 

  4152. }
    4153. 

  4153. 

  4154. 

  4155. 

  4156. #undef TS
    4157. 

  4157. 

  4158. #else
    4159. 

  4159. /*
    4160. 

  4160.    Adaptive Homogeneity-Directed interpolation is based on
    4161. 

  4161.    the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
    4162. 

  4162.  */
    4163. 

  4163. #define TS 256		/* Tile Size */
    4164. 

  4164. 

  4165. void CLASS ahd_interpolate()
    4166. 

  4166. {
    4167. 

  4167.   int i, j, k, top, left, row, col, tr, tc, c, d, val, hm[2];
    4168. 

  4168.   ushort (*pix)[4], (*rix)[3];
    4169. 

  4169.   static const int dir[4] = { -1, 1, -TS, TS };
    4170. 

  4170.   unsigned ldiff[2][4], abdiff[2][4], leps, abeps;
    4171. 

  4171.   float r, cbrt[0x10000], xyz[3], xyz_cam[3][4];
    4172. 

  4172.   ushort (*rgb)[TS][TS][3];
    4173. 

  4173.    short (*lab)[TS][TS][3], (*lix)[3];
    4174. 

  4174.    char (*homo)[TS][TS], *buffer;
    4175. 

  4175. 

  4176. #ifdef DCRAW_VERBOSE
    4177. 

  4177.   if (verbose) fprintf (stderr,_("AHD interpolation...\n"));
    4178. 

  4178. #endif
    4179. 

  4179. 

  4180.   for (i=0; i < 0x10000; i++) {
    4181. 

  4181.     r = i / 65535.0;
    4182. 

  4182.     cbrt[i] = r > 0.008856 ? pow((double)r,(double)(1/3.0)) : 7.787*r + 16/116.0;
    4183. 

  4183.   }
    4184. 

  4184.   for (i=0; i < 3; i++)
    4185. 

  4185.     for (j=0; j < colors; j++)
    4186. 

  4186.       for (xyz_cam[i][j] = k=0; k < 3; k++)
    4187. 

  4187. 	xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
    4188. 

  4188. 

  4189.   border_interpolate(5);
    4190. 

  4190.   buffer = (char *) malloc (26*TS*TS);		/* 1664 kB */
    4191. 

  4191.   merror (buffer, "ahd_interpolate()");
    4192. 

  4192.   rgb  = (ushort(*)[TS][TS][3]) buffer;
    4193. 

  4193.   lab  = (short (*)[TS][TS][3])(buffer + 12*TS*TS);
    4194. 

  4194.   homo = (char  (*)[TS][TS])   (buffer + 24*TS*TS);
    4195. 

  4195. 

  4196.   for (top=2; top < height-5; top += TS-6)
    4197. 

  4197.     for (left=2; left < width-5; left += TS-6) {
    4198. 

  4198. 

  4199. /*  Interpolate green horizontally and vertically:		*/
    4200. 

  4200.       for (row = top; row < top+TS && row < height-2; row++) {
    4201. 

  4201. 	col = left + (FC(row,left) & 1);
    4202. 

  4202. 	for (c = FC(row,col); col < left+TS && col < width-2; col+=2) {
    4203. 

  4203. 	  pix = image + row*width+col;
    4204. 

  4204. 	  val = ((pix[-1][1] + pix[0][c] + pix[1][1]) * 2
    4205. 

  4205. 		- pix[-2][c] - pix[2][c]) >> 2;
    4206. 

  4206. 	  rgb[0][row-top][col-left][1] = ULIM(val,pix[-1][1],pix[1][1]);
    4207. 

  4207. 	  val = ((pix[-width][1] + pix[0][c] + pix[width][1]) * 2
    4208. 

  4208. 		- pix[-2*width][c] - pix[2*width][c]) >> 2;
    4209. 

  4209. 	  rgb[1][row-top][col-left][1] = ULIM(val,pix[-width][1],pix[width][1]);
    4210. 

  4210. 	}
    4211. 

  4211.       }
    4212. 

  4212. /*  Interpolate red and blue, and convert to CIELab:		*/
    4213. 

  4213.       for (d=0; d < 2; d++)
    4214. 

  4214. 	for (row=top+1; row < top+TS-1 && row < height-3; row++)
    4215. 

  4215. 	  for (col=left+1; col < left+TS-1 && col < width-3; col++) {
    4216. 

  4216. 	    pix = image + row*width+col;
    4217. 

  4217. 	    rix = &rgb[d][row-top][col-left];
    4218. 

  4218. 	    lix = &lab[d][row-top][col-left];
    4219. 

  4219. 	    if ((c = 2 - FC(row,col)) == 1) {
    4220. 

  4220. 	      c = FC(row+1,col);
    4221. 

  4221. 	      val = pix[0][1] + (( pix[-1][2-c] + pix[1][2-c]
    4222. 

  4222. 				 - rix[-1][1] - rix[1][1] ) >> 1);
    4223. 

  4223. 	      rix[0][2-c] = CLIP(val);
    4224. 

  4224. 	      val = pix[0][1] + (( pix[-width][c] + pix[width][c]
    4225. 

  4225. 				 - rix[-TS][1] - rix[TS][1] ) >> 1);
    4226. 

  4226. 	    } else
    4227. 

  4227. 	      val = rix[0][1] + (( pix[-width-1][c] + pix[-width+1][c]
    4228. 

  4228. 				 + pix[+width-1][c] + pix[+width+1][c]
    4229. 

  4229. 				 - rix[-TS-1][1] - rix[-TS+1][1]
    4230. 

  4230. 				 - rix[+TS-1][1] - rix[+TS+1][1] + 1) >> 2);
    4231. 

  4231. 	    rix[0][c] = CLIP(val);
    4232. 

  4232. 	    c = FC(row,col);
    4233. 

  4233. 	    rix[0][c] = pix[0][c];
    4234. 

  4234. 	    xyz[0] = xyz[1] = xyz[2] = 0.5;
    4235. 

  4235. 	    FORCC {
    4236. 

  4236. 	      xyz[0] += xyz_cam[0][c] * rix[0][c];
    4237. 

  4237. 	      xyz[1] += xyz_cam[1][c] * rix[0][c];
    4238. 

  4238. 	      xyz[2] += xyz_cam[2][c] * rix[0][c];
    4239. 

  4239. 	    }
    4240. 

  4240. 	    xyz[0] = cbrt[CLIP((int) xyz[0])];
    4241. 

  4241. 	    xyz[1] = cbrt[CLIP((int) xyz[1])];
    4242. 

  4242. 	    xyz[2] = cbrt[CLIP((int) xyz[2])];
    4243. 

  4243. 	    lix[0][0] = 64 * (116 * xyz[1] - 16);
    4244. 

  4244. 	    lix[0][1] = 64 * 500 * (xyz[0] - xyz[1]);
    4245. 

  4245. 	    lix[0][2] = 64 * 200 * (xyz[1] - xyz[2]);
    4246. 

  4246. 	  }
    4247. 

  4247. /*  Build homogeneity maps from the CIELab images:		*/
    4248. 

  4248.       memset (homo, 0, 2*TS*TS);
    4249. 

  4249.       for (row=top+2; row < top+TS-2 && row < height-4; row++) {
    4250. 

  4250. 	tr = row-top;
    4251. 

  4251. 	for (col=left+2; col < left+TS-2 && col < width-4; col++) {
    4252. 

  4252. 	  tc = col-left;
    4253. 

  4253. 	  for (d=0; d < 2; d++) {
    4254. 

  4254. 	    lix = &lab[d][tr][tc];
    4255. 

  4255. 	    for (i=0; i < 4; i++) {
    4256. 

  4256. 	       ldiff[d][i] = ABS(lix[0][0]-lix[dir[i]][0]);
    4257. 

  4257. 	      abdiff[d][i] = SQR(lix[0][1]-lix[dir[i]][1])
    4258. 

  4258. 			   + SQR(lix[0][2]-lix[dir[i]][2]);
    4259. 

  4259. 	    }
    4260. 

  4260. 	  }
    4261. 

  4261. 	  leps = MIN(MAX(ldiff[0][0],ldiff[0][1]),
    4262. 

  4262. 		     MAX(ldiff[1][2],ldiff[1][3]));
    4263. 

  4263. 	  abeps = MIN(MAX(abdiff[0][0],abdiff[0][1]),
    4264. 

  4264. 		      MAX(abdiff[1][2],abdiff[1][3]));
    4265. 

  4265. 	  for (d=0; d < 2; d++)
    4266. 

  4266. 	    for (i=0; i < 4; i++)
    4267. 

  4267. 	      if (ldiff[d][i] <= leps && abdiff[d][i] <= abeps)
    4268. 

  4268. 		homo[d][tr][tc]++;
    4269. 

  4269. 	}
    4270. 

  4270.       }
    4271. 

  4271. /*  Combine the most homogenous pixels for the final result:	*/
    4272. 

  4272.       for (row=top+3; row < top+TS-3 && row < height-5; row++) {
    4273. 

  4273. 	tr = row-top;
    4274. 

  4274. 	for (col=left+3; col < left+TS-3 && col < width-5; col++) {
    4275. 

  4275. 	  tc = col-left;
    4276. 

  4276. 	  for (d=0; d < 2; d++)
    4277. 

  4277. 	    for (hm[d]=0, i=tr-1; i <= tr+1; i++)
    4278. 

  4278. 	      for (j=tc-1; j <= tc+1; j++)
    4279. 

  4279. 		hm[d] += homo[d][i][j];
    4280. 

  4280. 	  if (hm[0] != hm[1])
    4281. 

  4281. 	    FORC3 image[row*width+col][c] = rgb[hm[1] > hm[0]][tr][tc][c];
    4282. 

  4282. 	  else
    4283. 

  4283. 	    FORC3 image[row*width+col][c] =
    4284. 

  4284. 		(rgb[0][tr][tc][c] + rgb[1][tr][tc][c]) >> 1;
    4285. 

  4285. 	}
    4286. 

  4286.       }
    4287. 

  4287.     }
    4288. 

  4288.   free (buffer);
    4289. 

  4289. }
    4290. 

  4290. #undef TS
    4291. 

  4291. #endif
    4292. 

  4292. 

  4293. void CLASS median_filter()
    4294. 

  4294. {
    4295. 

  4295.   ushort (*pix)[4];
    4296. 

  4296.   int pass, c, i, j, k, med[9];
    4297. 

  4297.   static const uchar opt[] =	/* Optimal 9-element median search */
    4298. 

  4298.   { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
    4299. 

  4299.     0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
    4300. 

  4300. 

  4301.   for (pass=1; pass <= med_passes; pass++) {
    4302. 

  4302. #ifdef LIBRAW_LIBRARY_BUILD
    4303. 

  4303.       RUN_CALLBACK(LIBRAW_PROGRESS_MEDIAN_FILTER,pass-1,med_passes);
    4304. 

  4304. #endif
    4305. 

  4305. #ifdef DCRAW_VERBOSE
    4306. 

  4306.     if (verbose)
    4307. 

  4307.       fprintf (stderr,_("Median filter pass %d...\n"), pass);
    4308. 

  4308. #endif
    4309. 

  4309.     for (c=0; c < 3; c+=2) {
    4310. 

  4310.       for (pix = image; pix < image+width*height; pix++)
    4311. 

  4311. 	pix[0][3] = pix[0][c];
    4312. 

  4312.       for (pix = image+width; pix < image+width*(height-1); pix++) {
    4313. 

  4313. 	if ((pix-image+1) % width < 2) continue;
    4314. 

  4314. 	for (k=0, i = -width; i <= width; i += width)
    4315. 

  4315. 	  for (j = i-1; j <= i+1; j++)
    4316. 

  4316. 	    med[k++] = pix[j][3] - pix[j][1];
    4317. 

  4317. 	for (i=0; i < sizeof opt; i+=2)
    4318. 

  4318. 	  if     (med[opt[i]] > med[opt[i+1]])
    4319. 

  4319. 	    SWAP (med[opt[i]] , med[opt[i+1]]);
    4320. 

  4320. 	pix[0][c] = CLIP(med[4] + pix[0][1]);
    4321. 

  4321.       }
    4322. 

  4322.     }
    4323. 

  4323.   }
    4324. 

  4324. }
    4325. 

  4325. 

  4326. void CLASS blend_highlights()
    4327. 

  4327. {
    4328. 

  4328.   int clip=INT_MAX, row, col, c, i, j;
    4329. 

  4329.   static const float trans[2][4][4] =
    4330. 

  4330.   { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
    4331. 

  4331.     { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
    4332. 

  4332.   static const float itrans[2][4][4] =
    4333. 

  4333.   { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
    4334. 

  4334.     { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
    4335. 

  4335.   float cam[2][4], lab[2][4], sum[2], chratio;
    4336. 

  4336. 

  4337.   if ((unsigned) (colors-3) > 1) return;
    4338. 

  4338. #ifdef DCRAW_VERBOSE
    4339. 

  4339.   if (verbose) fprintf (stderr,_("Blending highlights...\n"));
    4340. 

  4340. #endif
    4341. 

  4341. #ifdef LIBRAW_LIBRARY_BUILD
    4342. 

  4342.   RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,0,2);
    4343. 

  4343. #endif
    4344. 

  4344.   FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
    4345. 

  4345.   for (row=0; row < height; row++)
    4346. 

  4346.     for (col=0; col < width; col++) {
    4347. 

  4347.       FORCC if (image[row*width+col][c] > clip) break;
    4348. 

  4348.       if (c == colors) continue;
    4349. 

  4349.       FORCC {
    4350. 

  4350. 	cam[0][c] = image[row*width+col][c];
    4351. 

  4351. 	cam[1][c] = MIN(cam[0][c],clip);
    4352. 

  4352.       }
    4353. 

  4353.       for (i=0; i < 2; i++) {
    4354. 

  4354. 	FORCC for (lab[i][c]=j=0; j < colors; j++)
    4355. 

  4355. 	  lab[i][c] += trans[colors-3][c][j] * cam[i][j];
    4356. 

  4356. 	for (sum[i]=0,c=1; c < colors; c++)
    4357. 

  4357. 	  sum[i] += SQR(lab[i][c]);
    4358. 

  4358.       }
    4359. 

  4359.       chratio = sqrt(sum[1]/sum[0]);
    4360. 

  4360.       for (c=1; c < colors; c++)
    4361. 

  4361. 	lab[0][c] *= chratio;
    4362. 

  4362.       FORCC for (cam[0][c]=j=0; j < colors; j++)
    4363. 

  4363. 	cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
    4364. 

  4364.       FORCC image[row*width+col][c] = cam[0][c] / colors;
    4365. 

  4365.     }
    4366. 

  4366. #ifdef LIBRAW_LIBRARY_BUILD
    4367. 

  4367.   RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,1,2);
    4368. 

  4368. #endif
    4369. 

  4369. }
    4370. 

  4370. 

  4371. #define SCALE (4 >> shrink)
    4372. 

  4372. void CLASS recover_highlights()
    4373. 

  4373. {
    4374. 

  4374.   float *map, sum, wgt, grow;
    4375. 

  4375.   int hsat[4], count, spread, change, val, i;
    4376. 

  4376.   unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
    4377. 

  4377.   ushort *pixel;
    4378. 

  4378.   static const signed char dir[8][2] =
    4379. 

  4379.     { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
    4380. 

  4380. 

  4381. #ifdef DCRAW_VERBOSE
    4382. 

  4382.   if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
    4383. 

  4383. #endif
    4384. 

  4384. 

  4385.   grow = pow (2.0, 4-highlight);
    4386. 

  4386.   FORCC hsat[c] = 32000 * pre_mul[c];
    4387. 

  4387.   for (kc=0, c=1; c < colors; c++)
    4388. 

  4388.     if (pre_mul[kc] < pre_mul[c]) kc = c;
    4389. 

  4389.   high = height / SCALE;
    4390. 

  4390.   wide =  width / SCALE;
    4391. 

  4391.   map = (float *) calloc (high*wide, sizeof *map);
    4392. 

  4392.   merror (map, "recover_highlights()");
    4393. 

  4393.   FORCC if (c != kc) {
    4394. 

  4394. #ifdef LIBRAW_LIBRARY_BUILD
    4395. 

  4395.       RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,c-1,colors-1);
    4396. 

  4396. #endif
    4397. 

  4397.     memset (map, 0, high*wide*sizeof *map);
    4398. 

  4398.     for (mrow=0; mrow < high; mrow++)
    4399. 

  4399.       for (mcol=0; mcol < wide; mcol++) {
    4400. 

  4400. 	sum = wgt = count = 0;
    4401. 

  4401. 	for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
    4402. 

  4402. 	  for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
    4403. 

  4403. 	    pixel = image[row*width+col];
    4404. 

  4404. 	    if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
    4405. 

  4405. 	      sum += pixel[c];
    4406. 

  4406. 	      wgt += pixel[kc];
    4407. 

  4407. 	      count++;
    4408. 

  4408. 	    }
    4409. 

  4409. 	  }
    4410. 

  4410. 	if (count == SCALE*SCALE)
    4411. 

  4411. 	  map[mrow*wide+mcol] = sum / wgt;
    4412. 

  4412.       }
    4413. 

  4413.     for (spread = 32/grow; spread--; ) {
    4414. 

  4414.       for (mrow=0; mrow < high; mrow++)
    4415. 

  4415. 	for (mcol=0; mcol < wide; mcol++) {
    4416. 

  4416. 	  if (map[mrow*wide+mcol]) continue;
    4417. 

  4417. 	  sum = count = 0;
    4418. 

  4418. 	  for (d=0; d < 8; d++) {
    4419. 

  4419. 	    y = mrow + dir[d][0];
    4420. 

  4420. 	    x = mcol + dir[d][1];
    4421. 

  4421. 	    if (y < high && x < wide && map[y*wide+x] > 0) {
    4422. 

  4422. 	      sum  += (1 + (d & 1)) * map[y*wide+x];
    4423. 

  4423. 	      count += 1 + (d & 1);
    4424. 

  4424. 	    }
    4425. 

  4425. 	  }
    4426. 

  4426. 	  if (count > 3)
    4427. 

  4427. 	    map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
    4428. 

  4428. 	}
    4429. 

  4429.       for (change=i=0; i < high*wide; i++)
    4430. 

  4430. 	if (map[i] < 0) {
    4431. 

  4431. 	  map[i] = -map[i];
    4432. 

  4432. 	  change = 1;
    4433. 

  4433. 	}
    4434. 

  4434.       if (!change) break;
    4435. 

  4435.     }
    4436. 

  4436.     for (i=0; i < high*wide; i++)
    4437. 

  4437.       if (map[i] == 0) map[i] = 1;
    4438. 

  4438.     for (mrow=0; mrow < high; mrow++)
    4439. 

  4439.       for (mcol=0; mcol < wide; mcol++) {
    4440. 

  4440. 	for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
    4441. 

  4441. 	  for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
    4442. 

  4442. 	    pixel = image[row*width+col];
    4443. 

  4443. 	    if (pixel[c] / hsat[c] > 1) {
    4444. 

  4444. 	      val = pixel[kc] * map[mrow*wide+mcol];
    4445. 

  4445. 	      if (pixel[c] < val) pixel[c] = CLIP(val);
    4446. 

  4446. 	    }
    4447. 

  4447. 	  }
    4448. 

  4448.       }
    4449. 

  4449.   }
    4450. 

  4450.   free (map);
    4451. 

  4451. }
    4452. 

  4452. #undef SCALE
    4453. 

  4453. 

  4454. void CLASS tiff_get (unsigned base,
    4455. 

  4455. 	unsigned *tag, unsigned *type, unsigned *len, unsigned *save)
    4456. 

  4456. {
    4457. 

  4457.   *tag  = get2();
    4458. 

  4458.   *type = get2();
    4459. 

  4459.   *len  = get4();
    4460. 

  4460.   *save = ftell(ifp) + 4;
    4461. 

  4461.   if (*len * ("11124811248488"[*type < 14 ? *type:0]-'0') > 4)
    4462. 

  4462.     fseek (ifp, get4()+base, SEEK_SET);
    4463. 

  4463. }
    4464. 

  4464. 

  4465. void CLASS parse_thumb_note (int base, unsigned toff, unsigned tlen)
    4466. 

  4466. {
    4467. 

  4467.   unsigned entries, tag, type, len, save;
    4468. 

  4468. 

  4469.   entries = get2();
    4470. 

  4470.   while (entries--) {
    4471. 

  4471.     tiff_get (base, &tag, &type, &len, &save);
    4472. 

  4472.     if (tag == toff) thumb_offset = get4()+base;
    4473. 

  4473.     if (tag == tlen) thumb_length = get4();
    4474. 

  4474.     fseek (ifp, save, SEEK_SET);
    4475. 

  4475.   }
    4476. 

  4476. }
    4477. 

  4477. #line 5624 "dcraw/dcraw.c"
    4478. 

  4478. void CLASS parse_makernote (int base, int uptag)
    4479. 

  4479. {
    4480. 

  4480.   static const uchar xlat[2][256] = {
    4481. 

  4481.   { 0xc1,0xbf,0x6d,0x0d,0x59,0xc5,0x13,0x9d,0x83,0x61,0x6b,0x4f,0xc7,0x7f,0x3d,0x3d,
    4482. 

  4482.     0x53,0x59,0xe3,0xc7,0xe9,0x2f,0x95,0xa7,0x95,0x1f,0xdf,0x7f,0x2b,0x29,0xc7,0x0d,
    4483. 

  4483.     0xdf,0x07,0xef,0x71,0x89,0x3d,0x13,0x3d,0x3b,0x13,0xfb,0x0d,0x89,0xc1,0x65,0x1f,
    4484. 

  4484.     0xb3,0x0d,0x6b,0x29,0xe3,0xfb,0xef,0xa3,0x6b,0x47,0x7f,0x95,0x35,0xa7,0x47,0x4f,
    4485. 

  4485.     0xc7,0xf1,0x59,0x95,0x35,0x11,0x29,0x61,0xf1,0x3d,0xb3,0x2b,0x0d,0x43,0x89,0xc1,
    4486. 

  4486.     0x9d,0x9d,0x89,0x65,0xf1,0xe9,0xdf,0xbf,0x3d,0x7f,0x53,0x97,0xe5,0xe9,0x95,0x17,
    4487. 

  4487.     0x1d,0x3d,0x8b,0xfb,0xc7,0xe3,0x67,0xa7,0x07,0xf1,0x71,0xa7,0x53,0xb5,0x29,0x89,
    4488. 

  4488.     0xe5,0x2b,0xa7,0x17,0x29,0xe9,0x4f,0xc5,0x65,0x6d,0x6b,0xef,0x0d,0x89,0x49,0x2f,
    4489. 

  4489.     0xb3,0x43,0x53,0x65,0x1d,0x49,0xa3,0x13,0x89,0x59,0xef,0x6b,0xef,0x65,0x1d,0x0b,
    4490. 

  4490.     0x59,0x13,0xe3,0x4f,0x9d,0xb3,0x29,0x43,0x2b,0x07,0x1d,0x95,0x59,0x59,0x47,0xfb,
    4491. 

  4491.     0xe5,0xe9,0x61,0x47,0x2f,0x35,0x7f,0x17,0x7f,0xef,0x7f,0x95,0x95,0x71,0xd3,0xa3,
    4492. 

  4492.     0x0b,0x71,0xa3,0xad,0x0b,0x3b,0xb5,0xfb,0xa3,0xbf,0x4f,0x83,0x1d,0xad,0xe9,0x2f,
    4493. 

  4493.     0x71,0x65,0xa3,0xe5,0x07,0x35,0x3d,0x0d,0xb5,0xe9,0xe5,0x47,0x3b,0x9d,0xef,0x35,
    4494. 

  4494.     0xa3,0xbf,0xb3,0xdf,0x53,0xd3,0x97,0x53,0x49,0x71,0x07,0x35,0x61,0x71,0x2f,0x43,
    4495. 

  4495.     0x2f,0x11,0xdf,0x17,0x97,0xfb,0x95,0x3b,0x7f,0x6b,0xd3,0x25,0xbf,0xad,0xc7,0xc5,
    4496. 

  4496.     0xc5,0xb5,0x8b,0xef,0x2f,0xd3,0x07,0x6b,0x25,0x49,0x95,0x25,0x49,0x6d,0x71,0xc7 },
    4497. 

  4497.   { 0xa7,0xbc,0xc9,0xad,0x91,0xdf,0x85,0xe5,0xd4,0x78,0xd5,0x17,0x46,0x7c,0x29,0x4c,
    4498. 

  4498.     0x4d,0x03,0xe9,0x25,0x68,0x11,0x86,0xb3,0xbd,0xf7,0x6f,0x61,0x22,0xa2,0x26,0x34,
    4499. 

  4499.     0x2a,0xbe,0x1e,0x46,0x14,0x68,0x9d,0x44,0x18,0xc2,0x40,0xf4,0x7e,0x5f,0x1b,0xad,
    4500. 

  4500.     0x0b,0x94,0xb6,0x67,0xb4,0x0b,0xe1,0xea,0x95,0x9c,0x66,0xdc,0xe7,0x5d,0x6c,0x05,
    4501. 

  4501.     0xda,0xd5,0xdf,0x7a,0xef,0xf6,0xdb,0x1f,0x82,0x4c,0xc0,0x68,0x47,0xa1,0xbd,0xee,
    4502. 

  4502.     0x39,0x50,0x56,0x4a,0xdd,0xdf,0xa5,0xf8,0xc6,0xda,0xca,0x90,0xca,0x01,0x42,0x9d,
    4503. 

  4503.     0x8b,0x0c,0x73,0x43,0x75,0x05,0x94,0xde,0x24,0xb3,0x80,0x34,0xe5,0x2c,0xdc,0x9b,
    4504. 

  4504.     0x3f,0xca,0x33,0x45,0xd0,0xdb,0x5f,0xf5,0x52,0xc3,0x21,0xda,0xe2,0x22,0x72,0x6b,
    4505. 

  4505.     0x3e,0xd0,0x5b,0xa8,0x87,0x8c,0x06,0x5d,0x0f,0xdd,0x09,0x19,0x93,0xd0,0xb9,0xfc,
    4506. 

  4506.     0x8b,0x0f,0x84,0x60,0x33,0x1c,0x9b,0x45,0xf1,0xf0,0xa3,0x94,0x3a,0x12,0x77,0x33,
    4507. 

  4507.     0x4d,0x44,0x78,0x28,0x3c,0x9e,0xfd,0x65,0x57,0x16,0x94,0x6b,0xfb,0x59,0xd0,0xc8,
    4508. 

  4508.     0x22,0x36,0xdb,0xd2,0x63,0x98,0x43,0xa1,0x04,0x87,0x86,0xf7,0xa6,0x26,0xbb,0xd6,
    4509. 

  4509.     0x59,0x4d,0xbf,0x6a,0x2e,0xaa,0x2b,0xef,0xe6,0x78,0xb6,0x4e,0xe0,0x2f,0xdc,0x7c,
    4510. 

  4510.     0xbe,0x57,0x19,0x32,0x7e,0x2a,0xd0,0xb8,0xba,0x29,0x00,0x3c,0x52,0x7d,0xa8,0x49,
    4511. 

  4511.     0x3b,0x2d,0xeb,0x25,0x49,0xfa,0xa3,0xaa,0x39,0xa7,0xc5,0xa7,0x50,0x11,0x36,0xfb,
    4512. 

  4512.     0xc6,0x67,0x4a,0xf5,0xa5,0x12,0x65,0x7e,0xb0,0xdf,0xaf,0x4e,0xb3,0x61,0x7f,0x2f } };
    4513. 

  4513.   unsigned offset=0, entries, tag, type, len, save, c;
    4514. 

  4514.   unsigned ver97=0, serial=0, i, wbi=0, wb[4]={0,0,0,0};
    4515. 

  4515.   uchar buf97[324], ci, cj, ck;
    4516. 

  4516.   short morder, sorder=order;
    4517. 

  4517.   char buf[10];
    4518. 

  4518. /*
    4519. 

  4519.    The MakerNote might have its own TIFF header (possibly with
    4520. 

  4520.    its own byte-order!), or it might just be a table.
    4521. 

  4521.  */
    4522. 

  4522.   if (!strcmp(make,"Nokia")) return;
    4523. 

  4523.   fread (buf, 1, 10, ifp);
    4524. 

  4524.   if (!strncmp (buf,"KDK" ,3) ||	/* these aren't TIFF tables */
    4525. 

  4525.       !strncmp (buf,"VER" ,3) ||
    4526. 

  4526.       !strncmp (buf,"IIII",4) ||
    4527. 

  4527.       !strncmp (buf,"MMMM",4)) return;
    4528. 

  4528.   if (!strncmp (buf,"KC"  ,2) ||	/* Konica KD-400Z, KD-510Z */
    4529. 

  4529.       !strncmp (buf,"MLY" ,3)) {	/* Minolta DiMAGE G series */
    4530. 

  4530.     order = 0x4d4d;
    4531. 

  4531.     while ((i=ftell(ifp)) < data_offset && i < 16384) {
    4532. 

  4532.       wb[0] = wb[2];  wb[2] = wb[1];  wb[1] = wb[3];
    4533. 

  4533.       wb[3] = get2();
    4534. 

  4534.       if (wb[1] == 256 && wb[3] == 256 &&
    4535. 

  4535. 	  wb[0] > 256 && wb[0] < 640 && wb[2] > 256 && wb[2] < 640)
    4536. 

  4536. 	FORC4 cam_mul[c] = wb[c];
    4537. 

  4537.     }
    4538. 

  4538.     goto quit;
    4539. 

  4539.   }
    4540. 

  4540.   if (!strcmp (buf,"Nikon")) {
    4541. 

  4541.     base = ftell(ifp);
    4542. 

  4542.     order = get2();
    4543. 

  4543.     if (get2() != 42) goto quit;
    4544. 

  4544.     offset = get4();
    4545. 

  4545.     fseek (ifp, offset-8, SEEK_CUR);
    4546. 

  4546.   } else if (!strcmp (buf,"OLYMPUS")) {
    4547. 

  4547.     base = ftell(ifp)-10;
    4548. 

  4548.     fseek (ifp, -2, SEEK_CUR);
    4549. 

  4549.     order = get2();  get2();
    4550. 

  4550.   } else if (!strncmp (buf,"SONY",4) ||
    4551. 

  4551. 	     !strcmp  (buf,"Panasonic")) {
    4552. 

  4552.     goto nf;
    4553. 

  4553.   } else if (!strncmp (buf,"FUJIFILM",8)) {
    4554. 

  4554.     base = ftell(ifp)-10;
    4555. 

  4555. nf: order = 0x4949;
    4556. 

  4556.     fseek (ifp,  2, SEEK_CUR);
    4557. 

  4557.   } else if (!strcmp (buf,"OLYMP") ||
    4558. 

  4558. 	     !strcmp (buf,"LEICA") ||
    4559. 

  4559. 	     !strcmp (buf,"Ricoh") ||
    4560. 

  4560. 	     !strcmp (buf,"EPSON"))
    4561. 

  4561.     fseek (ifp, -2, SEEK_CUR);
    4562. 

  4562.   else if (!strcmp (buf,"AOC") ||
    4563. 

  4563. 	   !strcmp (buf,"QVC"))
    4564. 

  4564.     fseek (ifp, -4, SEEK_CUR);
    4565. 

  4565.   else {
    4566. 

  4566.     fseek (ifp, -10, SEEK_CUR);
    4567. 

  4567.     if (!strncmp(make,"SAMSUNG",7))
    4568. 

  4568.       base = ftell(ifp);
    4569. 

  4569.   }
    4570. 

  4570.   entries = get2();
    4571. 

  4571.   if (entries > 1000) return;
    4572. 

  4572.   morder = order;
    4573. 

  4573.   while (entries--) {
    4574. 

  4574.     order = morder;
    4575. 

  4575.     tiff_get (base, &tag, &type, &len, &save);
    4576. 

  4576.     tag |= uptag << 16;
    4577. 

  4577.     if (tag == 2 && strstr(make,"NIKON") && !iso_speed)
    4578. 

  4578.       iso_speed = (get2(),get2());
    4579. 

  4579.     if (tag == 4 && len > 26 && len < 35) {
    4580. 

  4580.       if ((i=(get4(),get2())) != 0x7fff && !iso_speed)
    4581. 

  4581. 	iso_speed = 50 * pow (2, i/32.0 - 4);
    4582. 

  4582.       if ((i=(get2(),get2())) != 0x7fff && !aperture)
    4583. 

  4583. 	aperture = pow (2, i/64.0);
    4584. 

  4584.       if ((i=get2()) != 0xffff && !shutter)
    4585. 

  4585. 	shutter = pow (2, (short) i/-32.0);
    4586. 

  4586.       wbi = (get2(),get2());
    4587. 

  4587.       shot_order = (get2(),get2());
    4588. 

  4588.     }
    4589. 

  4589.     if ((tag == 4 || tag == 0x114) && !strncmp(make,"KONICA",6)) {
    4590. 

  4590.       fseek (ifp, tag == 4 ? 140:160, SEEK_CUR);
    4591. 

  4591.       switch (get2()) {
    4592. 

  4592. 	case 72:  flip = 0;  break;
    4593. 

  4593. 	case 76:  flip = 6;  break;
    4594. 

  4594. 	case 82:  flip = 5;  break;
    4595. 

  4595.       }
    4596. 

  4596.     }
    4597. 

  4597.     if (tag == 7 && type == 2 && len > 20)
    4598. 

  4598.       fgets (model2, 64, ifp);
    4599. 

  4599.     if (tag == 8 && type == 4)
    4600. 

  4600.       shot_order = get4();
    4601. 

  4601.     if (tag == 9 && !strcmp(make,"Canon"))
    4602. 

  4602.       fread (artist, 64, 1, ifp);
    4603. 

  4603.     if (tag == 0xc && len == 4) {
    4604. 

  4604.       cam_mul[0] = getreal(type);
    4605. 

  4605.       cam_mul[2] = getreal(type);
    4606. 

  4606.     }
    4607. 

  4607.     if (tag == 0xd && type == 7 && get2() == 0xaaaa) {
    4608. 

  4608.       for (c=i=2; (ushort) c != 0xbbbb && i < len; i++)
    4609. 

  4609. 	c = c << 8 | fgetc(ifp);
    4610. 

  4610.       while ((i+=4) < len-5)
    4611. 

  4611. 	if (get4() == 257 && (i=len) && (c = (get4(),fgetc(ifp))) < 3)
    4612. 

  4612. 	  flip = "065"[c]-'0';
    4613. 

  4613.     }
    4614. 

  4614.     if (tag == 0x10 && type == 4)
    4615. 

  4615.       unique_id = get4();
    4616. 

  4616.     if (tag == 0x11 && is_raw && !strncmp(make,"NIKON",5)) {
    4617. 

  4617.       fseek (ifp, get4()+base, SEEK_SET);
    4618. 

  4618.       parse_tiff_ifd (base);
    4619. 

  4619.     }
    4620. 

  4620.     if (tag == 0x14 && type == 7) {
    4621. 

  4621.       if (len == 2560) {
    4622. 

  4622. 	fseek (ifp, 1248, SEEK_CUR);
    4623. 

  4623. 	goto get2_256;
    4624. 

  4624.       }
    4625. 

  4625.       fread (buf, 1, 10, ifp);
    4626. 

  4626.       if (!strncmp(buf,"NRW ",4)) {
    4627. 

  4627. 	fseek (ifp, strcmp(buf+4,"0100") ? 46:1546, SEEK_CUR);
    4628. 

  4628. 	cam_mul[0] = get4() << 2;
    4629. 

  4629. 	cam_mul[1] = get4() + get4();
    4630. 

  4630. 	cam_mul[2] = get4() << 2;
    4631. 

  4631.       }
    4632. 

  4632.     }
    4633. 

  4633.     if (tag == 0x15 && type == 2 && is_raw)
    4634. 

  4634.       fread (model, 64, 1, ifp);
    4635. 

  4635.     if (strstr(make,"PENTAX")) {
    4636. 

  4636.       if (tag == 0x1b) tag = 0x1018;
    4637. 

  4637.       if (tag == 0x1c) tag = 0x1017;
    4638. 

  4638.     }
    4639. 

  4639.     if (tag == 0x1d)
    4640. 

  4640.       while ((c = fgetc(ifp)) && c != EOF)
    4641. 

  4641. 	serial = serial*10 + (isdigit(c) ? c - '0' : c % 10);
    4642. 

  4642.     if (tag == 0x81 && type == 4) {
    4643. 

  4643.       data_offset = get4();
    4644. 

  4644.       fseek (ifp, data_offset + 41, SEEK_SET);
    4645. 

  4645.       raw_height = get2() * 2;
    4646. 

  4646.       raw_width  = get2();
    4647. 

  4647.       filters = 0x61616161;
    4648. 

  4648.     }
    4649. 

  4649.     if (tag == 0x29 && type == 1) {
    4650. 

  4650.       c = wbi < 18 ? "012347800000005896"[wbi]-'0' : 0;
    4651. 

  4651.       fseek (ifp, 8 + c*32, SEEK_CUR);
    4652. 

  4652.       FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get4();
    4653. 

  4653.     }
    4654. 

  4654.     if ((tag == 0x81  && type == 7) ||
    4655. 

  4655. 	(tag == 0x100 && type == 7) ||
    4656. 

  4656. 	(tag == 0x280 && type == 1)) {
    4657. 

  4657.       thumb_offset = ftell(ifp);
    4658. 

  4658.       thumb_length = len;
    4659. 

  4659.     }
    4660. 

  4660.     if (tag == 0x88 && type == 4 && (thumb_offset = get4()))
    4661. 

  4661.       thumb_offset += base;
    4662. 

  4662.     if (tag == 0x89 && type == 4)
    4663. 

  4663.       thumb_length = get4();
    4664. 

  4664.     if (tag == 0x8c || tag == 0x96)
    4665. 

  4665.       meta_offset = ftell(ifp);
    4666. 

  4666.     if (tag == 0x97) {
    4667. 

  4667.       for (i=0; i < 4; i++)
    4668. 

  4668. 	ver97 = ver97 * 10 + fgetc(ifp)-'0';
    4669. 

  4669.       switch (ver97) {
    4670. 

  4670. 	case 100:
    4671. 

  4671. 	  fseek (ifp, 68, SEEK_CUR);
    4672. 

  4672. 	  FORC4 cam_mul[(c >> 1) | ((c & 1) << 1)] = get2();
    4673. 

  4673. 	  break;
    4674. 

  4674. 	case 102:
    4675. 

  4675. 	  fseek (ifp, 6, SEEK_CUR);
    4676. 

  4676. 	  goto get2_rggb;
    4677. 

  4677. 	case 103:
    4678. 

  4678. 	  fseek (ifp, 16, SEEK_CUR);
    4679. 

  4679. 	  FORC4 cam_mul[c] = get2();
    4680. 

  4680.       }
    4681. 

  4681.       if (ver97 >= 200) {
    4682. 

  4682. 	if (ver97 != 205) fseek (ifp, 280, SEEK_CUR);
    4683. 

  4683. 	fread (buf97, 324, 1, ifp);
    4684. 

  4684.       }
    4685. 

  4685.     }
    4686. 

  4686.     if (tag == 0xa1 && type == 7) {
    4687. 

  4687.       order = 0x4949;
    4688. 

  4688.       fseek (ifp, 140, SEEK_CUR);
    4689. 

  4689.       FORC3 cam_mul[c] = get4();
    4690. 

  4690.     }
    4691. 

  4691.     if (tag == 0xa4 && type == 3) {
    4692. 

  4692.       fseek (ifp, wbi*48, SEEK_CUR);
    4693. 

  4693.       FORC3 cam_mul[c] = get2();
    4694. 

  4694.     }
    4695. 

  4695.     if (tag == 0xa7 && (unsigned) (ver97-200) < 17) {
    4696. 

  4696.       ci = xlat[0][serial & 0xff];
    4697. 

  4697.       cj = xlat[1][fgetc(ifp)^fgetc(ifp)^fgetc(ifp)^fgetc(ifp)];
    4698. 

  4698.       ck = 0x60;
    4699. 

  4699.       for (i=0; i < 324; i++)
    4700. 

  4700. 	buf97[i] ^= (cj += ci * ck++);
    4701. 

  4701.       i = "66666>666;6A;:;55"[ver97-200] - '0';
    4702. 

  4702.       FORC4 cam_mul[c ^ (c >> 1) ^ (i & 1)] =
    4703. 

  4703. 	sget2 (buf97 + (i & -2) + c*2);
    4704. 

  4704.     }
    4705. 

  4705.     if (tag == 0x200 && len == 3)
    4706. 

  4706.       shot_order = (get4(),get4());
    4707. 

  4707.     if (tag == 0x200 && len == 4)
    4708. 

  4708.       FORC4 cblack[c ^ c >> 1] = get2();
    4709. 

  4709.     if (tag == 0x201 && len == 4)
    4710. 

  4710.       goto get2_rggb;
    4711. 

  4711.     if (tag == 0x220 && type == 7)
    4712. 

  4712.       meta_offset = ftell(ifp);
    4713. 

  4713.     if (tag == 0x401 && type == 4 && len == 4)
    4714. 

  4714.       FORC4 cblack[c ^ c >> 1] = get4();
    4715. 

  4715.     if (tag == 0xe01) {		/* Nikon Capture Note */
    4716. 

  4716.       order = 0x4949;
    4717. 

  4717.       fseek (ifp, 22, SEEK_CUR);
    4718. 

  4718.       for (offset=22; offset+22 < len; offset += 22+i) {
    4719. 

  4719. 	tag = get4();
    4720. 

  4720. 	fseek (ifp, 14, SEEK_CUR);
    4721. 

  4721. 	i = get4()-4;
    4722. 

  4722. 	if (tag == 0x76a43207) flip = get2();
    4723. 

  4723. 	else fseek (ifp, i, SEEK_CUR);
    4724. 

  4724.       }
    4725. 

  4725.     }
    4726. 

  4726.     if (tag == 0xe80 && len == 256 && type == 7) {
    4727. 

  4727.       fseek (ifp, 48, SEEK_CUR);
    4728. 

  4728.       cam_mul[0] = get2() * 508 * 1.078 / 0x10000;
    4729. 

  4729.       cam_mul[2] = get2() * 382 * 1.173 / 0x10000;
    4730. 

  4730.     }
    4731. 

  4731.     if (tag == 0xf00 && type == 7) {
    4732. 

  4732.       if (len == 614)
    4733. 

  4733. 	fseek (ifp, 176, SEEK_CUR);
    4734. 

  4734.       else if (len == 734 || len == 1502)
    4735. 

  4735. 	fseek (ifp, 148, SEEK_CUR);
    4736. 

  4736.       else goto next;
    4737. 

  4737.       goto get2_256;
    4738. 

  4738.     }
    4739. 

  4739.     if ((tag == 0x1011 && len == 9) || tag == 0x20400200)
    4740. 

  4740.       for (i=0; i < 3; i++)
    4741. 

  4741. 	FORC3 cmatrix[i][c] = ((short) get2()) / 256.0;
    4742. 

  4742.     if ((tag == 0x1012 || tag == 0x20400600) && len == 4)
    4743. 

  4743.       FORC4 cblack[c ^ c >> 1] = get2();
    4744. 

  4744.     if (tag == 0x1017 || tag == 0x20400100)
    4745. 

  4745.       cam_mul[0] = get2() / 256.0;
    4746. 

  4746.     if (tag == 0x1018 || tag == 0x20400100)
    4747. 

  4747.       cam_mul[2] = get2() / 256.0;
    4748. 

  4748.     if (tag == 0x2011 && len == 2) {
    4749. 

  4749. get2_256:
    4750. 

  4750.       order = 0x4d4d;
    4751. 

  4751.       cam_mul[0] = get2() / 256.0;
    4752. 

  4752.       cam_mul[2] = get2() / 256.0;
    4753. 

  4753.     }
    4754. 

  4754.     if ((tag | 0x70) == 0x2070 && type == 4)
    4755. 

  4755.       fseek (ifp, get4()+base, SEEK_SET);
    4756. 

  4756.     if (tag == 0x2010 && type != 7)
    4757. 

  4757.       load_raw = &CLASS olympus_load_raw;
    4758. 

  4758.     if (tag == 0x2020)
    4759. 

  4759.       parse_thumb_note (base, 257, 258);
    4760. 

  4760.     if (tag == 0x2040)
    4761. 

  4761.       parse_makernote (base, 0x2040);
    4762. 

  4762.     if (tag == 0xb028) {
    4763. 

  4763.       fseek (ifp, get4()+base, SEEK_SET);
    4764. 

  4764.       parse_thumb_note (base, 136, 137);
    4765. 

  4765.     }
    4766. 

  4766.     if (tag == 0x4001 && len > 500) {
    4767. 

  4767.       i = len == 582 ? 50 : len == 653 ? 68 : len == 5120 ? 142 : 126;
    4768. 

  4768.       fseek (ifp, i, SEEK_CUR);
    4769. 

  4769. get2_rggb:
    4770. 

  4770.       FORC4 cam_mul[c ^ (c >> 1)] = get2();
    4771. 

  4771.       i = len >> 3 == 164 ? 112:22;
    4772. 

  4772.       fseek (ifp, i, SEEK_CUR);
    4773. 

  4773.       FORC4 sraw_mul[c ^ (c >> 1)] = get2();
    4774. 

  4774.     }
    4775. 

  4775.     if (tag == 0xa021)
    4776. 

  4776.       FORC4 cam_mul[c ^ (c >> 1)] = get4();
    4777. 

  4777.     if (tag == 0xa028)
    4778. 

  4778.       FORC4 cam_mul[c ^ (c >> 1)] -= get4();
    4779. 

  4779. next:
    4780. 

  4780.     fseek (ifp, save, SEEK_SET);
    4781. 

  4781.   }
    4782. 

  4782. quit:
    4783. 

  4783.   order = sorder;
    4784. 

  4784. }
    4785. 

  4785. 

  4786. /*
    4787. 

  4787.    Since the TIFF DateTime string has no timezone information,
    4788. 

  4788.    assume that the camera's clock was set to Universal Time.
    4789. 

  4789.  */
    4790. 

  4790. void CLASS get_timestamp (int reversed)
    4791. 

  4791. {
    4792. 

  4792.   struct tm t;
    4793. 

  4793.   char str[20];
    4794. 

  4794.   int i;
    4795. 

  4795. 

  4796.   str[19] = 0;
    4797. 

  4797.   if (reversed)
    4798. 

  4798.     for (i=19; i--; ) str[i] = fgetc(ifp);
    4799. 

  4799.   else
    4800. 

  4800.     fread (str, 19, 1, ifp);
    4801. 

  4801.   memset (&t, 0, sizeof t);
    4802. 

  4802.   if (sscanf (str, "%d:%d:%d %d:%d:%d", &t.tm_year, &t.tm_mon,
    4803. 

  4803. 	&t.tm_mday, &t.tm_hour, &t.tm_min, &t.tm_sec) != 6)
    4804. 

  4804.     return;
    4805. 

  4805.   t.tm_year -= 1900;
    4806. 

  4806.   t.tm_mon -= 1;
    4807. 

  4807.   t.tm_isdst = -1;
    4808. 

  4808.   if (mktime(&t) > 0)
    4809. 

  4809.     timestamp = mktime(&t);
    4810. 

  4810. }
    4811. 

  4811. 

  4812. void CLASS parse_exif (int base)
    4813. 

  4813. {
    4814. 

  4814.   unsigned kodak, entries, tag, type, len, save, c;
    4815. 

  4815.   double expo;
    4816. 

  4816. 

  4817.   kodak = !strncmp(make,"EASTMAN",7) && tiff_nifds < 3;
    4818. 

  4818.   entries = get2();
    4819. 

  4819.   while (entries--) {
    4820. 

  4820.     tiff_get (base, &tag, &type, &len, &save);
    4821. 

  4821.     switch (tag) {
    4822. 

  4822.       case 33434:  shutter = getreal(type);		break;
    4823. 

  4823.       case 33437:  aperture = getreal(type);		break;
    4824. 

  4824.       case 34855:  iso_speed = get2();			break;
    4825. 

  4825.       case 36867:
    4826. 

  4826.       case 36868:  get_timestamp(0);			break;
    4827. 

  4827.       case 37377:  if ((expo = -getreal(type)) < 128)
    4828. 

  4828. 		     shutter = pow (2, expo);		break;
    4829. 

  4829.       case 37378:  aperture = pow (2, getreal(type)/2);	break;
    4830. 

  4830.       case 37386:  focal_len = getreal(type);		break;
    4831. 

  4831.       case 37500:  parse_makernote (base, 0);		break;
    4832. 

  4832.       case 40962:  if (kodak) raw_width  = get4();	break;
    4833. 

  4833.       case 40963:  if (kodak) raw_height = get4();	break;
    4834. 

  4834.       case 41730:
    4835. 

  4835. 	if (get4() == 0x20002)
    4836. 

  4836. 	  for (exif_cfa=c=0; c < 8; c+=2)
    4837. 

  4837. 	    exif_cfa |= fgetc(ifp) * 0x01010101 << c;
    4838. 

  4838.     }
    4839. 

  4839.     fseek (ifp, save, SEEK_SET);
    4840. 

  4840.   }
    4841. 

  4841. }
    4842. 

  4842. 

  4843. void CLASS parse_gps (int base)
    4844. 

  4844. {
    4845. 

  4845.   unsigned entries, tag, type, len, save, c;
    4846. 

  4846. 

  4847.   entries = get2();
    4848. 

  4848.   while (entries--) {
    4849. 

  4849.     tiff_get (base, &tag, &type, &len, &save);
    4850. 

  4850.     switch (tag) {
    4851. 

  4851.       case 1: case 3: case 5:
    4852. 

  4852. 	gpsdata[29+tag/2] = getc(ifp);			break;
    4853. 

  4853.       case 2: case 4: case 7:
    4854. 

  4854. 	FORC(6) gpsdata[tag/3*6+c] = get4();		break;
    4855. 

  4855.       case 6:
    4856. 

  4856. 	FORC(2) gpsdata[18+c] = get4();			break;
    4857. 

  4857.       case 18: case 29:
    4858. 

  4858. 	fgets ((char *) (gpsdata+14+tag/3), MIN(len,12), ifp);
    4859. 

  4859.     }
    4860. 

  4860.     fseek (ifp, save, SEEK_SET);
    4861. 

  4861.   }
    4862. 

  4862. }
    4863. 

  4863. 

  4864. void CLASS romm_coeff (float romm_cam[3][3])
    4865. 

  4865. {
    4866. 

  4866.   static const float rgb_romm[3][3] =	/* ROMM == Kodak ProPhoto */
    4867. 

  4867.   { {  2.034193, -0.727420, -0.306766 },
    4868. 

  4868.     { -0.228811,  1.231729, -0.002922 },
    4869. 

  4869.     { -0.008565, -0.153273,  1.161839 } };
    4870. 

  4870.   int i, j, k;
    4871. 

  4871. 

  4872.   for (i=0; i < 3; i++)
    4873. 

  4873.     for (j=0; j < 3; j++)
    4874. 

  4874.       for (cmatrix[i][j] = k=0; k < 3; k++)
    4875. 

  4875. 	cmatrix[i][j] += rgb_romm[i][k] * romm_cam[k][j];
    4876. 

  4876. }
    4877. 

  4877. 

  4878. void CLASS parse_mos (int offset)
    4879. 

  4879. {
    4880. 

  4880.   char data[40];
    4881. 

  4881.   int skip, from, i, c, neut[4], planes=0, frot=0;
    4882. 

  4882.   static const char *mod[] =
    4883. 

  4883.   { "","DCB2","Volare","Cantare","CMost","Valeo 6","Valeo 11","Valeo 22",
    4884. 

  4884.     "Valeo 11p","Valeo 17","","Aptus 17","Aptus 22","Aptus 75","Aptus 65",
    4885. 

  4885.     "Aptus 54S","Aptus 65S","Aptus 75S","AFi 5","AFi 6","AFi 7",
    4886. 

  4886.     "","","","","","","","","","","","","","","","","","AFi-II 12" };
    4887. 

  4887.   float romm_cam[3][3];
    4888. 

  4888. 

  4889.   fseek (ifp, offset, SEEK_SET);
    4890. 

  4890.   while (1) {
    4891. 

  4891.     if (get4() != 0x504b5453) break;
    4892. 

  4892.     get4();
    4893. 

  4893.     fread (data, 1, 40, ifp);
    4894. 

  4894.     skip = get4();
    4895. 

  4895.     from = ftell(ifp);
    4896. 

  4896.     if (!strcmp(data,"JPEG_preview_data")) {
    4897. 

  4897.       thumb_offset = from;
    4898. 

  4898.       thumb_length = skip;
    4899. 

  4899.     }
    4900. 

  4900.     if (!strcmp(data,"icc_camera_profile")) {
    4901. 

  4901.       profile_offset = from;
    4902. 

  4902.       profile_length = skip;
    4903. 

  4903.     }
    4904. 

  4904.     if (!strcmp(data,"ShootObj_back_type")) {
    4905. 

  4905.       fscanf (ifp, "%d", &i);
    4906. 

  4906.       if ((unsigned) i < sizeof mod / sizeof (*mod))
    4907. 

  4907. 	strcpy (model, mod[i]);
    4908. 

  4908.     }
    4909. 

  4909.     if (!strcmp(data,"icc_camera_to_tone_matrix")) {
    4910. 

  4910.       for (i=0; i < 9; i++)
    4911. 

  4911. 	romm_cam[0][i] = int_to_float(get4());
    4912. 

  4912.       romm_coeff (romm_cam);
    4913. 

  4913.     }
    4914. 

  4914.     if (!strcmp(data,"CaptProf_color_matrix")) {
    4915. 

  4915.       for (i=0; i < 9; i++)
    4916. 

  4916. 	fscanf (ifp, "%f", &romm_cam[0][i]);
    4917. 

  4917.       romm_coeff (romm_cam);
    4918. 

  4918.     }
    4919. 

  4919.     if (!strcmp(data,"CaptProf_number_of_planes"))
    4920. 

  4920.       fscanf (ifp, "%d", &planes);
    4921. 

  4921.     if (!strcmp(data,"CaptProf_raw_data_rotation"))
    4922. 

  4922.       fscanf (ifp, "%d", &flip);
    4923. 

  4923.     if (!strcmp(data,"CaptProf_mosaic_pattern"))
    4924. 

  4924.       FORC4 {
    4925. 

  4925. 	fscanf (ifp, "%d", &i);
    4926. 

  4926. 	if (i == 1) frot = c ^ (c >> 1);
    4927. 

  4927.       }
    4928. 

  4928.     if (!strcmp(data,"ImgProf_rotation_angle")) {
    4929. 

  4929.       fscanf (ifp, "%d", &i);
    4930. 

  4930.       flip = i - flip;
    4931. 

  4931.     }
    4932. 

  4932.     if (!strcmp(data,"NeutObj_neutrals") && !cam_mul[0]) {
    4933. 

  4933.       FORC4 fscanf (ifp, "%d", neut+c);
    4934. 

  4934.       FORC3 cam_mul[c] = (float) neut[0] / neut[c+1];
    4935. 

  4935.     }
    4936. 

  4936.     if (!strcmp(data,"Rows_data"))
    4937. 

  4937.       load_flags = get4();
    4938. 

  4938.     parse_mos (from);
    4939. 

  4939.     fseek (ifp, skip+from, SEEK_SET);
    4940. 

  4940.   }
    4941. 

  4941.   if (planes)
    4942. 

  4942.     filters = (planes == 1) * 0x01010101 *
    4943. 

  4943. 	(uchar) "\x94\x61\x16\x49"[(flip/90 + frot) & 3];
    4944. 

  4944. }
    4945. 

  4945. 

  4946. void CLASS linear_table (unsigned len)
    4947. 

  4947. {
    4948. 

  4948.   int i;
    4949. 

  4949.   if (len > 0x1000) len = 0x1000;
    4950. 

  4950.   read_shorts (curve, len);
    4951. 

  4951.   for (i=len; i < 0x1000; i++)
    4952. 

  4952.     curve[i] = curve[i-1];
    4953. 

  4953.   maximum = curve[0xfff];
    4954. 

  4954. }
    4955. 

  4955. 

  4956. void CLASS parse_kodak_ifd (int base)
    4957. 

  4957. {
    4958. 

  4958.   unsigned entries, tag, type, len, save;
    4959. 

  4959.   int i, c, wbi=-2, wbtemp=6500;
    4960. 

  4960.   float mul[3]={1,1,1}, num;
    4961. 

  4961.   static const int wbtag[] = { 64037,64040,64039,64041,-1,-1,64042 };
    4962. 

  4962. 

  4963.   entries = get2();
    4964. 

  4964.   if (entries > 1024) return;
    4965. 

  4965.   while (entries--) {
    4966. 

  4966.     tiff_get (base, &tag, &type, &len, &save);
    4967. 

  4967.     if (tag == 1020) wbi = getint(type);
    4968. 

  4968.     if (tag == 1021 && len == 72) {		/* WB set in software */
    4969. 

  4969.       fseek (ifp, 40, SEEK_CUR);
    4970. 

  4970.       FORC3 cam_mul[c] = 2048.0 / get2();
    4971. 

  4971.       wbi = -2;
    4972. 

  4972.     }
    4973. 

  4973.     if (tag == 2118) wbtemp = getint(type);
    4974. 

  4974.     if (tag == 2130 + wbi)
    4975. 

  4975.       FORC3 mul[c] = getreal(type);
    4976. 

  4976.     if (tag == 2140 + wbi && wbi >= 0)
    4977. 

  4977.       FORC3 {
    4978. 

  4978. 	for (num=i=0; i < 4; i++)
    4979. 

  4979. 	  num += getreal(type) * pow (wbtemp/100.0, i);
    4980. 

  4980. 	cam_mul[c] = 2048 / (num * mul[c]);
    4981. 

  4981.       }
    4982. 

  4982.     if (tag == 2317) linear_table (len);
    4983. 

  4983.     if (tag == 6020) iso_speed = getint(type);
    4984. 

  4984.     if (tag == 64013) wbi = fgetc(ifp);
    4985. 

  4985.     if ((unsigned) wbi < 7 && tag == wbtag[wbi])
    4986. 

  4986.       FORC3 cam_mul[c] = get4();
    4987. 

  4987.     if (tag == 64019) width = getint(type);
    4988. 

  4988.     if (tag == 64020) height = (getint(type)+1) & -2;
    4989. 

  4989.     fseek (ifp, save, SEEK_SET);
    4990. 

  4990.   }
    4991. 

  4991. }
    4992. 

  4992. #line 6144 "dcraw/dcraw.c"
    4993. 

  4993. int CLASS parse_tiff_ifd (int base)
    4994. 

  4994. {
    4995. 

  4995.   unsigned entries, tag, type, len, plen=16, save;
    4996. 

  4996.   int ifd, use_cm=0, cfa, i, j, c, ima_len=0;
    4997. 

  4997.   int blrr=1, blrc=1, dblack[] = { 0,0,0,0 };
    4998. 

  4998.   char software[64], *cbuf, *cp;
    4999. 

  4999.   uchar cfa_pat[16], cfa_pc[] = { 0,1,2,3 }, tab[256];
    5000. 

  5000.   double cc[4][4], cm[4][3], cam_xyz[4][3], num;
    5001. 

  5001.   double ab[]={ 1,1,1,1 }, asn[] = { 0,0,0,0 }, xyz[] = { 1,1,1 };
    5002. 

  5002.   unsigned sony_curve[] = { 0,0,0,0,0,4095 };
    5003. 

  5003.   unsigned *buf, sony_offset=0, sony_length=0, sony_key=0;
    5004. 

  5004.   struct jhead jh;
    5005. 

  5005. #ifndef LIBRAW_LIBRARY_BUILD
    5006. 

  5006.   FILE *sfp;
    5007. 

  5007. #endif
    5008. 

  5008. 

  5009.   if (tiff_nifds >= sizeof tiff_ifd / sizeof tiff_ifd[0])
    5010. 

  5010.     return 1;
    5011. 

  5011.   ifd = tiff_nifds++;
    5012. 

  5012.   for (j=0; j < 4; j++)
    5013. 

  5013.     for (i=0; i < 4; i++)
    5014. 

  5014.       cc[j][i] = i == j;
    5015. 

  5015.   entries = get2();
    5016. 

  5016.   if (entries > 512) return 1;
    5017. 

  5017.   while (entries--) {
    5018. 

  5018.     tiff_get (base, &tag, &type, &len, &save);
    5019. 

  5019.     switch (tag) {
    5020. 

  5020.       case 5:   width  = get2();  break;
    5021. 

  5021.       case 6:   height = get2();  break;
    5022. 

  5022.       case 7:   width += get2();  break;
    5023. 

  5023.       case 9:  filters = get2();  break;
    5024. 

  5024.       case 17: case 18:
    5025. 

  5025. 	if (type == 3 && len == 1)
    5026. 

  5026. 	  cam_mul[(tag-17)*2] = get2() / 256.0;
    5027. 

  5027. 	break;
    5028. 

  5028.       case 23:
    5029. 

  5029. 	if (type == 3) iso_speed = get2();
    5030. 

  5030. 	break;
    5031. 

  5031.       case 36: case 37: case 38:
    5032. 

  5032. 	cam_mul[tag-0x24] = get2();
    5033. 

  5033. 	break;
    5034. 

  5034.       case 39:
    5035. 

  5035. 	if (len < 50 || cam_mul[0]) break;
    5036. 

  5036. 	fseek (ifp, 12, SEEK_CUR);
    5037. 

  5037. 	FORC3 cam_mul[c] = get2();
    5038. 

  5038. 	break;
    5039. 

  5039.       case 46:
    5040. 

  5040. 	if (type != 7 || fgetc(ifp) != 0xff || fgetc(ifp) != 0xd8) break;
    5041. 

  5041. 	thumb_offset = ftell(ifp) - 2;
    5042. 

  5042. 	thumb_length = len;
    5043. 

  5043. 	break;
    5044. 

  5044.       case 61440:			/* Fuji HS10 table */
    5045. 

  5045. 	parse_tiff_ifd (base);
    5046. 

  5046. 	break;
    5047. 

  5047.       case 2: case 256: case 61441:	/* ImageWidth */
    5048. 

  5048. 	tiff_ifd[ifd].t_width = getint(type);
    5049. 

  5049. 	break;
    5050. 

  5050.       case 3: case 257: case 61442:	/* ImageHeight */
    5051. 

  5051. 	tiff_ifd[ifd].t_height = getint(type);
    5052. 

  5052. 	break;
    5053. 

  5053.       case 258:				/* BitsPerSample */
    5054. 

  5054.       case 61443:
    5055. 

  5055. 	tiff_ifd[ifd].samples = len & 7;
    5056. 

  5056. 	tiff_ifd[ifd].bps = getint(type);
    5057. 

  5057. 	break;
    5058. 

  5058.       case 61446:
    5059. 

  5059. 	raw_height = 0;
    5060. 

  5060. 	load_raw = &CLASS packed_load_raw;
    5061. 

  5061. 	load_flags = get4() && (filters=0x16161616) ? 24:80;
    5062. 

  5062. 	break;
    5063. 

  5063.       case 259:				/* Compression */
    5064. 

  5064. 	tiff_ifd[ifd].comp = getint(type);
    5065. 

  5065. 	break;
    5066. 

  5066.       case 262:				/* PhotometricInterpretation */
    5067. 

  5067. 	tiff_ifd[ifd].phint = get2();
    5068. 

  5068. 	break;
    5069. 

  5069.       case 270:				/* ImageDescription */
    5070. 

  5070. 	fread (desc, 512, 1, ifp);
    5071. 

  5071. 	break;
    5072. 

  5072.       case 271:				/* Make */
    5073. 

  5073. 	fgets (make, 64, ifp);
    5074. 

  5074. 	break;
    5075. 

  5075.       case 272:				/* Model */
    5076. 

  5076. 	fgets (model, 64, ifp);
    5077. 

  5077. 	break;
    5078. 

  5078.       case 280:				/* Panasonic RW2 offset */
    5079. 

  5079. 	if (type != 4) break;
    5080. 

  5080. 	load_raw = &CLASS panasonic_load_raw;
    5081. 

  5081. 	load_flags = 0x2008;
    5082. 

  5082.       case 273:				/* StripOffset */
    5083. 

  5083.       case 513:				/* JpegIFOffset */
    5084. 

  5084.       case 61447:
    5085. 

  5085. 	tiff_ifd[ifd].offset = get4()+base;
    5086. 

  5086. 	if (!tiff_ifd[ifd].bps && tiff_ifd[ifd].offset > 0) {
    5087. 

  5087. 	  fseek (ifp, tiff_ifd[ifd].offset, SEEK_SET);
    5088. 

  5088. 	  if (ljpeg_start (&jh, 1)) {
    5089. 

  5089. 	    tiff_ifd[ifd].comp    = 6;
    5090. 

  5090. 	    tiff_ifd[ifd].t_width   = jh.wide;
    5091. 

  5091. 	    tiff_ifd[ifd].t_height  = jh.high;
    5092. 

  5092. 	    tiff_ifd[ifd].bps     = jh.bits;
    5093. 

  5093. 	    tiff_ifd[ifd].samples = jh.clrs;
    5094. 

  5094. 	    if (!(jh.sraw || (jh.clrs & 1)))
    5095. 

  5095. 	      tiff_ifd[ifd].t_width *= jh.clrs;
    5096. 

  5096. 	    i = order;
    5097. 

  5097. 	    parse_tiff (tiff_ifd[ifd].offset + 12);
    5098. 

  5098. 	    order = i;
    5099. 

  5099. 	  }
    5100. 

  5100. 	}
    5101. 

  5101. 	break;
    5102. 

  5102.       case 274:				/* Orientation */
    5103. 

  5103. 	tiff_ifd[ifd].t_flip = "50132467"[get2() & 7]-'0';
    5104. 

  5104. 	break;
    5105. 

  5105.       case 277:				/* SamplesPerPixel */
    5106. 

  5106. 	tiff_ifd[ifd].samples = getint(type) & 7;
    5107. 

  5107. 	break;
    5108. 

  5108.       case 279:				/* StripByteCounts */
    5109. 

  5109.       case 514:
    5110. 

  5110.       case 61448:
    5111. 

  5111. 	tiff_ifd[ifd].bytes = get4();
    5112. 

  5112. 	break;
    5113. 

  5113.       case 61454:
    5114. 

  5114. 	FORC3 cam_mul[(4-c) % 3] = getint(type);
    5115. 

  5115. 	break;
    5116. 

  5116.       case 305:  case 11:		/* Software */
    5117. 

  5117. 	fgets (software, 64, ifp);
    5118. 

  5118. 	if (!strncmp(software,"Adobe",5) ||
    5119. 

  5119. 	    !strncmp(software,"dcraw",5) ||
    5120. 

  5120. 	    !strncmp(software,"UFRaw",5) ||
    5121. 

  5121. 	    !strncmp(software,"Bibble",6) ||
    5122. 

  5122. 	    !strncmp(software,"Nikon Scan",10) ||
    5123. 

  5123. 	    !strcmp (software,"Digital Photo Professional"))
    5124. 

  5124. 	  is_raw = 0;
    5125. 

  5125. 	break;
    5126. 

  5126.       case 306:				/* DateTime */
    5127. 

  5127. 	get_timestamp(0);
    5128. 

  5128. 	break;
    5129. 

  5129.       case 315:				/* Artist */
    5130. 

  5130. 	fread (artist, 64, 1, ifp);
    5131. 

  5131. 	break;
    5132. 

  5132.       case 322:				/* TileWidth */
    5133. 

  5133. 	tiff_ifd[ifd].t_tile_width = getint(type);
    5134. 

  5134. 	break;
    5135. 

  5135.       case 323:				/* TileLength */
    5136. 

  5136. 	tiff_ifd[ifd].t_tile_length = getint(type);
    5137. 

  5137. 	break;
    5138. 

  5138.       case 324:				/* TileOffsets */
    5139. 

  5139. 	tiff_ifd[ifd].offset = len > 1 ? ftell(ifp) : get4();
    5140. 

  5140. 	if (len == 4) {
    5141. 

  5141. 	  load_raw = &CLASS sinar_4shot_load_raw;
    5142. 

  5142. 	  is_raw = 5;
    5143. 

  5143. 	}
    5144. 

  5144. 	break;
    5145. 

  5145. #ifdef LIBRAW_LIBRARY_BUILD
    5146. 

  5146.       case 325:				/* TileByteCount */
    5147. 

  5147.           tiff_ifd[ifd].tile_maxbytes = 0;
    5148. 

  5148.           for(int jj=0;jj<len;jj++)
    5149. 

  5149.               {
    5150. 

  5150.                   int s = get4();
    5151. 

  5151.                   if(s > tiff_ifd[ifd].tile_maxbytes) tiff_ifd[ifd].tile_maxbytes=s;
    5152. 

  5152.               }
    5153. 

  5153. 	break;
    5154. 

  5154. #endif
    5155. 

  5155.       case 330:				/* SubIFDs */
    5156. 

  5156. 	if (!strcmp(model,"DSLR-A100") && tiff_ifd[ifd].t_width == 3872) {
    5157. 

  5157. 	  load_raw = &CLASS sony_arw_load_raw;
    5158. 

  5158. 	  data_offset = get4()+base;
    5159. 

  5159. 	  ifd++;  break;
    5160. 

  5160. 	}
    5161. 

  5161. 	while (len--) {
    5162. 

  5162. 	  i = ftell(ifp);
    5163. 

  5163. 	  fseek (ifp, get4()+base, SEEK_SET);
    5164. 

  5164. 	  if (parse_tiff_ifd (base)) break;
    5165. 

  5165. 	  fseek (ifp, i+4, SEEK_SET);
    5166. 

  5166. 	}
    5167. 

  5167. 	break;
    5168. 

  5168.       case 400:
    5169. 

  5169. 	strcpy (make, "Sarnoff");
    5170. 

  5170. 	maximum = 0xfff;
    5171. 

  5171. 	break;
    5172. 

  5172.       case 28688:
    5173. 

  5173. 	FORC4 sony_curve[c+1] = get2() >> 2 & 0xfff;
    5174. 

  5174. 	for (i=0; i < 5; i++)
    5175. 

  5175. 	  for (j = sony_curve[i]+1; j <= sony_curve[i+1]; j++)
    5176. 

  5176. 	    curve[j] = curve[j-1] + (1 << i);
    5177. 

  5177. 	break;
    5178. 

  5178.       case 29184: sony_offset = get4();  break;
    5179. 

  5179.       case 29185: sony_length = get4();  break;
    5180. 

  5180.       case 29217: sony_key    = get4();  break;
    5181. 

  5181.       case 29264:
    5182. 

  5182. 	parse_minolta (ftell(ifp));
    5183. 

  5183. 	raw_width = 0;
    5184. 

  5184. 	break;
    5185. 

  5185.       case 29443:
    5186. 

  5186. 	FORC4 cam_mul[c ^ (c < 2)] = get2();
    5187. 

  5187. 	break;
    5188. 

  5188.       case 29459:
    5189. 

  5189. 	FORC4 cam_mul[c] = get2();
    5190. 

  5190. 	i = (cam_mul[1] == 1024 && cam_mul[2] == 1024) << 1;
    5191. 

  5191. 	SWAP (cam_mul[i],cam_mul[i+1])
    5192. 

  5192. 	break;
    5193. 

  5193.       case 33405:			/* Model2 */
    5194. 

  5194. 	fgets (model2, 64, ifp);
    5195. 

  5195. 	break;
    5196. 

  5196.       case 33422:			/* CFAPattern */
    5197. 

  5197.       case 64777:			/* Kodak P-series */
    5198. 

  5198. 	if ((plen=len) > 16) plen = 16;
    5199. 

  5199. 	fread (cfa_pat, 1, plen, ifp);
    5200. 

  5200. 	for (colors=cfa=i=0; i < plen; i++) {
    5201. 

  5201. 	  colors += !(cfa & (1 << cfa_pat[i]));
    5202. 

  5202. 	  cfa |= 1 << cfa_pat[i];
    5203. 

  5203. 	}
    5204. 

  5204. 	if (cfa == 070) memcpy (cfa_pc,"\003\004\005",3);	/* CMY */
    5205. 

  5205. 	if (cfa == 072) memcpy (cfa_pc,"\005\003\004\001",4);	/* GMCY */
    5206. 

  5206. 	goto guess_cfa_pc;
    5207. 

  5207.       case 33424:
    5208. 

  5208.       case 65024:
    5209. 

  5209. 	fseek (ifp, get4()+base, SEEK_SET);
    5210. 

  5210. 	parse_kodak_ifd (base);
    5211. 

  5211. 	break;
    5212. 

  5212.       case 33434:			/* ExposureTime */
    5213. 

  5213. 	shutter = getreal(type);
    5214. 

  5214. 	break;
    5215. 

  5215.       case 33437:			/* FNumber */
    5216. 

  5216. 	aperture = getreal(type);
    5217. 

  5217. 	break;
    5218. 

  5218.       case 34306:			/* Leaf white balance */
    5219. 

  5219. 	FORC4 cam_mul[c ^ 1] = 4096.0 / get2();
    5220. 

  5220. 	break;
    5221. 

  5221.       case 34307:			/* Leaf CatchLight color matrix */
    5222. 

  5222. 	fread (software, 1, 7, ifp);
    5223. 

  5223. 	if (strncmp(software,"MATRIX",6)) break;
    5224. 

  5224. 	colors = 4;
    5225. 

  5225. 	for (raw_color = i=0; i < 3; i++) {
    5226. 

  5226. 	  FORC4 fscanf (ifp, "%f", &rgb_cam[i][c^1]);
    5227. 

  5227. 	  if (!use_camera_wb) continue;
    5228. 

  5228. 	  num = 0;
    5229. 

  5229. 	  FORC4 num += rgb_cam[i][c];
    5230. 

  5230. 	  FORC4 rgb_cam[i][c] /= num;
    5231. 

  5231. 	}
    5232. 

  5232. 	break;
    5233. 

  5233.       case 34310:			/* Leaf metadata */
    5234. 

  5234. 	parse_mos (ftell(ifp));
    5235. 

  5235.       case 34303:
    5236. 

  5236. 	strcpy (make, "Leaf");
    5237. 

  5237. 	break;
    5238. 

  5238.       case 34665:			/* EXIF tag */
    5239. 

  5239. 	fseek (ifp, get4()+base, SEEK_SET);
    5240. 

  5240. 	parse_exif (base);
    5241. 

  5241. 	break;
    5242. 

  5242.       case 34853:			/* GPSInfo tag */
    5243. 

  5243. 	fseek (ifp, get4()+base, SEEK_SET);
    5244. 

  5244. 	parse_gps (base);
    5245. 

  5245. 	break;
    5246. 

  5246.       case 34675:			/* InterColorProfile */
    5247. 

  5247.       case 50831:			/* AsShotICCProfile */
    5248. 

  5248. 	profile_offset = ftell(ifp);
    5249. 

  5249. 	profile_length = len;
    5250. 

  5250. 	break;
    5251. 

  5251.       case 37122:			/* CompressedBitsPerPixel */
    5252. 

  5252. 	kodak_cbpp = get4();
    5253. 

  5253. 	break;
    5254. 

  5254.       case 37386:			/* FocalLength */
    5255. 

  5255. 	focal_len = getreal(type);
    5256. 

  5256. 	break;
    5257. 

  5257.       case 37393:			/* ImageNumber */
    5258. 

  5258. 	shot_order = getint(type);
    5259. 

  5259. 	break;
    5260. 

  5260.       case 37400:			/* old Kodak KDC tag */
    5261. 

  5261. 	for (raw_color = i=0; i < 3; i++) {
    5262. 

  5262. 	  getreal(type);
    5263. 

  5263. 	  FORC3 rgb_cam[i][c] = getreal(type);
    5264. 

  5264. 	}
    5265. 

  5265. 	break;
    5266. 

  5266.       case 46275:			/* Imacon tags */
    5267. 

  5267. 	strcpy (make, "Imacon");
    5268. 

  5268. 	data_offset = ftell(ifp);
    5269. 

  5269. 	ima_len = len;
    5270. 

  5270.         printf("Data len: %d\n",ima_len);
    5271. 

  5271. 	break;
    5272. 

  5272.       case 46279:
    5273. 

  5273. 	if (!ima_len) break;
    5274. 

  5274. 	fseek (ifp, 38, SEEK_CUR);
    5275. 

  5275.       case 46274:
    5276. 

  5276. 	fseek (ifp, 40, SEEK_CUR);
    5277. 

  5277. 	raw_width  = get4();
    5278. 

  5278. 	raw_height = get4();
    5279. 

  5279. 	left_margin = get4() & 7;
    5280. 

  5280. 	width = raw_width - left_margin - (get4() & 7);
    5281. 

  5281. 	top_margin = get4() & 7;
    5282. 

  5282. 	height = raw_height - top_margin - (get4() & 7);
    5283. 

  5283. 	if (raw_width == 7262 && ima_len == 234317952 ) {
    5284. 

  5284. 	  height = 5412;
    5285. 

  5285. 	  width  = 7216;
    5286. 

  5286. 	  left_margin = 7;
    5287. 

  5287.           filters=0;
    5288. 

  5288. 	} else 	if (raw_width == 7262) {
    5289. 

  5289. 	  height = 5444;
    5290. 

  5290. 	  width  = 7244;
    5291. 

  5291. 	  left_margin = 7;
    5292. 

  5292. 	}
    5293. 

  5293. 	fseek (ifp, 52, SEEK_CUR);
    5294. 

  5294. 	FORC3 cam_mul[c] = getreal(11);
    5295. 

  5295. 	fseek (ifp, 114, SEEK_CUR);
    5296. 

  5296. 	flip = (get2() >> 7) * 90;
    5297. 

  5297. 	if (width * height * 6 == ima_len) {
    5298. 

  5298. 	  if (flip % 180 == 90) SWAP(width,height);
    5299. 

  5299. 	  raw_width = width;
    5300. 

  5300. 	  raw_height = height;
    5301. 

  5301. 	  left_margin = top_margin = filters = flip = 0;
    5302. 

  5302. 	}
    5303. 

  5303. 	sprintf (model, "Ixpress %d-Mp", height*width/1000000);
    5304. 

  5304. 	load_raw = &CLASS imacon_full_load_raw;
    5305. 

  5305. 	if (filters) {
    5306. 

  5306. 	  if (left_margin & 1) filters = 0x61616161;
    5307. 

  5307. 	  load_raw = &CLASS unpacked_load_raw;
    5308. 

  5308. 	}
    5309. 

  5309. 	maximum = 0xffff;
    5310. 

  5310. 	break;
    5311. 

  5311.       case 50454:			/* Sinar tag */
    5312. 

  5312.       case 50455:
    5313. 

  5313. 	if (!(cbuf = (char *) malloc(len))) break;
    5314. 

  5314. 	fread (cbuf, 1, len, ifp);
    5315. 

  5315. 	for (cp = cbuf-1; cp && cp < cbuf+len; cp = strchr(cp,'\n'))
    5316. 

  5316. 	  if (!strncmp (++cp,"Neutral ",8))
    5317. 

  5317. 	    sscanf (cp+8, "%f %f %f", cam_mul, cam_mul+1, cam_mul+2);
    5318. 

  5318. 	free (cbuf);
    5319. 

  5319. 	break;
    5320. 

  5320.       case 50458:
    5321. 

  5321. 	if (!make[0]) strcpy (make, "Hasselblad");
    5322. 

  5322. 	break;
    5323. 

  5323.       case 50459:			/* Hasselblad tag */
    5324. 

  5324. 	i = order;
    5325. 

  5325. 	j = ftell(ifp);
    5326. 

  5326. 	c = tiff_nifds;
    5327. 

  5327. 	order = get2();
    5328. 

  5328. 	fseek (ifp, j+(get2(),get4()), SEEK_SET);
    5329. 

  5329. 	parse_tiff_ifd (j);
    5330. 

  5330. 	maximum = 0xffff;
    5331. 

  5331. 	tiff_nifds = c;
    5332. 

  5332. 	order = i;
    5333. 

  5333. 	break;
    5334. 

  5334.       case 50706:			/* DNGVersion */
    5335. 

  5335. 	FORC4 dng_version = (dng_version << 8) + fgetc(ifp);
    5336. 

  5336. 	if (!make[0]) strcpy (make, "DNG");
    5337. 

  5337. 	is_raw = 1;
    5338. 

  5338. 	break;
    5339. 

  5339.       case 50710:			/* CFAPlaneColor */
    5340. 

  5340. 	if (len > 4) len = 4;
    5341. 

  5341. 	colors = len;
    5342. 

  5342. 	fread (cfa_pc, 1, colors, ifp);
    5343. 

  5343. guess_cfa_pc:
    5344. 

  5344. 	FORCC tab[cfa_pc[c]] = c;
    5345. 

  5345. 	cdesc[c] = 0;
    5346. 

  5346. 	for (i=16; i--; )
    5347. 

  5347. 	  filters = filters << 2 | tab[cfa_pat[i % plen]];
    5348. 

  5348. 	break;
    5349. 

  5349.       case 50711:			/* CFALayout */
    5350. 

  5350. 	if (get2() == 2) {
    5351. 

  5351. 	  fuji_width = 1;
    5352. 

  5352. 	  filters = 0x49494949;
    5353. 

  5353. 	}
    5354. 

  5354. 	break;
    5355. 

  5355.       case 291:
    5356. 

  5356.       case 50712:			/* LinearizationTable */
    5357. 

  5357. 	linear_table (len);
    5358. 

  5358. 	break;
    5359. 

  5359.       case 50713:			/* BlackLevelRepeatDim */
    5360. 

  5360. 	blrr = get2();
    5361. 

  5361. 	blrc = get2();
    5362. 

  5362. 	break;
    5363. 

  5363.       case 61450:
    5364. 

  5364. 	blrr = blrc = 2;
    5365. 

  5365.       case 50714:			/* BlackLevel */
    5366. 

  5366. 	black = getreal(type);
    5367. 

  5367. 	if (!filters || !~filters) break;
    5368. 

  5368. 	dblack[0] = black;
    5369. 

  5369. 	dblack[1] = (blrc == 2) ? getreal(type):dblack[0];
    5370. 

  5370. 	dblack[2] = (blrr == 2) ? getreal(type):dblack[0];
    5371. 

  5371. 	dblack[3] = (blrc == 2 && blrr == 2) ? getreal(type):dblack[1];
    5372. 

  5372. 	if (colors == 3)
    5373. 

  5373. 	  filters |= ((filters >> 2 & 0x22222222) |
    5374. 

  5374. 		      (filters << 2 & 0x88888888)) & filters << 1;
    5375. 

  5375. 	FORC4 cblack[filters >> (c << 1) & 3] = dblack[c];
    5376. 

  5376. 	black = 0;
    5377. 

  5377. 	break;
    5378. 

  5378.       case 50715:			/* BlackLevelDeltaH */
    5379. 

  5379.       case 50716:			/* BlackLevelDeltaV */
    5380. 

  5380. 	for (num=i=0; i < len; i++)
    5381. 

  5381. 	  num += getreal(type);
    5382. 

  5382. 	black += num/len + 0.5;
    5383. 

  5383. 	break;
    5384. 

  5384.       case 50717:			/* WhiteLevel */
    5385. 

  5385. 	maximum = getint(type);
    5386. 

  5386. 	break;
    5387. 

  5387.       case 50718:			/* DefaultScale */
    5388. 

  5388. 	pixel_aspect  = getreal(type);
    5389. 

  5389. 	pixel_aspect /= getreal(type);
    5390. 

  5390. 	break;
    5391. 

  5391.       case 50721:			/* ColorMatrix1 */
    5392. 

  5392.       case 50722:			/* ColorMatrix2 */
    5393. 

  5393. 	FORCC for (j=0; j < 3; j++)
    5394. 

  5394. 	  cm[c][j] = getreal(type);
    5395. 

  5395. 	use_cm = 1;
    5396. 

  5396. 	break;
    5397. 

  5397.       case 50723:			/* CameraCalibration1 */
    5398. 

  5398.       case 50724:			/* CameraCalibration2 */
    5399. 

  5399. 	for (i=0; i < colors; i++)
    5400. 

  5400. 	  FORCC cc[i][c] = getreal(type);
    5401. 

  5401. 	break;
    5402. 

  5402.       case 50727:			/* AnalogBalance */
    5403. 

  5403. 	FORCC ab[c] = getreal(type);
    5404. 

  5404. 	break;
    5405. 

  5405.       case 50728:			/* AsShotNeutral */
    5406. 

  5406. 	FORCC asn[c] = getreal(type);
    5407. 

  5407. 	break;
    5408. 

  5408.       case 50729:			/* AsShotWhiteXY */
    5409. 

  5409. 	xyz[0] = getreal(type);
    5410. 

  5410. 	xyz[1] = getreal(type);
    5411. 

  5411. 	xyz[2] = 1 - xyz[0] - xyz[1];
    5412. 

  5412. 	FORC3 xyz[c] /= d65_white[c];
    5413. 

  5413. 	break;
    5414. 

  5414.       case 50740:			/* DNGPrivateData */
    5415. 

  5415. 	if (dng_version) break;
    5416. 

  5416. 	parse_minolta (j = get4()+base);
    5417. 

  5417. 	fseek (ifp, j, SEEK_SET);
    5418. 

  5418. 	parse_tiff_ifd (base);
    5419. 

  5419. 	break;
    5420. 

  5420.       case 50752:
    5421. 

  5421. 	read_shorts (cr2_slice, 3);
    5422. 

  5422. 	break;
    5423. 

  5423.       case 50829:			/* ActiveArea */
    5424. 

  5424. 	top_margin = getint(type);
    5425. 

  5425. 	left_margin = getint(type);
    5426. 

  5426. 	height = getint(type) - top_margin;
    5427. 

  5427. 	width = getint(type) - left_margin;
    5428. 

  5428. 	break;
    5429. 

  5429.       case 50830:			/* MaskedAreas */
    5430. 

  5430.         for (i=0; i < len && i < 32; i++)
    5431. 

  5431. 	  mask[0][i] = getint(type);
    5432. 

  5432. 	black = 0;
    5433. 

  5433. 	break;
    5434. 

  5434.       case 51009:			/* OpcodeList2 */
    5435. 

  5435. 	meta_offset = ftell(ifp);
    5436. 

  5436. 	break;
    5437. 

  5437.       case 64772:			/* Kodak P-series */
    5438. 

  5438. 	if (len < 13) break;
    5439. 

  5439. 	fseek (ifp, 16, SEEK_CUR);
    5440. 

  5440. 	data_offset = get4();
    5441. 

  5441. 	fseek (ifp, 28, SEEK_CUR);
    5442. 

  5442. 	data_offset += get4();
    5443. 

  5443. 	load_raw = &CLASS packed_load_raw;
    5444. 

  5444. 	break;
    5445. 

  5445.       case 65026:
    5446. 

  5446. 	if (type == 2) fgets (model2, 64, ifp);
    5447. 

  5447.     }
    5448. 

  5448.     fseek (ifp, save, SEEK_SET);
    5449. 

  5449.   }
    5450. 

  5450.   if (sony_length && (buf = (unsigned *) malloc(sony_length))) {
    5451. 

  5451.     fseek (ifp, sony_offset, SEEK_SET);
    5452. 

  5452.     fread (buf, sony_length, 1, ifp);
    5453. 

  5453.     sony_decrypt (buf, sony_length/4, 1, sony_key);
    5454. 

  5454. #ifndef LIBRAW_LIBRARY_BUILD
    5455. 

  5455.     sfp = ifp;
    5456. 

  5456.     if ((ifp = tmpfile())) {
    5457. 

  5457.       fwrite (buf, sony_length, 1, ifp);
    5458. 

  5458.       fseek (ifp, 0, SEEK_SET);
    5459. 

  5459.       parse_tiff_ifd (-sony_offset);
    5460. 

  5460.       fclose (ifp);
    5461. 

  5461.     }
    5462. 

  5462.     ifp = sfp;
    5463. 

  5463. #else
    5464. 

  5464.     if( !ifp->tempbuffer_open(buf,sony_length))
    5465. 

  5465.         {
    5466. 

  5466.             parse_tiff_ifd(-sony_offset);
    5467. 

  5467.             ifp->tempbuffer_close();
    5468. 

  5468.         }
    5469. 

  5469. #endif
    5470. 

  5470.     free (buf);
    5471. 

  5471.   }
    5472. 

  5472.   for (i=0; i < colors; i++)
    5473. 

  5473.     FORCC cc[i][c] *= ab[i];
    5474. 

  5474.   if (use_cm) {
    5475. 

  5475.     FORCC for (i=0; i < 3; i++)
    5476. 

  5476.       for (cam_xyz[c][i]=j=0; j < colors; j++)
    5477. 

  5477. 	cam_xyz[c][i] += cc[c][j] * cm[j][i] * xyz[i];
    5478. 

  5478.     cam_xyz_coeff (cam_xyz);
    5479. 

  5479.   }
    5480. 

  5480.   if (asn[0]) {
    5481. 

  5481.     cam_mul[3] = 0;
    5482. 

  5482.     FORCC cam_mul[c] = 1 / asn[c];
    5483. 

  5483.   }
    5484. 

  5484.   if (!use_cm)
    5485. 

  5485.     FORCC pre_mul[c] /= cc[c][c];
    5486. 

  5486.   return 0;
    5487. 

  5487. }
    5488. 

  5488. 

  5489. int CLASS parse_tiff (int base)
    5490. 

  5490. {
    5491. 

  5491.   int doff;
    5492. 

  5492. 

  5493.   fseek (ifp, base, SEEK_SET);
    5494. 

  5494.   order = get2();
    5495. 

  5495.   if (order != 0x4949 && order != 0x4d4d) return 0;
    5496. 

  5496.   get2();
    5497. 

  5497.   while ((doff = get4())) {
    5498. 

  5498.     fseek (ifp, doff+base, SEEK_SET);
    5499. 

  5499.     if (parse_tiff_ifd (base)) break;
    5500. 

  5500.   }
    5501. 

  5501.   return 1;
    5502. 

  5502. }
    5503. 

  5503. 

  5504. void CLASS apply_tiff()
    5505. 

  5505. {
    5506. 

  5506.   int max_samp=0, raw=-1, thm=-1, i;
    5507. 

  5507.   struct jhead jh;
    5508. 

  5508. 

  5509.   thumb_misc = 16;
    5510. 

  5510.   if (thumb_offset) {
    5511. 

  5511.     fseek (ifp, thumb_offset, SEEK_SET);
    5512. 

  5512.     if (ljpeg_start (&jh, 1)) {
    5513. 

  5513.       thumb_misc   = jh.bits;
    5514. 

  5514.       thumb_width  = jh.wide;
    5515. 

  5515.       thumb_height = jh.high;
    5516. 

  5516.     }
    5517. 

  5517.   }
    5518. 

  5518.   for (i=0; i < tiff_nifds; i++) {
    5519. 

  5519.     if (max_samp < tiff_ifd[i].samples)
    5520. 

  5520. 	max_samp = tiff_ifd[i].samples;
    5521. 

  5521.     if (max_samp > 3) max_samp = 3;
    5522. 

  5522.     if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3) &&
    5523. 

  5523. 	(tiff_ifd[i].t_width | tiff_ifd[i].t_height) < 0x10000 &&
    5524. 

  5524. 	tiff_ifd[i].t_width*tiff_ifd[i].t_height > raw_width*raw_height) {
    5525. 

  5525.       raw_width     = tiff_ifd[i].t_width;
    5526. 

  5526.       raw_height    = tiff_ifd[i].t_height;
    5527. 

  5527.       tiff_bps      = tiff_ifd[i].bps;
    5528. 

  5528.       tiff_compress = tiff_ifd[i].comp;
    5529. 

  5529.       data_offset   = tiff_ifd[i].offset;
    5530. 

  5530.       tiff_flip     = tiff_ifd[i].t_flip;
    5531. 

  5531.       tiff_samples  = tiff_ifd[i].samples;
    5532. 

  5532.       tile_width    = tiff_ifd[i].t_tile_width;
    5533. 

  5533.       tile_length   = tiff_ifd[i].t_tile_length;
    5534. 

  5534. #ifdef LIBRAW_LIBRARY_BUILD
    5535. 

  5535.       data_size     = tile_length < INT_MAX && tile_length>0 ? tiff_ifd[i].tile_maxbytes: tiff_ifd[i].bytes;
    5536. 

  5536. #endif
    5537. 

  5537.       raw = i;
    5538. 

  5538.     }
    5539. 

  5539.   }
    5540. 

  5540.   if (!tile_width ) tile_width  = INT_MAX;
    5541. 

  5541.   if (!tile_length) tile_length = INT_MAX;
    5542. 

  5542.   for (i=tiff_nifds; i--; )
    5543. 

  5543.     if (tiff_ifd[i].t_flip) tiff_flip = tiff_ifd[i].t_flip;
    5544. 

  5544.   if (raw >= 0 && !load_raw)
    5545. 

  5545.     switch (tiff_compress) {
    5546. 

  5546.       case 32767:
    5547. 

  5547. 	if (tiff_ifd[raw].bytes == raw_width*raw_height) {
    5548. 

  5548. 	  tiff_bps = 12;
    5549. 

  5549. 	  load_raw = &CLASS sony_arw2_load_raw;			break;
    5550. 

  5550. 	}
    5551. 

  5551. 	if (tiff_ifd[raw].bytes*8 != raw_width*raw_height*tiff_bps) {
    5552. 

  5552. 	  raw_height += 8;
    5553. 

  5553. 	  load_raw = &CLASS sony_arw_load_raw;			break;
    5554. 

  5554. 	}
    5555. 

  5555. 	load_flags = 79;
    5556. 

  5556.       case 32769:
    5557. 

  5557. 	load_flags++;
    5558. 

  5558.       case 32770:
    5559. 

  5559.       case 32773: goto slr;
    5560. 

  5560.       case 0:  case 1:
    5561. 

  5561. 	if (tiff_ifd[raw].bytes*5 == raw_width*raw_height*8) {
    5562. 

  5562. 	  load_flags = 81;
    5563. 

  5563. 	  tiff_bps = 12;
    5564. 

  5564. 	} slr:
    5565. 

  5565. 	switch (tiff_bps) {
    5566. 

  5566. 	  case  8: load_raw = &CLASS eight_bit_load_raw;	break;
    5567. 

  5567. 	  case 12: if (tiff_ifd[raw].phint == 2)
    5568. 

  5568. 		     load_flags = 6;
    5569. 

  5569. 		   load_raw = &CLASS packed_load_raw;		break;
    5570. 

  5570. 	  case 14: load_flags = 0;
    5571. 

  5571. 	  case 16: load_raw = &CLASS unpacked_load_raw;		break;
    5572. 

  5572. 	}
    5573. 

  5573. 	break;
    5574. 

  5574.       case 6:  case 7:  case 99:
    5575. 

  5575. 	load_raw = &CLASS lossless_jpeg_load_raw;		break;
    5576. 

  5576.       case 262:
    5577. 

  5577. 	load_raw = &CLASS kodak_262_load_raw;			break;
    5578. 

  5578.       case 34713:
    5579. 

  5579. 	if ((raw_width+9)/10*16*raw_height == tiff_ifd[raw].bytes) {
    5580. 

  5580. 	  load_raw = &CLASS packed_load_raw;
    5581. 

  5581. 	  load_flags = 1;
    5582. 

  5582. 	} else if (raw_width*raw_height*2 == tiff_ifd[raw].bytes) {
    5583. 

  5583. 	  load_raw = &CLASS unpacked_load_raw;
    5584. 

  5584. 	  load_flags = 4;
    5585. 

  5585. 	  order = 0x4d4d;
    5586. 

  5586. 	} else
    5587. 

  5587. 	  load_raw = &CLASS nikon_load_raw;			break;
    5588. 

  5588.       case 34892:
    5589. 

  5589. 	load_raw = &CLASS lossy_dng_load_raw;			break;
    5590. 

  5590.       case 65535:
    5591. 

  5591. 	load_raw = &CLASS pentax_load_raw;			break;
    5592. 

  5592.       case 65000:
    5593. 

  5593. 	switch (tiff_ifd[raw].phint) {
    5594. 

  5594. 	  case 2: load_raw = &CLASS kodak_rgb_load_raw;   filters = 0;  break;
    5595. 

  5595. 	  case 6: load_raw = &CLASS kodak_ycbcr_load_raw; filters = 0;  break;
    5596. 

  5596. 	  case 32803: load_raw = &CLASS kodak_65000_load_raw;
    5597. 

  5597. 	}
    5598. 

  5598.       case 32867: break;
    5599. 

  5599.       default: is_raw = 0;
    5600. 

  5600.     }
    5601. 

  5601.   if (!dng_version)
    5602. 

  5602.     if ( (tiff_samples == 3 && tiff_ifd[raw].bytes &&
    5603. 

  5603. 	  tiff_bps != 14 && tiff_bps != 2048 && 
    5604. 

  5604. 	  tiff_compress != 32769 && tiff_compress != 32770)
    5605. 

  5605.       || (tiff_bps == 8 && !strstr(make,"KODAK") && !strstr(make,"Kodak") &&
    5606. 

  5606. 	  !strstr(model2,"DEBUG RAW")))
    5607. 

  5607.       is_raw = 0;
    5608. 

  5608.   for (i=0; i < tiff_nifds; i++)
    5609. 

  5609.     if (i != raw && tiff_ifd[i].samples == max_samp &&
    5610. 

  5610. 	tiff_ifd[i].t_width * tiff_ifd[i].t_height / SQR(tiff_ifd[i].bps+1) >
    5611. 

  5611. 	      thumb_width *       thumb_height / SQR(thumb_misc+1)
    5612. 

  5612. 	&& tiff_ifd[i].comp != 34892) {
    5613. 

  5613.       thumb_width  = tiff_ifd[i].t_width;
    5614. 

  5614.       thumb_height = tiff_ifd[i].t_height;
    5615. 

  5615.       thumb_offset = tiff_ifd[i].offset;
    5616. 

  5616.       thumb_length = tiff_ifd[i].bytes;
    5617. 

  5617.       thumb_misc   = tiff_ifd[i].bps;
    5618. 

  5618.       thm = i;
    5619. 

  5619.     }
    5620. 

  5620.   if (thm >= 0) {
    5621. 

  5621.     thumb_misc |= tiff_ifd[thm].samples << 5;
    5622. 

  5622.     switch (tiff_ifd[thm].comp) {
    5623. 

  5623.       case 0:
    5624. 

  5624. 	write_thumb = &CLASS layer_thumb;
    5625. 

  5625. 	break;
    5626. 

  5626.       case 1:
    5627. 

  5627. 	if (tiff_ifd[thm].bps <= 8)
    5628. 

  5628. 	  write_thumb = &CLASS ppm_thumb;
    5629. 

  5629. 	else if (!strcmp(make,"Imacon"))
    5630. 

  5630. 	  write_thumb = &CLASS ppm16_thumb;
    5631. 

  5631. 	else
    5632. 

  5632. 	  thumb_load_raw = &CLASS kodak_thumb_load_raw;
    5633. 

  5633. 	break;
    5634. 

  5634.       case 65000:
    5635. 

  5635. 	thumb_load_raw = tiff_ifd[thm].phint == 6 ?
    5636. 

  5636. 		&CLASS kodak_ycbcr_load_raw : &CLASS kodak_rgb_load_raw;
    5637. 

  5637.     }
    5638. 

  5638.   }
    5639. 

  5639. }
    5640. 

  5640. 

  5641. void CLASS parse_minolta (int base)
    5642. 

  5642. {
    5643. 

  5643.   int save, tag, len, offset, high=0, wide=0, i, c;
    5644. 

  5644.   short sorder=order;
    5645. 

  5645. 

  5646.   fseek (ifp, base, SEEK_SET);
    5647. 

  5647.   if (fgetc(ifp) || fgetc(ifp)-'M' || fgetc(ifp)-'R') return;
    5648. 

  5648.   order = fgetc(ifp) * 0x101;
    5649. 

  5649.   offset = base + get4() + 8;
    5650. 

  5650.   while ((save=ftell(ifp)) < offset) {
    5651. 

  5651.     for (tag=i=0; i < 4; i++)
    5652. 

  5652.       tag = tag << 8 | fgetc(ifp);
    5653. 

  5653.     len = get4();
    5654. 

  5654.     switch (tag) {
    5655. 

  5655.       case 0x505244:				/* PRD */
    5656. 

  5656. 	fseek (ifp, 8, SEEK_CUR);
    5657. 

  5657. 	high = get2();
    5658. 

  5658. 	wide = get2();
    5659. 

  5659. 	break;
    5660. 

  5660.       case 0x574247:				/* WBG */
    5661. 

  5661. 	get4();
    5662. 

  5662. 	i = strcmp(model,"DiMAGE A200") ? 0:3;
    5663. 

  5663. 	FORC4 cam_mul[c ^ (c >> 1) ^ i] = get2();
    5664. 

  5664. 	break;
    5665. 

  5665.       case 0x545457:				/* TTW */
    5666. 

  5666. 	parse_tiff (ftell(ifp));
    5667. 

  5667. 	data_offset = offset;
    5668. 

  5668.     }
    5669. 

  5669.     fseek (ifp, save+len+8, SEEK_SET);
    5670. 

  5670.   }
    5671. 

  5671.   raw_height = high;
    5672. 

  5672.   raw_width  = wide;
    5673. 

  5673.   order = sorder;
    5674. 

  5674. }
    5675. 

  5675. 

  5676. /*
    5677. 

  5677.    Many cameras have a "debug mode" that writes JPEG and raw
    5678. 

  5678.    at the same time.  The raw file has no header, so try to
    5679. 

  5679.    to open the matching JPEG file and read its metadata.
    5680. 

  5680.  */
    5681. 

  5681. void CLASS parse_external_jpeg()
    5682. 

  5682. {
    5683. 

  5683.   const char *file, *ext;
    5684. 

  5684.   char *jname, *jfile, *jext;
    5685. 

  5685. #ifndef LIBRAW_LIBRARY_BUILD
    5686. 

  5686.   FILE *save=ifp;
    5687. 

  5687. #else
    5688. 

  5688. #ifdef WIN32
    5689. 

  5689.   if(ifp->wfname())
    5690. 

  5690.   {
    5691. 

  5691. 	  std::wstring rawfile(ifp->wfname());
    5692. 

  5692. 	  rawfile.replace(rawfile.length()-3,3,L"JPG");
    5693. 

  5693. 	  if(!ifp->subfile_open(rawfile.c_str()))
    5694. 

  5694. 	  {
    5695. 

  5695. 		  parse_tiff (12);
    5696. 

  5696. 		  thumb_offset = 0;
    5697. 

  5697. 		  is_raw = 1;
    5698. 

  5698. 		  ifp->subfile_close();
    5699. 

  5699. 	  }
    5700. 

  5700. 	  else
    5701. 

  5701. 		  imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5702. 

  5702. 	 return;
    5703. 

  5703.   }
    5704. 

  5704. #endif
    5705. 

  5705.   if(!ifp->fname())
    5706. 

  5706.       {
    5707. 

  5707.           imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5708. 

  5708.           return;
    5709. 

  5709.       }
    5710. 

  5710. #endif
    5711. 

  5711. 

  5712.   ext  = strrchr (ifname, '.');
    5713. 

  5713.   file = strrchr (ifname, '/');
    5714. 

  5714.   if (!file) file = strrchr (ifname, '\\');
    5715. 

  5715. #ifndef LIBRAW_LIBRARY_BUILD
    5716. 

  5716.   if (!file) file = ifname-1;
    5717. 

  5717. #else
    5718. 

  5718.   if (!file) file = (char*)ifname-1;
    5719. 

  5719. #endif
    5720. 

  5720.   file++;
    5721. 

  5721.   if (!ext || strlen(ext) != 4 || ext-file != 8) return;
    5722. 

  5722.   jname = (char *) malloc (strlen(ifname) + 1);
    5723. 

  5723.   merror (jname, "parse_external_jpeg()");
    5724. 

  5724.   strcpy (jname, ifname);
    5725. 

  5725.   jfile = file - ifname + jname;
    5726. 

  5726.   jext  = ext  - ifname + jname;
    5727. 

  5727.   if (strcasecmp (ext, ".jpg")) {
    5728. 

  5728.     strcpy (jext, isupper(ext[1]) ? ".JPG":".jpg");
    5729. 

  5729.     if (isdigit(*file)) {
    5730. 

  5730.       memcpy (jfile, file+4, 4);
    5731. 

  5731.       memcpy (jfile+4, file, 4);
    5732. 

  5732.     }
    5733. 

  5733.   } else
    5734. 

  5734.     while (isdigit(*--jext)) {
    5735. 

  5735.       if (*jext != '9') {
    5736. 

  5736. 	(*jext)++;
    5737. 

  5737. 	break;
    5738. 

  5738.       }
    5739. 

  5739.       *jext = '0';
    5740. 

  5740.     }
    5741. 

  5741. #ifndef LIBRAW_LIBRARY_BUILD
    5742. 

  5742.   if (strcmp (jname, ifname)) {
    5743. 

  5743.     if ((ifp = fopen (jname, "rb"))) {
    5744. 

  5744. #ifdef DCRAW_VERBOSE
    5745. 

  5745.       if (verbose)
    5746. 

  5746. 	fprintf (stderr,_("Reading metadata from %s ...\n"), jname);
    5747. 

  5747. #endif
    5748. 

  5748.       parse_tiff (12);
    5749. 

  5749.       thumb_offset = 0;
    5750. 

  5750.       is_raw = 1;
    5751. 

  5751.       fclose (ifp);
    5752. 

  5752.     }
    5753. 

  5753.   }
    5754. 

  5754. #else
    5755. 

  5755.   if (strcmp (jname, ifname)) 
    5756. 

  5756.       {
    5757. 

  5757.           if(!ifp->subfile_open(jname))
    5758. 

  5758.               {
    5759. 

  5759.                   parse_tiff (12);
    5760. 

  5760.                   thumb_offset = 0;
    5761. 

  5761.                   is_raw = 1;
    5762. 

  5762.                   ifp->subfile_close();
    5763. 

  5763.               }
    5764. 

  5764.           else
    5765. 

  5765.               imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5766. 

  5766.       }
    5767. 

  5767. #endif
    5768. 

  5768.   if (!timestamp)
    5769. 

  5769.       {
    5770. 

  5770. #ifdef LIBRAW_LIBRARY_BUILD
    5771. 

  5771.           imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5772. 

  5772. #endif
    5773. 

  5773. #ifdef DCRAW_VERBOSE
    5774. 

  5774.           fprintf (stderr,_("Failed to read metadata from %s\n"), jname);
    5775. 

  5775. #endif
    5776. 

  5776.       }
    5777. 

  5777.   free (jname);
    5778. 

  5778. #ifndef LIBRAW_LIBRARY_BUILD
    5779. 

  5779.   ifp = save;
    5780. 

  5780. #endif
    5781. 

  5781. }
    5782. 

  5782. 

  5783. /*
    5784. 

  5784.    CIFF block 0x1030 contains an 8x8 white sample.
    5785. 

  5785.    Load this into white[][] for use in scale_colors().
    5786. 

  5786.  */
    5787. 

  5787. void CLASS ciff_block_1030()
    5788. 

  5788. {
    5789. 

  5789.   static const ushort key[] = { 0x410, 0x45f3 };
    5790. 

  5790.   int i, bpp, row, col, vbits=0;
    5791. 

  5791.   unsigned long bitbuf=0;
    5792. 

  5792. 

  5793.   if ((get2(),get4()) != 0x80008 || !get4()) return;
    5794. 

  5794.   bpp = get2();
    5795. 

  5795.   if (bpp != 10 && bpp != 12) return;
    5796. 

  5796.   for (i=row=0; row < 8; row++)
    5797. 

  5797.     for (col=0; col < 8; col++) {
    5798. 

  5798.       if (vbits < bpp) {
    5799. 

  5799. 	bitbuf = bitbuf << 16 | (get2() ^ key[i++ & 1]);
    5800. 

  5800. 	vbits += 16;
    5801. 

  5801.       }
    5802. 

  5802.       white[row][col] =
    5803. 

  5803. 	bitbuf << (LONG_BIT - vbits) >> (LONG_BIT - bpp);
    5804. 

  5804.       vbits -= bpp;
    5805. 

  5805.     }
    5806. 

  5806. }
    5807. 

  5807. 

  5808. /*
    5809. 

  5809.    Parse a CIFF file, better known as Canon CRW format.
    5810. 

  5810.  */
    5811. 

  5811. void CLASS parse_ciff (int offset, int length)
    5812. 

  5812. {
    5813. 

  5813.   int tboff, nrecs, c, type, len, save, wbi=-1;
    5814. 

  5814.   ushort key[] = { 0x410, 0x45f3 };
    5815. 

  5815. 

  5816.   fseek (ifp, offset+length-4, SEEK_SET);
    5817. 

  5817.   tboff = get4() + offset;
    5818. 

  5818.   fseek (ifp, tboff, SEEK_SET);
    5819. 

  5819.   nrecs = get2();
    5820. 

  5820.   if (nrecs > 100) return;
    5821. 

  5821.   while (nrecs--) {
    5822. 

  5822.     type = get2();
    5823. 

  5823.     len  = get4();
    5824. 

  5824.     save = ftell(ifp) + 4;
    5825. 

  5825.     fseek (ifp, offset+get4(), SEEK_SET);
    5826. 

  5826.     if ((((type >> 8) + 8) | 8) == 0x38)
    5827. 

  5827.       parse_ciff (ftell(ifp), len);	/* Parse a sub-table */
    5828. 

  5828. 

  5829.     if (type == 0x0810)
    5830. 

  5830.       fread (artist, 64, 1, ifp);
    5831. 

  5831.     if (type == 0x080a) {
    5832. 

  5832.       fread (make, 64, 1, ifp);
    5833. 

  5833.       fseek (ifp, strlen(make) - 63, SEEK_CUR);
    5834. 

  5834.       fread (model, 64, 1, ifp);
    5835. 

  5835.     }
    5836. 

  5836.     if (type == 0x1810) {
    5837. 

  5837.       fseek (ifp, 12, SEEK_CUR);
    5838. 

  5838.       flip = get4();
    5839. 

  5839.     }
    5840. 

  5840.     if (type == 0x1835)			/* Get the decoder table */
    5841. 

  5841.       tiff_compress = get4();
    5842. 

  5842.     if (type == 0x2007) {
    5843. 

  5843.       thumb_offset = ftell(ifp);
    5844. 

  5844.       thumb_length = len;
    5845. 

  5845.     }
    5846. 

  5846.     if (type == 0x1818) {
    5847. 

  5847.       shutter = pow (2, -int_to_float((get4(),get4())));
    5848. 

  5848.       aperture = pow (2, int_to_float(get4())/2);
    5849. 

  5849.     }
    5850. 

  5850.     if (type == 0x102a) {
    5851. 

  5851.       iso_speed = pow (2, (get4(),get2())/32.0 - 4) * 50;
    5852. 

  5852.       aperture  = pow (2, (get2(),(short)get2())/64.0);
    5853. 

  5853.       shutter   = pow (2,-((short)get2())/32.0);
    5854. 

  5854.       wbi = (get2(),get2());
    5855. 

  5855.       if (wbi > 17) wbi = 0;
    5856. 

  5856.       fseek (ifp, 32, SEEK_CUR);
    5857. 

  5857.       if (shutter > 1e6) shutter = get2()/10.0;
    5858. 

  5858.     }
    5859. 

  5859.     if (type == 0x102c) {
    5860. 

  5860.       if (get2() > 512) {		/* Pro90, G1 */
    5861. 

  5861. 	fseek (ifp, 118, SEEK_CUR);
    5862. 

  5862. 	FORC4 cam_mul[c ^ 2] = get2();
    5863. 

  5863.       } else {				/* G2, S30, S40 */
    5864. 

  5864. 	fseek (ifp, 98, SEEK_CUR);
    5865. 

  5865. 	FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get2();
    5866. 

  5866.       }
    5867. 

  5867.     }
    5868. 

  5868.     if (type == 0x0032) {
    5869. 

  5869.       if (len == 768) {			/* EOS D30 */
    5870. 

  5870. 	fseek (ifp, 72, SEEK_CUR);
    5871. 

  5871. 	FORC4 cam_mul[c ^ (c >> 1)] = 1024.0 / get2();
    5872. 

  5872. 	if (!wbi) cam_mul[0] = -1;	/* use my auto white balance */
    5873. 

  5873.       } else if (!cam_mul[0]) {
    5874. 

  5874. 	if (get2() == key[0])		/* Pro1, G6, S60, S70 */
    5875. 

  5875. 	  c = (strstr(model,"Pro1") ?
    5876. 

  5876. 	      "012346000000000000":"01345:000000006008")[wbi]-'0'+ 2;
    5877. 

  5877. 	else {				/* G3, G5, S45, S50 */
    5878. 

  5878. 	  c = "023457000000006000"[wbi]-'0';
    5879. 

  5879. 	  key[0] = key[1] = 0;
    5880. 

  5880. 	}
    5881. 

  5881. 	fseek (ifp, 78 + c*8, SEEK_CUR);
    5882. 

  5882. 	FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get2() ^ key[c & 1];
    5883. 

  5883. 	if (!wbi) cam_mul[0] = -1;
    5884. 

  5884.       }
    5885. 

  5885.     }
    5886. 

  5886.     if (type == 0x10a9) {		/* D60, 10D, 300D, and clones */
    5887. 

  5887.       if (len > 66) wbi = "0134567028"[wbi]-'0';
    5888. 

  5888.       fseek (ifp, 2 + wbi*8, SEEK_CUR);
    5889. 

  5889.       FORC4 cam_mul[c ^ (c >> 1)] = get2();
    5890. 

  5890.     }
    5891. 

  5891.     if (type == 0x1030 && (0x18040 >> wbi & 1))
    5892. 

  5892.       ciff_block_1030();		/* all that don't have 0x10a9 */
    5893. 

  5893.     if (type == 0x1031) {
    5894. 

  5894.       raw_width = (get2(),get2());
    5895. 

  5895.       raw_height = get2();
    5896. 

  5896.     }
    5897. 

  5897.     if (type == 0x5029) {
    5898. 

  5898.       focal_len = len >> 16;
    5899. 

  5899.       if ((len & 0xffff) == 2) focal_len /= 32;
    5900. 

  5900.     }
    5901. 

  5901.     if (type == 0x5813) flash_used = int_to_float(len);
    5902. 

  5902.     if (type == 0x5814) canon_ev   = int_to_float(len);
    5903. 

  5903.     if (type == 0x5817) shot_order = len;
    5904. 

  5904.     if (type == 0x5834) unique_id  = len;
    5905. 

  5905.     if (type == 0x580e) timestamp  = len;
    5906. 

  5906.     if (type == 0x180e) timestamp  = get4();
    5907. 

  5907. #ifdef LOCALTIME
    5908. 

  5908.     if ((type | 0x4000) == 0x580e)
    5909. 

  5909.       timestamp = mktime (gmtime (&timestamp));
    5910. 

  5910. #endif
    5911. 

  5911.     fseek (ifp, save, SEEK_SET);
    5912. 

  5912.   }
    5913. 

  5913. }
    5914. 

  5914. 

  5915. void CLASS parse_rollei()
    5916. 

  5916. {
    5917. 

  5917.   char line[128], *val;
    5918. 

  5918.   struct tm t;
    5919. 

  5919. 

  5920.   fseek (ifp, 0, SEEK_SET);
    5921. 

  5921.   memset (&t, 0, sizeof t);
    5922. 

  5922.   do {
    5923. 

  5923.     fgets (line, 128, ifp);
    5924. 

  5924.     if ((val = strchr(line,'=')))
    5925. 

  5925.       *val++ = 0;
    5926. 

  5926.     else
    5927. 

  5927.       val = line + strlen(line);
    5928. 

  5928.     if (!strcmp(line,"DAT"))
    5929. 

  5929.       sscanf (val, "%d.%d.%d", &t.tm_mday, &t.tm_mon, &t.tm_year);
    5930. 

  5930.     if (!strcmp(line,"TIM"))
    5931. 

  5931.       sscanf (val, "%d:%d:%d", &t.tm_hour, &t.tm_min, &t.tm_sec);
    5932. 

  5932.     if (!strcmp(line,"HDR"))
    5933. 

  5933.       thumb_offset = atoi(val);
    5934. 

  5934.     if (!strcmp(line,"X  "))
    5935. 

  5935.       raw_width = atoi(val);
    5936. 

  5936.     if (!strcmp(line,"Y  "))
    5937. 

  5937.       raw_height = atoi(val);
    5938. 

  5938.     if (!strcmp(line,"TX "))
    5939. 

  5939.       thumb_width = atoi(val);
    5940. 

  5940.     if (!strcmp(line,"TY "))
    5941. 

  5941.       thumb_height = atoi(val);
    5942. 

  5942.   } while (strncmp(line,"EOHD",4));
    5943. 

  5943.   data_offset = thumb_offset + thumb_width * thumb_height * 2;
    5944. 

  5944.   t.tm_year -= 1900;
    5945. 

  5945.   t.tm_mon -= 1;
    5946. 

  5946.   if (mktime(&t) > 0)
    5947. 

  5947.     timestamp = mktime(&t);
    5948. 

  5948.   strcpy (make, "Rollei");
    5949. 

  5949.   strcpy (model,"d530flex");
    5950. 

  5950.   write_thumb = &CLASS rollei_thumb;
    5951. 

  5951. }
    5952. 

  5952. 

  5953. void CLASS parse_sinar_ia()
    5954. 

  5954. {
    5955. 

  5955.   int entries, off;
    5956. 

  5956.   char str[8], *cp;
    5957. 

  5957. 

  5958.   order = 0x4949;
    5959. 

  5959.   fseek (ifp, 4, SEEK_SET);
    5960. 

  5960.   entries = get4();
    5961. 

  5961.   fseek (ifp, get4(), SEEK_SET);
    5962. 

  5962.   while (entries--) {
    5963. 

  5963.     off = get4(); get4();
    5964. 

  5964.     fread (str, 8, 1, ifp);
    5965. 

  5965.     if (!strcmp(str,"META"))   meta_offset = off;
    5966. 

  5966.     if (!strcmp(str,"THUMB")) thumb_offset = off;
    5967. 

  5967.     if (!strcmp(str,"RAW0"))   data_offset = off;
    5968. 

  5968.   }
    5969. 

  5969.   fseek (ifp, meta_offset+20, SEEK_SET);
    5970. 

  5970.   fread (make, 64, 1, ifp);
    5971. 

  5971.   make[63] = 0;
    5972. 

  5972.   if ((cp = strchr(make,' '))) {
    5973. 

  5973.     strcpy (model, cp+1);
    5974. 

  5974.     *cp = 0;
    5975. 

  5975.   }
    5976. 

  5976.   raw_width  = get2();
    5977. 

  5977.   raw_height = get2();
    5978. 

  5978.   load_raw = &CLASS unpacked_load_raw;
    5979. 

  5979.   thumb_width = (get4(),get2());
    5980. 

  5980.   thumb_height = get2();
    5981. 

  5981.   write_thumb = &CLASS ppm_thumb;
    5982. 

  5982.   maximum = 0x3fff;
    5983. 

  5983. }
    5984. 

  5984. 

  5985. void CLASS parse_phase_one (int base)
    5986. 

  5986. {
    5987. 

  5987.   unsigned entries, tag, type, len, data, save, i, c;
    5988. 

  5988.   float romm_cam[3][3];
    5989. 

  5989.   char *cp;
    5990. 

  5990. 

  5991.   memset (&ph1, 0, sizeof ph1);
    5992. 

  5992.   fseek (ifp, base, SEEK_SET);
    5993. 

  5993.   order = get4() & 0xffff;
    5994. 

  5994.   if (get4() >> 8 != 0x526177) return;		/* "Raw" */
    5995. 

  5995.   fseek (ifp, get4()+base, SEEK_SET);
    5996. 

  5996.   entries = get4();
    5997. 

  5997.   get4();
    5998. 

  5998.   while (entries--) {
    5999. 

  5999.     tag  = get4();
    6000. 

  6000.     type = get4();
    6001. 

  6001.     len  = get4();
    6002. 

  6002.     data = get4();
    6003. 

  6003.     save = ftell(ifp);
    6004. 

  6004.     fseek (ifp, base+data, SEEK_SET);
    6005. 

  6005.     switch (tag) {
    6006. 

  6006.       case 0x100:  flip = "0653"[data & 3]-'0';  break;
    6007. 

  6007.       case 0x106:
    6008. 

  6008. 	for (i=0; i < 9; i++)
    6009. 

  6009. 	  romm_cam[0][i] = getreal(11);
    6010. 

  6010. 	romm_coeff (romm_cam);
    6011. 

  6011. 	break;
    6012. 

  6012.       case 0x107:
    6013. 

  6013. 	FORC3 cam_mul[c] = getreal(11);
    6014. 

  6014. 	break;
    6015. 

  6015.       case 0x108:  raw_width     = data;	break;
    6016. 

  6016.       case 0x109:  raw_height    = data;	break;
    6017. 

  6017.       case 0x10a:  left_margin   = data;	break;
    6018. 

  6018.       case 0x10b:  top_margin    = data;	break;
    6019. 

  6019.       case 0x10c:  width         = data;	break;
    6020. 

  6020.       case 0x10d:  height        = data;	break;
    6021. 

  6021.       case 0x10e:  ph1.format    = data;	break;
    6022. 

  6022.       case 0x10f:  data_offset   = data+base;	break;
    6023. 

  6023.       case 0x110:  meta_offset   = data+base;
    6024. 

  6024. 		   meta_length   = len;			break;
    6025. 

  6025.       case 0x112:  ph1.key_off   = save - 4;		break;
    6026. 

  6026.       case 0x210:  ph1.tag_210   = int_to_float(data);	break;
    6027. 

  6027.       case 0x21a:  ph1.tag_21a   = data;		break;
    6028. 

  6028.       case 0x21c:  strip_offset  = data+base;		break;
    6029. 

  6029.       case 0x21d:  ph1.t_black     = data;		break;
    6030. 

  6030.       case 0x222:  ph1.split_col = data;		break;
    6031. 

  6031.       case 0x223:  ph1.black_off = data+base;		break;
    6032. 

  6032.       case 0x301:
    6033. 

  6033. 	model[63] = 0;
    6034. 

  6034. 	fread (model, 1, 63, ifp);
    6035. 

  6035. 	if ((cp = strstr(model," camera"))) *cp = 0;
    6036. 

  6036.     }
    6037. 

  6037.     fseek (ifp, save, SEEK_SET);
    6038. 

  6038.   }
    6039. 

  6039.   load_raw = ph1.format < 3 ?
    6040. 

  6040. 	&CLASS phase_one_load_raw : &CLASS phase_one_load_raw_c;
    6041. 

  6041.   maximum = 0xffff;
    6042. 

  6042.   strcpy (make, "Phase One");
    6043. 

  6043.   if (model[0]) return;
    6044. 

  6044.   switch (raw_height) {
    6045. 

  6045.     case 2060: strcpy (model,"LightPhase");	break;
    6046. 

  6046.     case 2682: strcpy (model,"H 10");		break;
    6047. 

  6047.     case 4128: strcpy (model,"H 20");		break;
    6048. 

  6048.     case 5488: strcpy (model,"H 25");		break;
    6049. 

  6049.   }
    6050. 

  6050. }
    6051. 

  6051. 

  6052. void CLASS parse_fuji (int offset)
    6053. 

  6053. {
    6054. 

  6054.   unsigned entries, tag, len, save, c;
    6055. 

  6055. 

  6056.   fseek (ifp, offset, SEEK_SET);
    6057. 

  6057.   entries = get4();
    6058. 

  6058.   if (entries > 255) return;
    6059. 

  6059.   while (entries--) {
    6060. 

  6060.     tag = get2();
    6061. 

  6061.     len = get2();
    6062. 

  6062.     save = ftell(ifp);
    6063. 

  6063.     if (tag == 0x100) {
    6064. 

  6064.       raw_height = get2();
    6065. 

  6065.       raw_width  = get2();
    6066. 

  6066.     } else if (tag == 0x121) {
    6067. 

  6067.       height = get2();
    6068. 

  6068.       if ((width = get2()) == 4284) width += 3;
    6069. 

  6069.     } else if (tag == 0x130) {
    6070. 

  6070.       fuji_layout = fgetc(ifp) >> 7;
    6071. 

  6071.       fuji_width = !(fgetc(ifp) & 8);
    6072. 

  6072.     } else if (tag == 0x2ff0) {
    6073. 

  6073.       FORC4 cam_mul[c ^ 1] = get2();
    6074. 

  6074.     } else if (tag == 0xc000) {
    6075. 

  6075.       c = order;
    6076. 

  6076.       order = 0x4949;
    6077. 

  6077.       if ((width = get4()) > 10000) width = get4();
    6078. 

  6078.       height = get4();
    6079. 

  6079.       order = c;
    6080. 

  6080.     }
    6081. 

  6081.     fseek (ifp, save+len, SEEK_SET);
    6082. 

  6082.   }
    6083. 

  6083.   height <<= fuji_layout;
    6084. 

  6084.   width  >>= fuji_layout;
    6085. 

  6085. }
    6086. 

  6086. 

  6087. int CLASS parse_jpeg (int offset)
    6088. 

  6088. {
    6089. 

  6089.   int len, save, hlen, mark;
    6090. 

  6090. 

  6091.   fseek (ifp, offset, SEEK_SET);
    6092. 

  6092.   if (fgetc(ifp) != 0xff || fgetc(ifp) != 0xd8) return 0;
    6093. 

  6093. 

  6094.   while (fgetc(ifp) == 0xff && (mark = fgetc(ifp)) != 0xda) {
    6095. 

  6095.     order = 0x4d4d;
    6096. 

  6096.     len   = get2() - 2;
    6097. 

  6097.     save  = ftell(ifp);
    6098. 

  6098.     if (mark == 0xc0 || mark == 0xc3) {
    6099. 

  6099.       fgetc(ifp);
    6100. 

  6100.       raw_height = get2();
    6101. 

  6101.       raw_width  = get2();
    6102. 

  6102.     }
    6103. 

  6103.     order = get2();
    6104. 

  6104.     hlen  = get4();
    6105. 

  6105.     if (get4() == 0x48454150)		/* "HEAP" */
    6106. 

  6106.       parse_ciff (save+hlen, len-hlen);
    6107. 

  6107.     if (parse_tiff (save+6)) apply_tiff();
    6108. 

  6108.     fseek (ifp, save+len, SEEK_SET);
    6109. 

  6109.   }
    6110. 

  6110.   return 1;
    6111. 

  6111. }
    6112. 

  6112. 

  6113. void CLASS parse_riff()
    6114. 

  6114. {
    6115. 

  6115.   unsigned i, size, end;
    6116. 

  6116.   char tag[4], date[64], month[64];
    6117. 

  6117.   static const char mon[12][4] =
    6118. 

  6118.   { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
    6119. 

  6119.   struct tm t;
    6120. 

  6120. 

  6121.   order = 0x4949;
    6122. 

  6122.   fread (tag, 4, 1, ifp);
    6123. 

  6123.   size = get4();
    6124. 

  6124.   end = ftell(ifp) + size;
    6125. 

  6125.   if (!memcmp(tag,"RIFF",4) || !memcmp(tag,"LIST",4)) {
    6126. 

  6126.     get4();
    6127. 

  6127.     while (ftell(ifp)+7 < end)
    6128. 

  6128.       parse_riff();
    6129. 

  6129.   } else if (!memcmp(tag,"nctg",4)) {
    6130. 

  6130.     while (ftell(ifp)+7 < end) {
    6131. 

  6131.       i = get2();
    6132. 

  6132.       size = get2();
    6133. 

  6133.       if ((i+1) >> 1 == 10 && size == 20)
    6134. 

  6134. 	get_timestamp(0);
    6135. 

  6135.       else fseek (ifp, size, SEEK_CUR);
    6136. 

  6136.     }
    6137. 

  6137.   } else if (!memcmp(tag,"IDIT",4) && size < 64) {
    6138. 

  6138.     fread (date, 64, 1, ifp);
    6139. 

  6139.     date[size] = 0;
    6140. 

  6140.     memset (&t, 0, sizeof t);
    6141. 

  6141.     if (sscanf (date, "%*s %s %d %d:%d:%d %d", month, &t.tm_mday,
    6142. 

  6142. 	&t.tm_hour, &t.tm_min, &t.tm_sec, &t.tm_year) == 6) {
    6143. 

  6143.       for (i=0; i < 12 && strcasecmp(mon[i],month); i++);
    6144. 

  6144.       t.tm_mon = i;
    6145. 

  6145.       t.tm_year -= 1900;
    6146. 

  6146.       if (mktime(&t) > 0)
    6147. 

  6147. 	timestamp = mktime(&t);
    6148. 

  6148.     }
    6149. 

  6149.   } else
    6150. 

  6150.     fseek (ifp, size, SEEK_CUR);
    6151. 

  6151. }
    6152. 

  6152. 

  6153. void CLASS parse_smal (int offset, int fsize)
    6154. 

  6154. {
    6155. 

  6155.   int ver;
    6156. 

  6156. 

  6157.   fseek (ifp, offset+2, SEEK_SET);
    6158. 

  6158.   order = 0x4949;
    6159. 

  6159.   ver = fgetc(ifp);
    6160. 

  6160.   if (ver == 6)
    6161. 

  6161.     fseek (ifp, 5, SEEK_CUR);
    6162. 

  6162.   if (get4() != fsize) return;
    6163. 

  6163.   if (ver > 6) data_offset = get4();
    6164. 

  6164.   raw_height = height = get2();
    6165. 

  6165.   raw_width  = width  = get2();
    6166. 

  6166.   strcpy (make, "SMaL");
    6167. 

  6167.   sprintf (model, "v%d %dx%d", ver, width, height);
    6168. 

  6168.   if (ver == 6) load_raw = &CLASS smal_v6_load_raw;
    6169. 

  6169.   if (ver == 9) load_raw = &CLASS smal_v9_load_raw;
    6170. 

  6170. }
    6171. 

  6171. 

  6172. void CLASS parse_cine()
    6173. 

  6173. {
    6174. 

  6174.   unsigned off_head, off_setup, off_image, i;
    6175. 

  6175. 

  6176.   order = 0x4949;
    6177. 

  6177.   fseek (ifp, 4, SEEK_SET);
    6178. 

  6178.   is_raw = get2() == 2;
    6179. 

  6179.   fseek (ifp, 14, SEEK_CUR);
    6180. 

  6180.   is_raw *= get4();
    6181. 

  6181.   off_head = get4();
    6182. 

  6182.   off_setup = get4();
    6183. 

  6183.   off_image = get4();
    6184. 

  6184.   timestamp = get4();
    6185. 

  6185.   if ((i = get4())) timestamp = i;
    6186. 

  6186.   fseek (ifp, off_head+4, SEEK_SET);
    6187. 

  6187.   raw_width = get4();
    6188. 

  6188.   raw_height = get4();
    6189. 

  6189.   switch (get2(),get2()) {
    6190. 

  6190.     case  8:  load_raw = &CLASS eight_bit_load_raw;  break;
    6191. 

  6191.     case 16:  load_raw = &CLASS  unpacked_load_raw;
    6192. 

  6192.   }
    6193. 

  6193.   fseek (ifp, off_setup+792, SEEK_SET);
    6194. 

  6194.   strcpy (make, "CINE");
    6195. 

  6195.   sprintf (model, "%d", get4());
    6196. 

  6196.   fseek (ifp, 12, SEEK_CUR);
    6197. 

  6197.   switch ((i=get4()) & 0xffffff) {
    6198. 

  6198.     case  3:  filters = 0x94949494;  break;
    6199. 

  6199.     case  4:  filters = 0x49494949;  break;
    6200. 

  6200.     default:  is_raw = 0;
    6201. 

  6201.   }
    6202. 

  6202.   fseek (ifp, 72, SEEK_CUR);
    6203. 

  6203.   switch ((get4()+3600) % 360) {
    6204. 

  6204.     case 270:  flip = 4;  break;
    6205. 

  6205.     case 180:  flip = 1;  break;
    6206. 

  6206.     case  90:  flip = 7;  break;
    6207. 

  6207.     case   0:  flip = 2;
    6208. 

  6208.   }
    6209. 

  6209.   cam_mul[0] = getreal(11);
    6210. 

  6210.   cam_mul[2] = getreal(11);
    6211. 

  6211.   maximum = ~(-1 << get4());
    6212. 

  6212.   fseek (ifp, 668, SEEK_CUR);
    6213. 

  6213.   shutter = get4()/1000000000.0;
    6214. 

  6214.   fseek (ifp, off_image, SEEK_SET);
    6215. 

  6215.   if (shot_select < is_raw)
    6216. 

  6216.     fseek (ifp, shot_select*8, SEEK_CUR);
    6217. 

  6217.   data_offset  = (INT64) get4() + 8;
    6218. 

  6218.   data_offset += (INT64) get4() << 32;
    6219. 

  6219. }
    6220. 

  6220. 

  6221. void CLASS parse_redcine()
    6222. 

  6222. {
    6223. 

  6223.   unsigned i, len, rdvo;
    6224. 

  6224. 

  6225.   order = 0x4d4d;
    6226. 

  6226.   is_raw = 0;
    6227. 

  6227.   fseek (ifp, 52, SEEK_SET);
    6228. 

  6228.   width  = get4();
    6229. 

  6229.   height = get4();
    6230. 

  6230.   fseek (ifp, 0, SEEK_END);
    6231. 

  6231.   fseek (ifp, -(i = ftello(ifp) & 511), SEEK_CUR);
    6232. 

  6232.   if (get4() != i || get4() != 0x52454f42) {
    6233. 

  6233. #ifdef DCRAW_VERBOSE
    6234. 

  6234.     fprintf (stderr,_("%s: Tail is missing, parsing from head...\n"), ifname);
    6235. 

  6235. #endif
    6236. 

  6236.     fseek (ifp, 0, SEEK_SET);
    6237. 

  6237.     while ((len = get4()) != EOF) {
    6238. 

  6238.       if (get4() == 0x52454456)
    6239. 

  6239. 	if (is_raw++ == shot_select)
    6240. 

  6240. 	  data_offset = ftello(ifp) - 8;
    6241. 

  6241.       fseek (ifp, len-8, SEEK_CUR);
    6242. 

  6242.     }
    6243. 

  6243.   } else {
    6244. 

  6244.     rdvo = get4();
    6245. 

  6245.     fseek (ifp, 12, SEEK_CUR);
    6246. 

  6246.     is_raw = get4();
    6247. 

  6247.     fseeko (ifp, rdvo+8 + shot_select*4, SEEK_SET);
    6248. 

  6248.     data_offset = get4();
    6249. 

  6249.   }
    6250. 

  6250. }
    6251. 

  6251. #line 7405 "dcraw/dcraw.c"
    6252. 

  6252. char * CLASS foveon_gets (int offset, char *str, int len)
    6253. 

  6253. {
    6254. 

  6254.   int i;
    6255. 

  6255.   fseek (ifp, offset, SEEK_SET);
    6256. 

  6256.   for (i=0; i < len-1; i++)
    6257. 

  6257.     if ((str[i] = get2()) == 0) break;
    6258. 

  6258.   str[i] = 0;
    6259. 

  6259.   return str;
    6260. 

  6260. }
    6261. 

  6261. 

  6262. void CLASS parse_foveon()
    6263. 

  6263. {
    6264. 

  6264.   int entries, img=0, off, len, tag, save, i, wide, high, pent, poff[256][2];
    6265. 

  6265.   char name[64], value[64];
    6266. 

  6266. 

  6267.   order = 0x4949;			/* Little-endian */
    6268. 

  6268.   fseek (ifp, 36, SEEK_SET);
    6269. 

  6269.   flip = get4();
    6270. 

  6270.   fseek (ifp, -4, SEEK_END);
    6271. 

  6271.   fseek (ifp, get4(), SEEK_SET);
    6272. 

  6272.   if (get4() != 0x64434553) return;	/* SECd */
    6273. 

  6273.   entries = (get4(),get4());
    6274. 

  6274.   while (entries--) {
    6275. 

  6275.     off = get4();
    6276. 

  6276.     len = get4();
    6277. 

  6277.     tag = get4();
    6278. 

  6278.     save = ftell(ifp);
    6279. 

  6279.     fseek (ifp, off, SEEK_SET);
    6280. 

  6280.     if (get4() != (0x20434553 | (tag << 24))) return;
    6281. 

  6281.     switch (tag) {
    6282. 

  6282.       case 0x47414d49:			/* IMAG */
    6283. 

  6283.       case 0x32414d49:			/* IMA2 */
    6284. 

  6284. 	fseek (ifp, 8, SEEK_CUR);
    6285. 

  6285. 	pent = get4();
    6286. 

  6286. 	wide = get4();
    6287. 

  6287. 	high = get4();
    6288. 

  6288. 	if (wide > raw_width && high > raw_height) {
    6289. 

  6289. 	  switch (pent) {
    6290. 

  6290. 	    case  5:  load_flags = 1;
    6291. 

  6291. 	    case  6:  load_raw = &CLASS foveon_sd_load_raw;  break;
    6292. 

  6292. 	    case 30:  load_raw = &CLASS foveon_dp_load_raw;  break;
    6293. 

  6293. 	    default:  load_raw = 0;
    6294. 

  6294. 	  }
    6295. 

  6295. 	  raw_width  = wide;
    6296. 

  6296. 	  raw_height = high;
    6297. 

  6297. 	  data_offset = off+28;
    6298. 

  6298. 	}
    6299. 

  6299. 	fseek (ifp, off+28, SEEK_SET);
    6300. 

  6300. 	if (fgetc(ifp) == 0xff && fgetc(ifp) == 0xd8
    6301. 

  6301. 		&& thumb_length < len-28) {
    6302. 

  6302. 	  thumb_offset = off+28;
    6303. 

  6303. 	  thumb_length = len-28;
    6304. 

  6304. 	  write_thumb = &CLASS jpeg_thumb;
    6305. 

  6305. 	}
    6306. 

  6306. 	if (++img == 2 && !thumb_length) {
    6307. 

  6307. 	  thumb_offset = off+24;
    6308. 

  6308. 	  thumb_width = wide;
    6309. 

  6309. 	  thumb_height = high;
    6310. 

  6310. 	  write_thumb = &CLASS foveon_thumb;
    6311. 

  6311. 	}
    6312. 

  6312. 	break;
    6313. 

  6313.       case 0x464d4143:			/* CAMF */
    6314. 

  6314. 	meta_offset = off+8;
    6315. 

  6315. 	meta_length = len-28;
    6316. 

  6316. 	break;
    6317. 

  6317.       case 0x504f5250:			/* PROP */
    6318. 

  6318. 	pent = (get4(),get4());
    6319. 

  6319. 	fseek (ifp, 12, SEEK_CUR);
    6320. 

  6320. 	off += pent*8 + 24;
    6321. 

  6321. 	if ((unsigned) pent > 256) pent=256;
    6322. 

  6322. 	for (i=0; i < pent*2; i++)
    6323. 

  6323. 	  poff[0][i] = off + get4()*2;
    6324. 

  6324. 	for (i=0; i < pent; i++) {
    6325. 

  6325. 	  foveon_gets (poff[i][0], name, 64);
    6326. 

  6326. 	  foveon_gets (poff[i][1], value, 64);
    6327. 

  6327. 	  if (!strcmp (name, "ISO"))
    6328. 

  6328. 	    iso_speed = atoi(value);
    6329. 

  6329. 	  if (!strcmp (name, "CAMMANUF"))
    6330. 

  6330. 	    strcpy (make, value);
    6331. 

  6331. 	  if (!strcmp (name, "CAMMODEL"))
    6332. 

  6332. 	    strcpy (model, value);
    6333. 

  6333. 	  if (!strcmp (name, "WB_DESC"))
    6334. 

  6334. 	    strcpy (model2, value);
    6335. 

  6335. 	  if (!strcmp (name, "TIME"))
    6336. 

  6336. 	    timestamp = atoi(value);
    6337. 

  6337. 	  if (!strcmp (name, "EXPTIME"))
    6338. 

  6338. 	    shutter = atoi(value) / 1000000.0;
    6339. 

  6339. 	  if (!strcmp (name, "APERTURE"))
    6340. 

  6340. 	    aperture = atof(value);
    6341. 

  6341. 	  if (!strcmp (name, "FLENGTH"))
    6342. 

  6342. 	    focal_len = atof(value);
    6343. 

  6343. 	}
    6344. 

  6344. #ifdef LOCALTIME
    6345. 

  6345. 	timestamp = mktime (gmtime (&timestamp));
    6346. 

  6346. #endif
    6347. 

  6347.     }
    6348. 

  6348.     fseek (ifp, save, SEEK_SET);
    6349. 

  6349.   }
    6350. 

  6350.   is_foveon = 1;
    6351. 

  6351. }
    6352. 

  6352. #line 7508 "dcraw/dcraw.c"
    6353. 

  6353. /*
    6354. 

  6354.    All matrices are from Adobe DNG Converter unless otherwise noted.
    6355. 

  6355.  */
    6356. 

  6356. void CLASS adobe_coeff (const char *t_make, const char *t_model)
    6357. 

  6357. {
    6358. 

  6358.   static const struct {
    6359. 

  6359.     const char *prefix;
    6360. 

  6360.     short t_black, t_maximum, trans[12];
    6361. 

  6361.   } table[] = {
    6362. 

  6362.     { "AGFAPHOTO DC-833m", 0, 0,	/* DJC */
    6363. 

  6363. 	{ 11438,-3762,-1115,-2409,9914,2497,-1227,2295,5300 } },
    6364. 

  6364.     { "Apple QuickTake", 0, 0,		/* DJC */
    6365. 

  6365. 	{ 21392,-5653,-3353,2406,8010,-415,7166,1427,2078 } },
    6366. 

  6366.     { "Canon EOS D2000", 0, 0,
    6367. 

  6367. 	{ 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } },
    6368. 

  6368.     { "Canon EOS D6000", 0, 0,
    6369. 

  6369. 	{ 20482,-7172,-3125,-1033,10410,-285,2542,226,3136 } },
    6370. 

  6370.     { "Canon EOS D30", 0, 0,
    6371. 

  6371. 	{ 9805,-2689,-1312,-5803,13064,3068,-2438,3075,8775 } },
    6372. 

  6372.     { "Canon EOS D60", 0, 0xfa0,
    6373. 

  6373. 	{ 6188,-1341,-890,-7168,14489,2937,-2640,3228,8483 } },
    6374. 

  6374.     { "Canon EOS 5D Mark III", 0, 0x3c80,
    6375. 

  6375. 	{ 6722,-635,-963,-4287,12460,2028,-908,2162,5668 } },
    6376. 

  6376.     { "Canon EOS 5D Mark II", 0, 0x3cf0,
    6377. 

  6377. 	{ 4716,603,-830,-7798,15474,2480,-1496,1937,6651 } },
    6378. 

  6378.     { "Canon EOS 5D", 0, 0xe6c,
    6379. 

  6379. 	{ 6347,-479,-972,-8297,15954,2480,-1968,2131,7649 } },
    6380. 

  6380.     { "Canon EOS 6D", 0, 0x3c82,
    6381. 

  6381. 	{ 7034,-804,-1014,-4420,12564,2058,-851,1994,5758 } },
    6382. 

  6382.     { "Canon EOS 7D", 0, 0x3510,
    6383. 

  6383. 	{ 6844,-996,-856,-3876,11761,2396,-593,1772,6198 } },
    6384. 

  6384.     { "Canon EOS 10D", 0, 0xfa0,
    6385. 

  6385. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6386. 

  6386.     { "Canon EOS 20Da", 0, 0,
    6387. 

  6387. 	{ 14155,-5065,-1382,-6550,14633,2039,-1623,1824,6561 } },
    6388. 

  6388.     { "Canon EOS 20D", 0, 0xfff,
    6389. 

  6389. 	{ 6599,-537,-891,-8071,15783,2424,-1983,2234,7462 } },
    6390. 

  6390.     { "Canon EOS 30D", 0, 0,
    6391. 

  6391. 	{ 6257,-303,-1000,-7880,15621,2396,-1714,1904,7046 } },
    6392. 

  6392.     { "Canon EOS 40D", 0, 0x3f60,
    6393. 

  6393. 	{ 6071,-747,-856,-7653,15365,2441,-2025,2553,7315 } },
    6394. 

  6394.     { "Canon EOS 50D", 0, 0x3d93,
    6395. 

  6395. 	{ 4920,616,-593,-6493,13964,2784,-1774,3178,7005 } },
    6396. 

  6396.     { "Canon EOS 60D", 0, 0x2ff7,
    6397. 

  6397. 	{ 6719,-994,-925,-4408,12426,2211,-887,2129,6051 } },
    6398. 

  6398.     { "Canon EOS 300D", 0, 0xfa0,
    6399. 

  6399. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6400. 

  6400.     { "Canon EOS 350D", 0, 0xfff,
    6401. 

  6401. 	{ 6018,-617,-965,-8645,15881,2975,-1530,1719,7642 } },
    6402. 

  6402.     { "Canon EOS 400D", 0, 0xe8e,
    6403. 

  6403. 	{ 7054,-1501,-990,-8156,15544,2812,-1278,1414,7796 } },
    6404. 

  6404.     { "Canon EOS 450D", 0, 0x390d,
    6405. 

  6405. 	{ 5784,-262,-821,-7539,15064,2672,-1982,2681,7427 } },
    6406. 

  6406.     { "Canon EOS 500D", 0, 0x3479,
    6407. 

  6407. 	{ 4763,712,-646,-6821,14399,2640,-1921,3276,6561 } },
    6408. 

  6408.     { "Canon EOS 550D", 0, 0x3dd7,
    6409. 

  6409. 	{ 6941,-1164,-857,-3825,11597,2534,-416,1540,6039 } },
    6410. 

  6410.     { "Canon EOS 600D", 0, 0x3510,
    6411. 

  6411. 	{ 6461,-907,-882,-4300,12184,2378,-819,1944,5931 } },
    6412. 

  6412.     { "Canon EOS 650D", 0, 0x354d,
    6413. 

  6413. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6414. 

  6414.     { "Canon EOS 1000D", 0, 0xe43,
    6415. 

  6415. 	{ 6771,-1139,-977,-7818,15123,2928,-1244,1437,7533 } },
    6416. 

  6416.     { "Canon EOS 1100D", 0, 0x3510,
    6417. 

  6417. 	{ 6444,-904,-893,-4563,12308,2535,-903,2016,6728 } },
    6418. 

  6418.     { "Canon EOS M", 0, 0,
    6419. 

  6419. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6420. 

  6420.     { "Canon EOS-1Ds Mark III", 0, 0x3bb0,
    6421. 

  6421. 	{ 5859,-211,-930,-8255,16017,2353,-1732,1887,7448 } },
    6422. 

  6422.     { "Canon EOS-1Ds Mark II", 0, 0xe80,
    6423. 

  6423. 	{ 6517,-602,-867,-8180,15926,2378,-1618,1771,7633 } },
    6424. 

  6424.     { "Canon EOS-1D Mark IV", 0, 0x3bb0,
    6425. 

  6425. 	{ 6014,-220,-795,-4109,12014,2361,-561,1824,5787 } },
    6426. 

  6426.     { "Canon EOS-1D Mark III", 0, 0x3bb0,
    6427. 

  6427. 	{ 6291,-540,-976,-8350,16145,2311,-1714,1858,7326 } },
    6428. 

  6428.     { "Canon EOS-1D Mark II N", 0, 0xe80,
    6429. 

  6429. 	{ 6240,-466,-822,-8180,15825,2500,-1801,1938,8042 } },
    6430. 

  6430.     { "Canon EOS-1D Mark II", 0, 0xe80,
    6431. 

  6431. 	{ 6264,-582,-724,-8312,15948,2504,-1744,1919,8664 } },
    6432. 

  6432.     { "Canon EOS-1DS", 0, 0xe20,
    6433. 

  6433. 	{ 4374,3631,-1743,-7520,15212,2472,-2892,3632,8161 } },
    6434. 

  6434.     { "Canon EOS-1D X", 0, 0x3c4e,
    6435. 

  6435. 	{ 6847,-614,-1014,-4669,12737,2139,-1197,2488,6846 } },
    6436. 

  6436.     { "Canon EOS-1D", 0, 0xe20,
    6437. 

  6437. 	{ 6806,-179,-1020,-8097,16415,1687,-3267,4236,7690 } },
    6438. 

  6438.     { "Canon EOS", 0, 0,
    6439. 

  6439. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6440. 

  6440.     { "Canon PowerShot A530", 0, 0,
    6441. 

  6441. 	{ 0 } },	/* don't want the A5 matrix */
    6442. 

  6442.     { "Canon PowerShot A50", 0, 0,
    6443. 

  6443. 	{ -5300,9846,1776,3436,684,3939,-5540,9879,6200,-1404,11175,217 } },
    6444. 

  6444.     { "Canon PowerShot A5", 0, 0,
    6445. 

  6445. 	{ -4801,9475,1952,2926,1611,4094,-5259,10164,5947,-1554,10883,547 } },
    6446. 

  6446.     { "Canon PowerShot G10", 0, 0,
    6447. 

  6447. 	{ 11093,-3906,-1028,-5047,12492,2879,-1003,1750,5561 } },
    6448. 

  6448.     { "Canon PowerShot G11", 0, 0,
    6449. 

  6449. 	{ 12177,-4817,-1069,-1612,9864,2049,-98,850,4471 } },
    6450. 

  6450.     { "Canon PowerShot G12", 0, 0,
    6451. 

  6451. 	{ 13244,-5501,-1248,-1508,9858,1935,-270,1083,4366 } },
    6452. 

  6452.     { "Canon PowerShot G15", 0, 0,
    6453. 

  6453. 	{ 7474,-2301,-567,-4056,11456,2975,-222,716,4181 } },
    6454. 

  6454.     { "Canon PowerShot G1 X", 0, 0,
    6455. 

  6455. 	{ 7378,-1255,-1043,-4088,12251,2048,-876,1946,5805 } },
    6456. 

  6456.     { "Canon PowerShot G1", 0, 0,
    6457. 

  6457. 	{ -4778,9467,2172,4743,-1141,4344,-5146,9908,6077,-1566,11051,557 } },
    6458. 

  6458.     { "Canon PowerShot G2", 0, 0,
    6459. 

  6459. 	{ 9087,-2693,-1049,-6715,14382,2537,-2291,2819,7790 } },
    6460. 

  6460.     { "Canon PowerShot G3", 0, 0,
    6461. 

  6461. 	{ 9212,-2781,-1073,-6573,14189,2605,-2300,2844,7664 } },
    6462. 

  6462.     { "Canon PowerShot G5", 0, 0,
    6463. 

  6463. 	{ 9757,-2872,-933,-5972,13861,2301,-1622,2328,7212 } },
    6464. 

  6464.     { "Canon PowerShot G6", 0, 0,
    6465. 

  6465. 	{ 9877,-3775,-871,-7613,14807,3072,-1448,1305,7485 } },
    6466. 

  6466.     { "Canon PowerShot G9", 0, 0,
    6467. 

  6467. 	{ 7368,-2141,-598,-5621,13254,2625,-1418,1696,5743 } },
    6468. 

  6468.     { "Canon PowerShot Pro1", 0, 0,
    6469. 

  6469. 	{ 10062,-3522,-999,-7643,15117,2730,-765,817,7323 } },
    6470. 

  6470.     { "Canon PowerShot Pro70", 34, 0,
    6471. 

  6471. 	{ -4155,9818,1529,3939,-25,4522,-5521,9870,6610,-2238,10873,1342 } },
    6472. 

  6472.     { "Canon PowerShot Pro90", 0, 0,
    6473. 

  6473. 	{ -4963,9896,2235,4642,-987,4294,-5162,10011,5859,-1770,11230,577 } },
    6474. 

  6474.     { "Canon PowerShot S30", 0, 0,
    6475. 

  6475. 	{ 10566,-3652,-1129,-6552,14662,2006,-2197,2581,7670 } },
    6476. 

  6476.     { "Canon PowerShot S40", 0, 0,
    6477. 

  6477. 	{ 8510,-2487,-940,-6869,14231,2900,-2318,2829,9013 } },
    6478. 

  6478.     { "Canon PowerShot S45", 0, 0,
    6479. 

  6479. 	{ 8163,-2333,-955,-6682,14174,2751,-2077,2597,8041 } },
    6480. 

  6480.     { "Canon PowerShot S50", 0, 0,
    6481. 

  6481. 	{ 8882,-2571,-863,-6348,14234,2288,-1516,2172,6569 } },
    6482. 

  6482.     { "Canon PowerShot S60", 0, 0,
    6483. 

  6483. 	{ 8795,-2482,-797,-7804,15403,2573,-1422,1996,7082 } },
    6484. 

  6484.     { "Canon PowerShot S70", 0, 0,
    6485. 

  6485. 	{ 9976,-3810,-832,-7115,14463,2906,-901,989,7889 } },
    6486. 

  6486.     { "Canon PowerShot S90", 0, 0,
    6487. 

  6487. 	{ 12374,-5016,-1049,-1677,9902,2078,-83,852,4683 } },
    6488. 

  6488.     { "Canon PowerShot S95", 0, 0,
    6489. 

  6489. 	{ 13440,-5896,-1279,-1236,9598,1931,-180,1001,4651 } },
    6490. 

  6490.     { "Canon PowerShot S110", 0, 0,
    6491. 

  6491. 	{ 8039,-2643,-654,-3783,11230,2930,-206,690,4194 } },
    6492. 

  6492.     { "Canon PowerShot S100", 0, 0,
    6493. 

  6493. 	{ 7968,-2565,-636,-2873,10697,2513,180,667,4211 } },
    6494. 

  6494.     { "Canon PowerShot S110", 0, 0,
    6495. 

  6495. 	{ 8039,-2643,-654,-3783,11230,2930,-206,690,4194 } },
    6496. 

  6496.     { "Canon PowerShot SX1 IS", 0, 0,
    6497. 

  6497. 	{ 6578,-259,-502,-5974,13030,3309,-308,1058,4970 } },
    6498. 

  6498.     { "Canon PowerShot SX50 HS", 0, 0,
    6499. 

  6499. 	{ 12432,-4753,-1247,-2110,10691,1629,-412,1623,4926 } },
    6500. 

  6500.     { "Canon PowerShot A470", 0, 0,	/* DJC */
    6501. 

  6501. 	{ 12513,-4407,-1242,-2680,10276,2405,-878,2215,4734 } },
    6502. 

  6502.     { "Canon PowerShot A610", 0, 0,	/* DJC */
    6503. 

  6503. 	{ 15591,-6402,-1592,-5365,13198,2168,-1300,1824,5075 } },
    6504. 

  6504.     { "Canon PowerShot A620", 0, 0,	/* DJC */
    6505. 

  6505. 	{ 15265,-6193,-1558,-4125,12116,2010,-888,1639,5220 } },
    6506. 

  6506.     { "Canon PowerShot A630", 0, 0,	/* DJC */
    6507. 

  6507. 	{ 14201,-5308,-1757,-6087,14472,1617,-2191,3105,5348 } },
    6508. 

  6508.     { "Canon PowerShot A640", 0, 0,	/* DJC */
    6509. 

  6509. 	{ 13124,-5329,-1390,-3602,11658,1944,-1612,2863,4885 } },
    6510. 

  6510.     { "Canon PowerShot A650", 0, 0,	/* DJC */
    6511. 

  6511. 	{ 9427,-3036,-959,-2581,10671,1911,-1039,1982,4430 } },
    6512. 

  6512.     { "Canon PowerShot A720", 0, 0,	/* DJC */
    6513. 

  6513. 	{ 14573,-5482,-1546,-1266,9799,1468,-1040,1912,3810 } },
    6514. 

  6514.     { "Canon PowerShot S3 IS", 0, 0,	/* DJC */
    6515. 

  6515. 	{ 14062,-5199,-1446,-4712,12470,2243,-1286,2028,4836 } },
    6516. 

  6516.     { "Canon PowerShot SX110 IS", 0, 0,	/* DJC */
    6517. 

  6517. 	{ 14134,-5576,-1527,-1991,10719,1273,-1158,1929,3581 } },
    6518. 

  6518.     { "Canon PowerShot SX220", 0, 0,	/* DJC */
    6519. 

  6519. 	{ 13898,-5076,-1447,-1405,10109,1297,-244,1860,3687 } },
    6520. 

  6520.     { "Canon PowerShot SX50", 0, 0,
    6521. 

  6521. 	{ 12432,-4753,-1247,-2110,10691,1629,-412,1623,4926 } },
    6522. 

  6522.     { "CASIO EX-S20", 0, 0,		/* DJC */
    6523. 

  6523. 	{ 11634,-3924,-1128,-4968,12954,2015,-1588,2648,7206 } },
    6524. 

  6524.     { "CASIO EX-Z750", 0, 0,		/* DJC */
    6525. 

  6525. 	{ 10819,-3873,-1099,-4903,13730,1175,-1755,3751,4632 } },
    6526. 

  6526.     { "CASIO EX-Z10", 128, 0xfff,	/* DJC */
    6527. 

  6527. 	{ 9790,-3338,-603,-2321,10222,2099,-344,1273,4799 } },
    6528. 

  6528.     { "CINE 650", 0, 0,
    6529. 

  6529. 	{ 3390,480,-500,-800,3610,340,-550,2336,1192 } },
    6530. 

  6530.     { "CINE 660", 0, 0,
    6531. 

  6531. 	{ 3390,480,-500,-800,3610,340,-550,2336,1192 } },
    6532. 

  6532.     { "CINE", 0, 0,
    6533. 

  6533. 	{ 20183,-4295,-423,-3940,15330,3985,-280,4870,9800 } },
    6534. 

  6534.     { "Contax N Digital", 0, 0xf1e,
    6535. 

  6535. 	{ 7777,1285,-1053,-9280,16543,2916,-3677,5679,7060 } },
    6536. 

  6536.     { "EPSON R-D1", 0, 0,
    6537. 

  6537. 	{ 6827,-1878,-732,-8429,16012,2564,-704,592,7145 } },
    6538. 

  6538.     { "FUJIFILM E550", 0, 0,
    6539. 

  6539. 	{ 11044,-3888,-1120,-7248,15168,2208,-1531,2277,8069 } },
    6540. 

  6540.     { "FUJIFILM E900", 0, 0,
    6541. 

  6541. 	{ 9183,-2526,-1078,-7461,15071,2574,-2022,2440,8639 } },
    6542. 

  6542.     { "FUJIFILM F5", 0, 0,
    6543. 

  6543. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6544. 

  6544.     { "FUJIFILM F6", 0, 0,
    6545. 

  6545. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6546. 

  6546.     { "FUJIFILM F77", 0, 0xfe9,
    6547. 

  6547. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6548. 

  6548.     { "FUJIFILM F7", 0, 0,
    6549. 

  6549. 	{ 10004,-3219,-1201,-7036,15047,2107,-1863,2565,7736 } },
    6550. 

  6550.     { "FUJIFILM F800", 0, 0,
    6551. 

  6551. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6552. 

  6552.     { "FUJIFILM F8", 0, 0,
    6553. 

  6553. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6554. 

  6554.     { "FUJIFILM S100FS", 514, 0,
    6555. 

  6555. 	{ 11521,-4355,-1065,-6524,13767,3058,-1466,1984,6045 } },
    6556. 

  6556.     { "FUJIFILM S200EXR", 512, 0x3fff,
    6557. 

  6557. 	{ 11401,-4498,-1312,-5088,12751,2613,-838,1568,5941 } },
    6558. 

  6558.     { "FUJIFILM S20Pro", 0, 0,
    6559. 

  6559. 	{ 10004,-3219,-1201,-7036,15047,2107,-1863,2565,7736 } },
    6560. 

  6560.     { "FUJIFILM S2Pro", 128, 0,
    6561. 

  6561. 	{ 12492,-4690,-1402,-7033,15423,1647,-1507,2111,7697 } },
    6562. 

  6562.     { "FUJIFILM S3Pro", 0, 0,
    6563. 

  6563. 	{ 11807,-4612,-1294,-8927,16968,1988,-2120,2741,8006 } },
    6564. 

  6564.     { "FUJIFILM S5Pro", 0, 0,
    6565. 

  6565. 	{ 12300,-5110,-1304,-9117,17143,1998,-1947,2448,8100 } },
    6566. 

  6566.     { "FUJIFILM S5000", 0, 0,
    6567. 

  6567. 	{ 8754,-2732,-1019,-7204,15069,2276,-1702,2334,6982 } },
    6568. 

  6568.     { "FUJIFILM S5100", 0, 0,
    6569. 

  6569. 	{ 11940,-4431,-1255,-6766,14428,2542,-993,1165,7421 } },
    6570. 

  6570.     { "FUJIFILM S5500", 0, 0,
    6571. 

  6571. 	{ 11940,-4431,-1255,-6766,14428,2542,-993,1165,7421 } },
    6572. 

  6572.     { "FUJIFILM S5200", 0, 0,
    6573. 

  6573. 	{ 9636,-2804,-988,-7442,15040,2589,-1803,2311,8621 } },
    6574. 

  6574.     { "FUJIFILM S5600", 0, 0,
    6575. 

  6575. 	{ 9636,-2804,-988,-7442,15040,2589,-1803,2311,8621 } },
    6576. 

  6576.     { "FUJIFILM S6", 0, 0,
    6577. 

  6577. 	{ 12628,-4887,-1401,-6861,14996,1962,-2198,2782,7091 } },
    6578. 

  6578.     { "FUJIFILM S7000", 0, 0,
    6579. 

  6579. 	{ 10190,-3506,-1312,-7153,15051,2238,-2003,2399,7505 } },
    6580. 

  6580.     { "FUJIFILM S9000", 0, 0,
    6581. 

  6581. 	{ 10491,-3423,-1145,-7385,15027,2538,-1809,2275,8692 } },
    6582. 

  6582.     { "FUJIFILM S9500", 0, 0,
    6583. 

  6583. 	{ 10491,-3423,-1145,-7385,15027,2538,-1809,2275,8692 } },
    6584. 

  6584.     { "FUJIFILM S9100", 0, 0,
    6585. 

  6585. 	{ 12343,-4515,-1285,-7165,14899,2435,-1895,2496,8800 } },
    6586. 

  6586.     { "FUJIFILM S9600", 0, 0,
    6587. 

  6587. 	{ 12343,-4515,-1285,-7165,14899,2435,-1895,2496,8800 } },
    6588. 

  6588.     { "FUJIFILM IS-1", 0, 0,
    6589. 

  6589. 	{ 21461,-10807,-1441,-2332,10599,1999,289,875,7703 } },
    6590. 

  6590.     { "FUJIFILM IS Pro", 0, 0,
    6591. 

  6591. 	{ 12300,-5110,-1304,-9117,17143,1998,-1947,2448,8100 } },
    6592. 

  6592.     { "FUJIFILM HS10 HS11", 0, 0xf68,
    6593. 

  6593. 	{ 12440,-3954,-1183,-1123,9674,1708,-83,1614,4086 } },
    6594. 

  6594.     { "FUJIFILM HS20EXR", 0, 0,
    6595. 

  6595. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6596. 

  6596.     { "FUJIFILM HS3", 0, 0,
    6597. 

  6597. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6598. 

  6598.     { "FUJIFILM X100", 0, 0,
    6599. 

  6599. 	{ 12161,-4457,-1069,-5034,12874,2400,-795,1724,6904 } },
    6600. 

  6600.     { "FUJIFILM X10", 0, 0,
    6601. 

  6601. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6602. 

  6602.     { "FUJIFILM XF1", 0, 0,
    6603. 

  6603. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6604. 

  6604.     { "FUJIFILM X-Pro1", 0, 0,
    6605. 

  6605. 	{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
    6606. 

  6606.     { "FUJIFILM X-E1", 0, 0,
    6607. 

  6607. 	{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
    6608. 

  6608.     { "FUJIFILM XF1", 0, 0,
    6609. 

  6609. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6610. 

  6610.     { "FUJIFILM X-S1", 0, 0,
    6611. 

  6611. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6612. 

  6612.     { "Imacon Ixpress", 0, 0,		/* DJC */
    6613. 

  6613. 	{ 7025,-1415,-704,-5188,13765,1424,-1248,2742,6038 } },
    6614. 

  6614.     { "KODAK NC2000", 0, 0,
    6615. 

  6615. 	{ 13891,-6055,-803,-465,9919,642,2121,82,1291 } },
    6616. 

  6616.     { "Kodak DCS315C", 8, 0,
    6617. 

  6617. 	{ 17523,-4827,-2510,756,8546,-137,6113,1649,2250 } },
    6618. 

  6618.     { "Kodak DCS330C", 8, 0,
    6619. 

  6619. 	{ 20620,-7572,-2801,-103,10073,-396,3551,-233,2220 } },
    6620. 

  6620.     { "KODAK DCS420", 0, 0,
    6621. 

  6621. 	{ 10868,-1852,-644,-1537,11083,484,2343,628,2216 } },
    6622. 

  6622.     { "KODAK DCS460", 0, 0,
    6623. 

  6623. 	{ 10592,-2206,-967,-1944,11685,230,2206,670,1273 } },
    6624. 

  6624.     { "KODAK EOSDCS1", 0, 0,
    6625. 

  6625. 	{ 10592,-2206,-967,-1944,11685,230,2206,670,1273 } },
    6626. 

  6626.     { "KODAK EOSDCS3B", 0, 0,
    6627. 

  6627. 	{ 9898,-2700,-940,-2478,12219,206,1985,634,1031 } },
    6628. 

  6628.     { "Kodak DCS520C", 178, 0,
    6629. 

  6629. 	{ 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } },
    6630. 

  6630.     { "Kodak DCS560C", 177, 0,
    6631. 

  6631. 	{ 20482,-7172,-3125,-1033,10410,-285,2542,226,3136 } },
    6632. 

  6632.     { "Kodak DCS620C", 177, 0,
    6633. 

  6633. 	{ 23617,-10175,-3149,-2054,11749,-272,2586,-489,3453 } },
    6634. 

  6634.     { "Kodak DCS620X", 176, 0,
    6635. 

  6635. 	{ 13095,-6231,154,12221,-21,-2137,895,4602,2258 } },
    6636. 

  6636.     { "Kodak DCS660C", 173, 0,
    6637. 

  6637. 	{ 18244,-6351,-2739,-791,11193,-521,3711,-129,2802 } },
    6638. 

  6638.     { "Kodak DCS720X", 0, 0,
    6639. 

  6639. 	{ 11775,-5884,950,9556,1846,-1286,-1019,6221,2728 } },
    6640. 

  6640.     { "Kodak DCS760C", 0, 0,
    6641. 

  6641. 	{ 16623,-6309,-1411,-4344,13923,323,2285,274,2926 } },
    6642. 

  6642.     { "Kodak DCS Pro SLR", 0, 0,
    6643. 

  6643. 	{ 5494,2393,-232,-6427,13850,2846,-1876,3997,5445 } },
    6644. 

  6644.     { "Kodak DCS Pro 14nx", 0, 0,
    6645. 

  6645. 	{ 5494,2393,-232,-6427,13850,2846,-1876,3997,5445 } },
    6646. 

  6646.     { "Kodak DCS Pro 14", 0, 0,
    6647. 

  6647. 	{ 7791,3128,-776,-8588,16458,2039,-2455,4006,6198 } },
    6648. 

  6648.     { "Kodak ProBack645", 0, 0,
    6649. 

  6649. 	{ 16414,-6060,-1470,-3555,13037,473,2545,122,4948 } },
    6650. 

  6650.     { "Kodak ProBack", 0, 0,
    6651. 

  6651. 	{ 21179,-8316,-2918,-915,11019,-165,3477,-180,4210 } },
    6652. 

  6652.     { "KODAK P712", 0, 0,
    6653. 

  6653. 	{ 9658,-3314,-823,-5163,12695,2768,-1342,1843,6044 } },
    6654. 

  6654.     { "KODAK P850", 0, 0xf7c,
    6655. 

  6655. 	{ 10511,-3836,-1102,-6946,14587,2558,-1481,1792,6246 } },
    6656. 

  6656.     { "KODAK P880", 0, 0xfff,
    6657. 

  6657. 	{ 12805,-4662,-1376,-7480,15267,2360,-1626,2194,7904 } },
    6658. 

  6658.     { "KODAK EasyShare Z980", 0, 0,
    6659. 

  6659. 	{ 11313,-3559,-1101,-3893,11891,2257,-1214,2398,4908 } },
    6660. 

  6660.     { "KODAK EasyShare Z981", 0, 0,
    6661. 

  6661. 	{ 12729,-4717,-1188,-1367,9187,2582,274,860,4411 } },
    6662. 

  6662.     { "KODAK EasyShare Z990", 0, 0xfed,
    6663. 

  6663. 	{ 11749,-4048,-1309,-1867,10572,1489,-138,1449,4522 } },
    6664. 

  6664.     { "KODAK EASYSHARE Z1015", 0, 0xef1,
    6665. 

  6665. 	{ 11265,-4286,-992,-4694,12343,2647,-1090,1523,5447 } },
    6666. 

  6666.     { "Leaf CMost", 0, 0,
    6667. 

  6667. 	{ 3952,2189,449,-6701,14585,2275,-4536,7349,6536 } },
    6668. 

  6668.     { "Leaf Valeo 6", 0, 0,
    6669. 

  6669. 	{ 3952,2189,449,-6701,14585,2275,-4536,7349,6536 } },
    6670. 

  6670.     { "Leaf Aptus 54S", 0, 0,
    6671. 

  6671. 	{ 8236,1746,-1314,-8251,15953,2428,-3673,5786,5771 } },
    6672. 

  6672.     { "Leaf Aptus 65", 0, 0,
    6673. 

  6673. 	{ 7914,1414,-1190,-8777,16582,2280,-2811,4605,5562 } },
    6674. 

  6674.     { "Leaf Aptus 75", 0, 0,
    6675. 

  6675. 	{ 7914,1414,-1190,-8777,16582,2280,-2811,4605,5562 } },
    6676. 

  6676.     { "Leaf", 0, 0,
    6677. 

  6677. 	{ 8236,1746,-1314,-8251,15953,2428,-3673,5786,5771 } },
    6678. 

  6678.     { "Mamiya ZD", 0, 0,
    6679. 

  6679. 	{ 7645,2579,-1363,-8689,16717,2015,-3712,5941,5961 } },
    6680. 

  6680.     { "Micron 2010", 110, 0,		/* DJC */
    6681. 

  6681. 	{ 16695,-3761,-2151,155,9682,163,3433,951,4904 } },
    6682. 

  6682.     { "Minolta DiMAGE 5", 0, 0xf7d,
    6683. 

  6683. 	{ 8983,-2942,-963,-6556,14476,2237,-2426,2887,8014 } },
    6684. 

  6684.     { "Minolta DiMAGE 7Hi", 0, 0xf7d,
    6685. 

  6685. 	{ 11368,-3894,-1242,-6521,14358,2339,-2475,3056,7285 } },
    6686. 

  6686.     { "Minolta DiMAGE 7", 0, 0xf7d,
    6687. 

  6687. 	{ 9144,-2777,-998,-6676,14556,2281,-2470,3019,7744 } },
    6688. 

  6688.     { "Minolta DiMAGE A1", 0, 0xf8b,
    6689. 

  6689. 	{ 9274,-2547,-1167,-8220,16323,1943,-2273,2720,8340 } },
    6690. 

  6690.     { "MINOLTA DiMAGE A200", 0, 0,
    6691. 

  6691. 	{ 8560,-2487,-986,-8112,15535,2771,-1209,1324,7743 } },
    6692. 

  6692.     { "Minolta DiMAGE A2", 0, 0xf8f,
    6693. 

  6693. 	{ 9097,-2726,-1053,-8073,15506,2762,-966,981,7763 } },
    6694. 

  6694.     { "Minolta DiMAGE Z2", 0, 0,	/* DJC */
    6695. 

  6695. 	{ 11280,-3564,-1370,-4655,12374,2282,-1423,2168,5396 } },
    6696. 

  6696.     { "MINOLTA DYNAX 5", 0, 0xffb,
    6697. 

  6697. 	{ 10284,-3283,-1086,-7957,15762,2316,-829,882,6644 } },
    6698. 

  6698.     { "MINOLTA DYNAX 7", 0, 0xffb,
    6699. 

  6699. 	{ 10239,-3104,-1099,-8037,15727,2451,-927,925,6871 } },
    6700. 

  6700.     { "MOTOROLA PIXL", 0, 0,		/* DJC */
    6701. 

  6701. 	{ 8898,-989,-1033,-3292,11619,1674,-661,3178,5216 } },
    6702. 

  6702.     { "NIKON D100", 0, 0,
    6703. 

  6703. 	{ 5902,-933,-782,-8983,16719,2354,-1402,1455,6464 } },
    6704. 

  6704.     { "NIKON D1H", 0, 0,
    6705. 

  6705. 	{ 7577,-2166,-926,-7454,15592,1934,-2377,2808,8606 } },
    6706. 

  6706.     { "NIKON D1X", 0, 0,
    6707. 

  6707. 	{ 7702,-2245,-975,-9114,17242,1875,-2679,3055,8521 } },
    6708. 

  6708.     { "NIKON D1", 0, 0, /* multiplied by 2.218750, 1.0, 1.148438 */
    6709. 

  6709. 	{ 16772,-4726,-2141,-7611,15713,1972,-2846,3494,9521 } },
    6710. 

  6710.     { "NIKON D200", 0, 0xfbc,
    6711. 

  6711. 	{ 8367,-2248,-763,-8758,16447,2422,-1527,1550,8053 } },
    6712. 

  6712.     { "NIKON D2H", 0, 0,
    6713. 

  6713. 	{ 5710,-901,-615,-8594,16617,2024,-2975,4120,6830 } },
    6714. 

  6714.     { "NIKON D2X", 0, 0,
    6715. 

  6715. 	{ 10231,-2769,-1255,-8301,15900,2552,-797,680,7148 } },
    6716. 

  6716.     { "NIKON D3000", 0, 0,
    6717. 

  6717. 	{ 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
    6718. 

  6718.     { "NIKON D3100", 0, 0,
    6719. 

  6719. 	{ 7911,-2167,-813,-5327,13150,2408,-1288,2483,7968 } },
    6720. 

  6720.     { "NIKON D3200", 0, 0xfb9,
    6721. 

  6721. 	{ 7013,-1408,-635,-5268,12902,2640,-1470,2801,7379 } },
    6722. 

  6722.     { "NIKON D300", 0, 0,
    6723. 

  6723. 	{ 9030,-1992,-715,-8465,16302,2255,-2689,3217,8069 } },
    6724. 

  6724.     { "NIKON D3X", 0, 0,
    6725. 

  6725. 	{ 7171,-1986,-648,-8085,15555,2718,-2170,2512,7457 } },
    6726. 

  6726.     { "NIKON D3S", 0, 0,
    6727. 

  6727. 	{ 8828,-2406,-694,-4874,12603,2541,-660,1509,7587 } },
    6728. 

  6728.     { "NIKON D3", 0, 0,
    6729. 

  6729. 	{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
    6730. 

  6730.     { "NIKON D40X", 0, 0,
    6731. 

  6731. 	{ 8819,-2543,-911,-9025,16928,2151,-1329,1213,8449 } },
    6732. 

  6732.     { "NIKON D40", 0, 0,
    6733. 

  6733. 	{ 6992,-1668,-806,-8138,15748,2543,-874,850,7897 } },
    6734. 

  6734.     { "NIKON D4", 0, 0,
    6735. 

  6735. 	{ 8598,-2848,-857,-5618,13606,2195,-1002,1773,7137 } },
    6736. 

  6736.     { "NIKON D5000", 0, 0xf00,
    6737. 

  6737. 	{ 7309,-1403,-519,-8474,16008,2622,-2433,2826,8064 } },
    6738. 

  6738.     { "NIKON D5100", 0, 0x3de6,
    6739. 

  6739. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6740. 

  6740.     { "NIKON D50", 0, 0,
    6741. 

  6741. 	{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
    6742. 

  6742.     { "NIKON D600", 0, 0x3e07,
    6743. 

  6743. 	{ 8178,-2245,-609,-4857,12394,2776,-1207,2086,7298 } },
    6744. 

  6744.     { "NIKON D60", 0, 0,
    6745. 

  6745. 	{ 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
    6746. 

  6746.     { "NIKON D7000", 0, 0,
    6747. 

  6747. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6748. 

  6748.     { "NIKON D700", 0, 0,
    6749. 

  6749. 	{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
    6750. 

  6750.     { "NIKON D70", 0, 0,
    6751. 

  6751. 	{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
    6752. 

  6752.     { "NIKON D800", 0, 0,
    6753. 

  6753. 	{ 7866,-2108,-555,-4869,12483,2681,-1176,2069,7501 } },
    6754. 

  6754.     { "NIKON D80", 0, 0,
    6755. 

  6755. 	{ 8629,-2410,-883,-9055,16940,2171,-1490,1363,8520 } },
    6756. 

  6756.     { "NIKON D90", 0, 0xf00,
    6757. 

  6757. 	{ 7309,-1403,-519,-8474,16008,2622,-2434,2826,8064 } },
    6758. 

  6758.     { "NIKON E950", 0, 0x3dd,		/* DJC */
    6759. 

  6759. 	{ -3746,10611,1665,9621,-1734,2114,-2389,7082,3064,3406,6116,-244 } },
    6760. 

  6760.     { "NIKON E995", 0, 0,	/* copied from E5000 */
    6761. 

  6761. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6762. 

  6762.     { "NIKON E2100", 0, 0,	/* copied from Z2, new white balance */
    6763. 

  6763. 	{ 13142,-4152,-1596,-4655,12374,2282,-1769,2696,6711} },
    6764. 

  6764.     { "NIKON E2500", 0, 0,
    6765. 

  6765. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6766. 

  6766.     { "NIKON E3200", 0, 0,		/* DJC */
    6767. 

  6767. 	{ 9846,-2085,-1019,-3278,11109,2170,-774,2134,5745 } },
    6768. 

  6768.     { "NIKON E4300", 0, 0,	/* copied from Minolta DiMAGE Z2 */
    6769. 

  6769. 	{ 11280,-3564,-1370,-4655,12374,2282,-1423,2168,5396 } },
    6770. 

  6770.     { "NIKON E4500", 0, 0,
    6771. 

  6771. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6772. 

  6772.     { "NIKON E5000", 0, 0,
    6773. 

  6773. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6774. 

  6774.     { "NIKON E5400", 0, 0,
    6775. 

  6775. 	{ 9349,-2987,-1001,-7919,15766,2266,-2098,2680,6839 } },
    6776. 

  6776.     { "NIKON E5700", 0, 0,
    6777. 

  6777. 	{ -5368,11478,2368,5537,-113,3148,-4969,10021,5782,778,9028,211 } },
    6778. 

  6778.     { "NIKON E8400", 0, 0,
    6779. 

  6779. 	{ 7842,-2320,-992,-8154,15718,2599,-1098,1342,7560 } },
    6780. 

  6780.     { "NIKON E8700", 0, 0,
    6781. 

  6781. 	{ 8489,-2583,-1036,-8051,15583,2643,-1307,1407,7354 } },
    6782. 

  6782.     { "NIKON E8800", 0, 0,
    6783. 

  6783. 	{ 7971,-2314,-913,-8451,15762,2894,-1442,1520,7610 } },
    6784. 

  6784.     { "NIKON COOLPIX P6000", 0, 0,
    6785. 

  6785. 	{ 9698,-3367,-914,-4706,12584,2368,-837,968,5801 } },
    6786. 

  6786.     { "NIKON COOLPIX P7000", 0, 0,
    6787. 

  6787. 	{ 11432,-3679,-1111,-3169,11239,2202,-791,1380,4455 } },
    6788. 

  6788.     { "NIKON COOLPIX P7100", 0, 0,
    6789. 

  6789. 	{ 11053,-4269,-1024,-1976,10182,2088,-526,1263,4469 } },
    6790. 

  6790.     { "NIKON COOLPIX P7700", 200, 0,
    6791. 

  6791. 	{ 10321,-3920,-931,-2750,11146,1824,-442,1545,5539 } },
    6792. 

  6792.     { "NIKON 1 V2", 0, 0,
    6793. 

  6793. 	{ 6588,-1305,-693,-3277,10987,2634,-355,2016,5106 } },
    6794. 

  6794.     { "NIKON 1 ", 0, 0,
    6795. 

  6795. 	{ 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
    6796. 

  6796.     { "OLYMPUS C5050", 0, 0,
    6797. 

  6797. 	{ 10508,-3124,-1273,-6079,14294,1901,-1653,2306,6237 } },
    6798. 

  6798.     { "OLYMPUS C5060", 0, 0,
    6799. 

  6799. 	{ 10445,-3362,-1307,-7662,15690,2058,-1135,1176,7602 } },
    6800. 

  6800.     { "OLYMPUS C7070", 0, 0,
    6801. 

  6801. 	{ 10252,-3531,-1095,-7114,14850,2436,-1451,1723,6365 } },
    6802. 

  6802.     { "OLYMPUS C70", 0, 0,
    6803. 

  6803. 	{ 10793,-3791,-1146,-7498,15177,2488,-1390,1577,7321 } },
    6804. 

  6804.     { "OLYMPUS C80", 0, 0,
    6805. 

  6805. 	{ 8606,-2509,-1014,-8238,15714,2703,-942,979,7760 } },
    6806. 

  6806.     { "OLYMPUS E-10", 0, 0xffc,
    6807. 

  6807. 	{ 12745,-4500,-1416,-6062,14542,1580,-1934,2256,6603 } },
    6808. 

  6808.     { "OLYMPUS E-1", 0, 0,
    6809. 

  6809. 	{ 11846,-4767,-945,-7027,15878,1089,-2699,4122,8311 } },
    6810. 

  6810.     { "OLYMPUS E-20", 0, 0xffc,
    6811. 

  6811. 	{ 13173,-4732,-1499,-5807,14036,1895,-2045,2452,7142 } },
    6812. 

  6812.     { "OLYMPUS E-300", 0, 0,
    6813. 

  6813. 	{ 7828,-1761,-348,-5788,14071,1830,-2853,4518,6557 } },
    6814. 

  6814.     { "OLYMPUS E-330", 0, 0,
    6815. 

  6815. 	{ 8961,-2473,-1084,-7979,15990,2067,-2319,3035,8249 } },
    6816. 

  6816.     { "OLYMPUS E-30", 0, 0xfbc,
    6817. 

  6817. 	{ 8144,-1861,-1111,-7763,15894,1929,-1865,2542,7607 } },
    6818. 

  6818.     { "OLYMPUS E-3", 0, 0xf99,
    6819. 

  6819. 	{ 9487,-2875,-1115,-7533,15606,2010,-1618,2100,7389 } },
    6820. 

  6820.     { "OLYMPUS E-400", 0, 0,
    6821. 

  6821. 	{ 6169,-1483,-21,-7107,14761,2536,-2904,3580,8568 } },
    6822. 

  6822.     { "OLYMPUS E-410", 0, 0xf6a,
    6823. 

  6823. 	{ 8856,-2582,-1026,-7761,15766,2082,-2009,2575,7469 } },
    6824. 

  6824.     { "OLYMPUS E-420", 0, 0xfd7,
    6825. 

  6825. 	{ 8746,-2425,-1095,-7594,15612,2073,-1780,2309,7416 } },
    6826. 

  6826.     { "OLYMPUS E-450", 0, 0xfd2,
    6827. 

  6827. 	{ 8745,-2425,-1095,-7594,15613,2073,-1780,2309,7416 } },
    6828. 

  6828.     { "OLYMPUS E-500", 0, 0,
    6829. 

  6829. 	{ 8136,-1968,-299,-5481,13742,1871,-2556,4205,6630 } },
    6830. 

  6830.     { "OLYMPUS E-510", 0, 0xf6a,
    6831. 

  6831. 	{ 8785,-2529,-1033,-7639,15624,2112,-1783,2300,7817 } },
    6832. 

  6832.     { "OLYMPUS E-520", 0, 0xfd2,
    6833. 

  6833. 	{ 8344,-2322,-1020,-7596,15635,2048,-1748,2269,7287 } },
    6834. 

  6834.     { "OLYMPUS E-5", 0, 0xeec,
    6835. 

  6835. 	{ 11200,-3783,-1325,-4576,12593,2206,-695,1742,7504 } },
    6836. 

  6836.     { "OLYMPUS E-600", 0, 0xfaf,
    6837. 

  6837. 	{ 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
    6838. 

  6838.     { "OLYMPUS E-620", 0, 0xfaf,
    6839. 

  6839. 	{ 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
    6840. 

  6840.     { "OLYMPUS E-P1", 0, 0xffd,
    6841. 

  6841. 	{ 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
    6842. 

  6842.     { "OLYMPUS E-P2", 0, 0xffd,
    6843. 

  6843. 	{ 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
    6844. 

  6844.     { "OLYMPUS E-P3", 0, 0,
    6845. 

  6845. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6846. 

  6846.     { "OLYMPUS E-PL1s", 0, 0,
    6847. 

  6847. 	{ 11409,-3872,-1393,-4572,12757,2003,-709,1810,7415 } },
    6848. 

  6848.     { "OLYMPUS E-PL1", 0, 0,
    6849. 

  6849. 	{ 11408,-4289,-1215,-4286,12385,2118,-387,1467,7787 } },
    6850. 

  6850.     { "OLYMPUS E-PL2", 0, 0,
    6851. 

  6851. 	{ 15030,-5552,-1806,-3987,12387,1767,-592,1670,7023 } },
    6852. 

  6852.     { "OLYMPUS E-PL3", 0, 0,
    6853. 

  6853. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6854. 

  6854.     { "OLYMPUS E-PL5", 0, 0xfcb,
    6855. 

  6855. 	{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
    6856. 

  6856.     { "OLYMPUS E-PM1", 0, 0,
    6857. 

  6857. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6858. 

  6858.     { "OLYMPUS E-PM2", 0, 0,
    6859. 

  6859. 	{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
    6860. 

  6860.     { "OLYMPUS E-M5", 0, 0xfe1,
    6861. 

  6861. 	{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
    6862. 

  6862.     { "OLYMPUS SP350", 0, 0,
    6863. 

  6863. 	{ 12078,-4836,-1069,-6671,14306,2578,-786,939,7418 } },
    6864. 

  6864.     { "OLYMPUS SP3", 0, 0,
    6865. 

  6865. 	{ 11766,-4445,-1067,-6901,14421,2707,-1029,1217,7572 } },
    6866. 

  6866.     { "OLYMPUS SP500UZ", 0, 0xfff,
    6867. 

  6867. 	{ 9493,-3415,-666,-5211,12334,3260,-1548,2262,6482 } },
    6868. 

  6868.     { "OLYMPUS SP510UZ", 0, 0xffe,
    6869. 

  6869. 	{ 10593,-3607,-1010,-5881,13127,3084,-1200,1805,6721 } },
    6870. 

  6870.     { "OLYMPUS SP550UZ", 0, 0xffe,
    6871. 

  6871. 	{ 11597,-4006,-1049,-5432,12799,2957,-1029,1750,6516 } },
    6872. 

  6872.     { "OLYMPUS SP560UZ", 0, 0xff9,
    6873. 

  6873. 	{ 10915,-3677,-982,-5587,12986,2911,-1168,1968,6223 } },
    6874. 

  6874.     { "OLYMPUS SP570UZ", 0, 0,
    6875. 

  6875. 	{ 11522,-4044,-1146,-4736,12172,2904,-988,1829,6039 } },
    6876. 

  6876.     { "OLYMPUS XZ-1", 0, 0,
    6877. 

  6877. 	{ 10901,-4095,-1074,-1141,9208,2293,-62,1417,5158 } },
    6878. 

  6878.     { "OLYMPUS XZ-2", 0, 0,
    6879. 

  6879. 	{ 9777,-3483,-925,-2886,11297,1800,-602,1663,5134 } },
    6880. 

  6880.     { "PENTAX *ist DL2", 0, 0,
    6881. 

  6881. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    6882. 

  6882.     { "PENTAX *ist DL", 0, 0,
    6883. 

  6883. 	{ 10829,-2838,-1115,-8339,15817,2696,-837,680,11939 } },
    6884. 

  6884.     { "PENTAX *ist DS2", 0, 0,
    6885. 

  6885. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    6886. 

  6886.     { "PENTAX *ist DS", 0, 0,
    6887. 

  6887. 	{ 10371,-2333,-1206,-8688,16231,2602,-1230,1116,11282 } },
    6888. 

  6888.     { "PENTAX *ist D", 0, 0,
    6889. 

  6889. 	{ 9651,-2059,-1189,-8881,16512,2487,-1460,1345,10687 } },
    6890. 

  6890.     { "PENTAX K10D", 0, 0,
    6891. 

  6891. 	{ 9566,-2863,-803,-7170,15172,2112,-818,803,9705 } },
    6892. 

  6892.     { "PENTAX K1", 0, 0,
    6893. 

  6893. 	{ 11095,-3157,-1324,-8377,15834,2720,-1108,947,11688 } },
    6894. 

  6894.     { "PENTAX K20D", 0, 0,
    6895. 

  6895. 	{ 9427,-2714,-868,-7493,16092,1373,-2199,3264,7180 } },
    6896. 

  6896.     { "PENTAX K200D", 0, 0,
    6897. 

  6897. 	{ 9186,-2678,-907,-8693,16517,2260,-1129,1094,8524 } },
    6898. 

  6898.     { "PENTAX K2000", 0, 0,
    6899. 

  6899. 	{ 11057,-3604,-1155,-5152,13046,2329,-282,375,8104 } },
    6900. 

  6900.     { "PENTAX K-m", 0, 0,
    6901. 

  6901. 	{ 11057,-3604,-1155,-5152,13046,2329,-282,375,8104 } },
    6902. 

  6902.     { "PENTAX K-x", 0, 0,
    6903. 

  6903. 	{ 8843,-2837,-625,-5025,12644,2668,-411,1234,7410 } },
    6904. 

  6904.     { "PENTAX K-r", 0, 0,
    6905. 

  6905. 	{ 9895,-3077,-850,-5304,13035,2521,-883,1768,6936 } },
    6906. 

  6906.     { "PENTAX K-30", 0, 0,
    6907. 

  6907. 	{ 8833,-2670,-1183,-3995,12301,1881,-979,1717,6527 } },
    6908. 

  6908.     { "PENTAX K-5 II s", 0, 0,
    6909. 

  6909. 	{ 8366,-2528,-1120,-3995,12301,1881,-998,1749,6649 } },
    6910. 

  6910.     { "PENTAX K-5 II", 0, 0,
    6911. 

  6911. 	{ 8773,-2651,-1175,-3995,12301,1881,-973,1706,6486 } },
    6912. 

  6912.     { "PENTAX K-5", 0, 0,
    6913. 

  6913. 	{ 8713,-2833,-743,-4342,11900,2772,-722,1543,6247 } },
    6914. 

  6914.     { "PENTAX K-7", 0, 0,
    6915. 

  6915. 	{ 9142,-2947,-678,-8648,16967,1663,-2224,2898,8615 } },
    6916. 

  6916.     { "PENTAX Q10", 0, 0,
    6917. 

  6917. 	{ 12995,-5593,-1107,-1879,10139,2027,-64,1233,4919 } },
    6918. 

  6918.     { "PENTAX 645D", 0, 0x3e00,
    6919. 

  6919. 	{ 10646,-3593,-1158,-3329,11699,1831,-667,2874,6287 } },
    6920. 

  6920.     { "Panasonic DMC-FZ8", 0, 0xf7f,
    6921. 

  6921. 	{ 8986,-2755,-802,-6341,13575,3077,-1476,2144,6379 } },
    6922. 

  6922.     { "Panasonic DMC-FZ18", 0, 0,
    6923. 

  6923. 	{ 9932,-3060,-935,-5809,13331,2753,-1267,2155,5575 } },
    6924. 

  6924.     { "Panasonic DMC-FZ28", 15, 0xf96,
    6925. 

  6925. 	{ 10109,-3488,-993,-5412,12812,2916,-1305,2140,5543 } },
    6926. 

  6926.     { "Panasonic DMC-FZ30", 0, 0xf94,
    6927. 

  6927. 	{ 10976,-4029,-1141,-7918,15491,2600,-1670,2071,8246 } },
    6928. 

  6928.     { "Panasonic DMC-FZ3", 143, 0,
    6929. 

  6929. 	{ 9938,-2780,-890,-4604,12393,2480,-1117,2304,4620 } },
    6930. 

  6930.     { "Panasonic DMC-FZ4", 143, 0,
    6931. 

  6931. 	{ 13639,-5535,-1371,-1698,9633,2430,316,1152,4108 } },
    6932. 

  6932.     { "Panasonic DMC-FZ50", 0, 0,
    6933. 

  6933. 	{ 7906,-2709,-594,-6231,13351,3220,-1922,2631,6537 } },
    6934. 

  6934.     { "LEICA V-LUX1", 0, 0,
    6935. 

  6935. 	{ 7906,-2709,-594,-6231,13351,3220,-1922,2631,6537 } },
    6936. 

  6936.     { "Panasonic DMC-L10", 15, 0xf96,
    6937. 

  6937. 	{ 8025,-1942,-1050,-7920,15904,2100,-2456,3005,7039 } },
    6938. 

  6938.     { "Panasonic DMC-L1", 0, 0xf7f,
    6939. 

  6939. 	{ 8054,-1885,-1025,-8349,16367,2040,-2805,3542,7629 } },
    6940. 

  6940.     { "LEICA DIGILUX 3", 0, 0xf7f,
    6941. 

  6941. 	{ 8054,-1885,-1025,-8349,16367,2040,-2805,3542,7629 } },
    6942. 

  6942.     { "Panasonic DMC-LC1", 0, 0,
    6943. 

  6943. 	{ 11340,-4069,-1275,-7555,15266,2448,-2960,3426,7685 } },
    6944. 

  6944.     { "LEICA DIGILUX 2", 0, 0,
    6945. 

  6945. 	{ 11340,-4069,-1275,-7555,15266,2448,-2960,3426,7685 } },
    6946. 

  6946.     { "Panasonic DMC-LX1", 0, 0xf7f,
    6947. 

  6947. 	{ 10704,-4187,-1230,-8314,15952,2501,-920,945,8927 } },
    6948. 

  6948.     { "LEICA D-LUX2", 0, 0xf7f,
    6949. 

  6949. 	{ 10704,-4187,-1230,-8314,15952,2501,-920,945,8927 } },
    6950. 

  6950.     { "Panasonic DMC-LX2", 0, 0,
    6951. 

  6951. 	{ 8048,-2810,-623,-6450,13519,3272,-1700,2146,7049 } },
    6952. 

  6952.     { "LEICA D-LUX3", 0, 0,
    6953. 

  6953. 	{ 8048,-2810,-623,-6450,13519,3272,-1700,2146,7049 } },
    6954. 

  6954.     { "Panasonic DMC-LX3", 15, 0,
    6955. 

  6955. 	{ 8128,-2668,-655,-6134,13307,3161,-1782,2568,6083 } },
    6956. 

  6956.     { "LEICA D-LUX 4", 15, 0,
    6957. 

  6957. 	{ 8128,-2668,-655,-6134,13307,3161,-1782,2568,6083 } },
    6958. 

  6958.     { "Panasonic DMC-LX5", 143, 0,
    6959. 

  6959. 	{ 10909,-4295,-948,-1333,9306,2399,22,1738,4582 } },
    6960. 

  6960.     { "Panasonic DMC-LX7", 143, 0,
    6961. 

  6961. 	{ 10148,-3743,-991,-2837,11366,1659,-701,1893,4899 } },
    6962. 

  6962.     { "LEICA D-LUX 5", 143, 0,
    6963. 

  6963. 	{ 10909,-4295,-948,-1333,9306,2399,22,1738,4582 } },
    6964. 

  6964.     { "Panasonic DMC-LX7", 143, 0,
    6965. 

  6965. 	{ 10148,-3743,-991,-2837,11366,1659,-701,1893,4899 } },
    6966. 

  6966.     { "LEICA D-LUX 6", 143, 0,
    6967. 

  6967. 	{ 10148,-3743,-991,-2837,11366,1659,-701,1893,4899 } },
    6968. 

  6968.     { "Panasonic DMC-FZ100", 143, 0xfff,
    6969. 

  6969. 	{ 16197,-6146,-1761,-2393,10765,1869,366,2238,5248 } },
    6970. 

  6970.     { "LEICA V-LUX 2", 143, 0xfff,
    6971. 

  6971. 	{ 16197,-6146,-1761,-2393,10765,1869,366,2238,5248 } },
    6972. 

  6972.     { "Panasonic DMC-FZ150", 143, 0xfff,
    6973. 

  6973. 	{ 11904,-4541,-1189,-2355,10899,1662,-296,1586,4289 } },
    6974. 

  6974.     { "LEICA V-LUX 3", 143, 0xfff,
    6975. 

  6975. 	{ 11904,-4541,-1189,-2355,10899,1662,-296,1586,4289 } },
    6976. 

  6976.     { "Panasonic DMC-FZ200", 143, 0xfff,
    6977. 

  6977. 	{ 8112,-2563,-740,-3730,11784,2197,-941,2075,4933 } },
    6978. 

  6978.     { "LEICA V-LUX 4", 143, 0xfff,
    6979. 

  6979. 	{ 8112,-2563,-740,-3730,11784,2197,-941,2075,4933 } },
    6980. 

  6980.     { "Panasonic DMC-FX150", 15, 0xfff,
    6981. 

  6981. 	{ 9082,-2907,-925,-6119,13377,3058,-1797,2641,5609 } },
    6982. 

  6982.     { "Panasonic DMC-G10", 0, 0,
    6983. 

  6983. 	{ 10113,-3400,-1114,-4765,12683,2317,-377,1437,6710 } },
    6984. 

  6984.     { "Panasonic DMC-G1", 15, 0xf94,
    6985. 

  6985. 	{ 8199,-2065,-1056,-8124,16156,2033,-2458,3022,7220 } },
    6986. 

  6986.     { "Panasonic DMC-G2", 15, 0xf3c,
    6987. 

  6987. 	{ 10113,-3400,-1114,-4765,12683,2317,-377,1437,6710 } },
    6988. 

  6988.     { "Panasonic DMC-G3", 143, 0xfff,
    6989. 

  6989. 	{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
    6990. 

  6990.     { "Panasonic DMC-G5", 143, 0xfff,
    6991. 

  6991. 	{ 7798,-2562,-740,-3879,11584,2613,-1055,2248,5434 } },
    6992. 

  6992.     { "Panasonic DMC-GF1", 15, 0xf92,
    6993. 

  6993. 	{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
    6994. 

  6994.     { "Panasonic DMC-GF2", 143, 0xfff,
    6995. 

  6995. 	{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
    6996. 

  6996.     { "Panasonic DMC-GF3", 143, 0xfff,
    6997. 

  6997. 	{ 9051,-2468,-1204,-5212,13276,2121,-1197,2510,6890 } },
    6998. 

  6998.     { "Panasonic DMC-GF5", 143, 0xfff,
    6999. 

  6999. 	{ 8228,-2945,-660,-3938,11792,2430,-1094,2278,5793 } },
    7000. 

  7000.     { "Panasonic DMC-GH1", 15, 0xf92,
    7001. 

  7001. 	{ 6299,-1466,-532,-6535,13852,2969,-2331,3112,5984 } },
    7002. 

  7002.     { "Panasonic DMC-GH2", 15, 0xf95,
    7003. 

  7003. 	{ 7780,-2410,-806,-3913,11724,2484,-1018,2390,5298 } },
    7004. 

  7004.     { "Panasonic DMC-GH3", 144, 0,
    7005. 

  7005. 	{ 6559,-1752,-491,-3672,11407,2586,-962,1875,5130 } },
    7006. 

  7006.     { "Panasonic DMC-GX1", 143, 0,
    7007. 

  7007. 	{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
    7008. 

  7008.     { "Phase One H 20", 0, 0,		/* DJC */
    7009. 

  7009. 	{ 1313,1855,-109,-6715,15908,808,-327,1840,6020 } },
    7010. 

  7010.     { "Phase One H 25", 0, 0,
    7011. 

  7011. 	{ 2905,732,-237,-8134,16626,1476,-3038,4253,7517 } },
    7012. 

  7012.     { "Phase One P 2", 0, 0,
    7013. 

  7013. 	{ 2905,732,-237,-8134,16626,1476,-3038,4253,7517 } },
    7014. 

  7014.     { "Phase One P 30", 0, 0,
    7015. 

  7015. 	{ 4516,-245,-37,-7020,14976,2173,-3206,4671,7087 } },
    7016. 

  7016.     { "Phase One P 45", 0, 0,
    7017. 

  7017. 	{ 5053,-24,-117,-5684,14076,1702,-2619,4492,5849 } },
    7018. 

  7018.     { "Phase One P40", 0, 0,
    7019. 

  7019. 	{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
    7020. 

  7020.     { "Phase One P65", 0, 0,
    7021. 

  7021. 	{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
    7022. 

  7022.     { "RED ONE", 704, 0xffff,		/* DJC */
    7023. 

  7023. 	{ 21014,-7891,-2613,-3056,12201,856,-2203,5125,8042 } },
    7024. 

  7024.     { "SAMSUNG EX1", 0, 0x3e00,
    7025. 

  7025. 	{ 8898,-2498,-994,-3144,11328,2066,-760,1381,4576 } },
    7026. 

  7026.     { "SAMSUNG EX2F", 0, 0x7ff,
    7027. 

  7027. 	{ 10648,-3897,-1055,-2022,10573,1668,-492,1611,4742 } },
    7028. 

  7028.     { "SAMSUNG NX2", 0, 0xfff,	/* NX20, NX200, NX210 */
    7029. 

  7029. 	{ 6933,-2268,-753,-4921,13387,1647,-803,1641,6096 } },
    7030. 

  7030.     { "SAMSUNG NX1000", 0, 0,
    7031. 

  7031. 	{ 6933,-2268,-753,-4921,13387,1647,-803,1641,6096 } },
    7032. 

  7032.     { "SAMSUNG NX", 0, 0,	/* NX5, NX10, NX11, NX100 */
    7033. 

  7033. 	{ 10332,-3234,-1168,-6111,14639,1520,-1352,2647,8331 } },
    7034. 

  7034.     { "SAMSUNG WB2000", 0, 0xfff,
    7035. 

  7035. 	{ 12093,-3557,-1155,-1000,9534,1733,-22,1787,4576 } },
    7036. 

  7036.     { "SAMSUNG GX-1", 0, 0,
    7037. 

  7037. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    7038. 

  7038.     { "SAMSUNG S85", 0, 0xffff,		/* DJC */
    7039. 

  7039. 	{ 11885,-3968,-1473,-4214,12299,1916,-835,1655,5549 } },
    7040. 

  7040.     { "Sinar", 0, 0,			/* DJC */
    7041. 

  7041. 	{ 16442,-2956,-2422,-2877,12128,750,-1136,6066,4559 } },
    7042. 

  7042.     { "SONY DSC-F828", 0, 0,
    7043. 

  7043. 	{ 7924,-1910,-777,-8226,15459,2998,-1517,2199,6818,-7242,11401,3481 } },
    7044. 

  7044.     { "SONY DSC-R1", 512, 0,
    7045. 

  7045. 	{ 8512,-2641,-694,-8042,15670,2526,-1821,2117,7414 } },
    7046. 

  7046.     { "SONY DSC-V3", 0, 0,
    7047. 

  7047. 	{ 7511,-2571,-692,-7894,15088,3060,-948,1111,8128 } },
    7048. 

  7048.     { "SONY DSC-RX100", 200, 0,
    7049. 

  7049. 	{ 8651,-2754,-1057,-3464,12207,1373,-568,1398,4434 } },
    7050. 

  7050.     { "SONY DSC-RX1", 128, 0,
    7051. 

  7051. 	{ 6344,-1612,-462,-4863,12477,2681,-865,1786,6899 } },
    7052. 

  7052.     { "SONY DSLR-A100", 0, 0xfeb,
    7053. 

  7053. 	{ 9437,-2811,-774,-8405,16215,2290,-710,596,7181 } },
    7054. 

  7054.     { "SONY DSLR-A290", 0, 0,
    7055. 

  7055. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7056. 

  7056.     { "SONY DSLR-A2", 0, 0,
    7057. 

  7057. 	{ 9847,-3091,-928,-8485,16345,2225,-715,595,7103 } },
    7058. 

  7058.     { "SONY DSLR-A300", 0, 0,
    7059. 

  7059. 	{ 9847,-3091,-928,-8485,16345,2225,-715,595,7103 } },
    7060. 

  7060.     { "SONY DSLR-A330", 0, 0,
    7061. 

  7061. 	{ 9847,-3091,-929,-8485,16346,2225,-714,595,7103 } },
    7062. 

  7062.     { "SONY DSLR-A350", 0, 0xffc,
    7063. 

  7063. 	{ 6038,-1484,-578,-9146,16746,2513,-875,746,7217 } },
    7064. 

  7064.     { "SONY DSLR-A380", 0, 0,
    7065. 

  7065. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7066. 

  7066.     { "SONY DSLR-A390", 0, 0,
    7067. 

  7067. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7068. 

  7068.     { "SONY DSLR-A450", 128, 0xfeb,
    7069. 

  7069. 	{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
    7070. 

  7070.     { "SONY DSLR-A580", 128, 0xfeb,
    7071. 

  7071. 	{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
    7072. 

  7072.     { "SONY DSLR-A5", 128, 0xfeb,
    7073. 

  7073. 	{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
    7074. 

  7074.     { "SONY DSLR-A700", 126, 0,
    7075. 

  7075. 	{ 5775,-805,-359,-8574,16295,2391,-1943,2341,7249 } },
    7076. 

  7076.     { "SONY DSLR-A850", 128, 0,
    7077. 

  7077. 	{ 5413,-1162,-365,-5665,13098,2866,-608,1179,8440 } },
    7078. 

  7078.     { "SONY DSLR-A900", 128, 0,
    7079. 

  7079. 	{ 5209,-1072,-397,-8845,16120,2919,-1618,1803,8654 } },
    7080. 

  7080.     { "SONY NEX-3", 128, 0,		/* Adobe */
    7081. 

  7081. 	{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
    7082. 

  7082.     { "SONY NEX-5N", 128, 0,
    7083. 

  7083. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7084. 

  7084.     { "SONY NEX-5R", 128, 0,		
    7085. 

  7085. 	{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
    7086. 

  7086.     { "SONY NEX-5", 128, 0,		/* Adobe */
    7087. 

  7087. 	{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
    7088. 

  7088.     { "SONY NEX-6", 128, 0,
    7089. 

  7089. 	{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
    7090. 

  7090.     { "SONY NEX-7", 128, 0,
    7091. 

  7091. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7092. 

  7092.     { "SONY NEX", 128, 0,	/* NEX-C3, NEX-F3 */
    7093. 

  7093. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7094. 

  7094.     { "SONY SLT-A33", 128, 0,
    7095. 

  7095. 	{ 6069,-1221,-366,-5221,12779,2734,-1024,2066,6834 } },
    7096. 

  7096.     { "SONY SLT-A35", 128, 0,
    7097. 

  7097. 	{ 5986,-1618,-415,-4557,11820,3120,-681,1404,6971 } },
    7098. 

  7098.     { "SONY SLT-A37", 128, 0,
    7099. 

  7099. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7100. 

  7100.     { "SONY SLT-A55", 128, 0,
    7101. 

  7101. 	{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
    7102. 

  7102.     { "SONY SLT-A57", 128, 0,
    7103. 

  7103. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7104. 

  7104.     { "SONY SLT-A65", 128, 0,
    7105. 

  7105. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7106. 

  7106.     { "SONY SLT-A77", 128, 0,
    7107. 

  7107. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7108. 

  7108.     { "SONY SLT-A99", 128, 0,
    7109. 

  7109. 	{ 6344,-1612,-462,-4863,12477,2681,-865,1786,6899 } },
    7110. 

  7110.   };
    7111. 

  7111.   double cam_xyz[4][3];
    7112. 

  7112.   char name[130];
    7113. 

  7113.   int i, j;
    7114. 

  7114. 

  7115.   sprintf (name, "%s %s", t_make, t_model);
    7116. 

  7116.   for (i=0; i < sizeof table / sizeof *table; i++)
    7117. 

  7117.     if (!strncmp (name, table[i].prefix, strlen(table[i].prefix))) {
    7118. 

  7118.       if (table[i].t_black)   black   = (ushort) table[i].t_black;
    7119. 

  7119.       if (table[i].t_maximum) maximum = (ushort) table[i].t_maximum;
    7120. 

  7120.       if (table[i].trans[0]) {
    7121. 

  7121. 	for (j=0; j < 12; j++)
    7122. 

  7122. #ifdef LIBRAW_LIBRARY_BUILD
    7123. 

  7123.           imgdata.color.cam_xyz[0][j] = 
    7124. 

  7124. #endif
    7125. 

  7125. 	  cam_xyz[0][j] = table[i].trans[j] / 10000.0;
    7126. 

  7126. 	cam_xyz_coeff (cam_xyz);
    7127. 

  7127.       }
    7128. 

  7128.       break;
    7129. 

  7129.     }
    7130. 

  7130. }
    7131. 

  7131. 

  7132. void CLASS simple_coeff (int index)
    7133. 

  7133. {
    7134. 

  7134.   static const float table[][12] = {
    7135. 

  7135.   /* index 0 -- all Foveon cameras */
    7136. 

  7136.   { 1.4032,-0.2231,-0.1016,-0.5263,1.4816,0.017,-0.0112,0.0183,0.9113 },
    7137. 

  7137.   /* index 1 -- Kodak DC20 and DC25 */
    7138. 

  7138.   { 2.25,0.75,-1.75,-0.25,-0.25,0.75,0.75,-0.25,-0.25,-1.75,0.75,2.25 },
    7139. 

  7139.   /* index 2 -- Logitech Fotoman Pixtura */
    7140. 

  7140.   { 1.893,-0.418,-0.476,-0.495,1.773,-0.278,-1.017,-0.655,2.672 },
    7141. 

  7141.   /* index 3 -- Nikon E880, E900, and E990 */
    7142. 

  7142.   { -1.936280,  1.800443, -1.448486,  2.584324,
    7143. 

  7143.      1.405365, -0.524955, -0.289090,  0.408680,
    7144. 

  7144.     -1.204965,  1.082304,  2.941367, -1.818705 }
    7145. 

  7145.   };
    7146. 

  7146.   int i, c;
    7147. 

  7147. 

  7148.   for (raw_color = i=0; i < 3; i++)
    7149. 

  7149.     FORCC rgb_cam[i][c] = table[index][i*colors+c];
    7150. 

  7150. }
    7151. 

  7151. 

  7152. short CLASS guess_byte_order (int words)
    7153. 

  7153. {
    7154. 

  7154.   uchar test[4][2];
    7155. 

  7155.   int t=2, msb;
    7156. 

  7156.   double diff, sum[2] = {0,0};
    7157. 

  7157. 

  7158.   fread (test[0], 2, 2, ifp);
    7159. 

  7159.   for (words-=2; words--; ) {
    7160. 

  7160.     fread (test[t], 2, 1, ifp);
    7161. 

  7161.     for (msb=0; msb < 2; msb++) {
    7162. 

  7162.       diff = (test[t^2][msb] << 8 | test[t^2][!msb])
    7163. 

  7163. 	   - (test[t  ][msb] << 8 | test[t  ][!msb]);
    7164. 

  7164.       sum[msb] += diff*diff;
    7165. 

  7165.     }
    7166. 

  7166.     t = (t+1) & 3;
    7167. 

  7167.   }
    7168. 

  7168.   return sum[0] < sum[1] ? 0x4d4d : 0x4949;
    7169. 

  7169. }
    7170. 

  7170. 

  7171. float CLASS find_green (int bps, int bite, int off0, int off1)
    7172. 

  7172. {
    7173. 

  7173.   UINT64 bitbuf=0;
    7174. 

  7174.   int vbits, col, i, c;
    7175. 

  7175.   ushort img[2][2064];
    7176. 

  7176.   double sum[]={0,0};
    7177. 

  7177. 

  7178.   FORC(2) {
    7179. 

  7179.     fseek (ifp, c ? off1:off0, SEEK_SET);
    7180. 

  7180.     for (vbits=col=0; col < width; col++) {
    7181. 

  7181.       for (vbits -= bps; vbits < 0; vbits += bite) {
    7182. 

  7182. 	bitbuf <<= bite;
    7183. 

  7183. 	for (i=0; i < bite; i+=8)
    7184. 

  7184. 	  bitbuf |= (unsigned) (fgetc(ifp) << i);
    7185. 

  7185.       }
    7186. 

  7186.       img[c][col] = bitbuf << (64-bps-vbits) >> (64-bps);
    7187. 

  7187.     }
    7188. 

  7188.   }
    7189. 

  7189.   FORC(width-1) {
    7190. 

  7190.     sum[ c & 1] += ABS(img[0][c]-img[1][c+1]);
    7191. 

  7191.     sum[~c & 1] += ABS(img[1][c]-img[0][c+1]);
    7192. 

  7192.   }
    7193. 

  7193.   return 100 * log(sum[0]/sum[1]);
    7194. 

  7194. }
    7195. 

  7195. 

  7196. 

  7197. #ifndef LIBRAW_LIBRARY_BUILD
    7198. 

  7198. void CLASS identify2(unsigned fsize, unsigned flen, char *head);
    7199. 

  7199. #endif
    7200. 

  7200. 

  7201. /*
    7202. 

  7202.    Identify which camera created this file, and set global variables
    7203. 

  7203.    accordingly.
    7204. 

  7204.  */
    7205. 

  7205. void CLASS identify()
    7206. 

  7206. {
    7207. 

  7207.   char head[32], *cp;
    7208. 

  7208.   int hlen, flen, fsize, zero_fsize=1, i, c, is_canon;
    7209. 

  7209.   struct jhead jh;
    7210. 

  7210.   static const struct {
    7211. 

  7211.     int fsize;
    7212. 

  7212.     char t_make[12], t_model[19], withjpeg;
    7213. 

  7213.   } table[] = {
    7214. 

  7214.     {    62464, "Kodak",    "DC20"            ,0 },
    7215. 

  7215.     {   124928, "Kodak",    "DC20"            ,0 },
    7216. 

  7216.     {  1652736, "Kodak",    "DCS200"          ,0 },
    7217. 

  7217.     {  4159302, "Kodak",    "C330"            ,0 },
    7218. 

  7218.     {  4162462, "Kodak",    "C330"            ,0 },
    7219. 

  7219.     {   460800, "Kodak",    "C603v"           ,0 },
    7220. 

  7220.     {   614400, "Kodak",    "C603v"           ,0 },
    7221. 

  7221.     {  6163328, "Kodak",    "C603"            ,0 },
    7222. 

  7222.     {  6166488, "Kodak",    "C603"            ,0 },
    7223. 

  7223.     {  9116448, "Kodak",    "C603y"           ,0 },
    7224. 

  7224.     {   311696, "ST Micro", "STV680 VGA"      ,0 },  /* SPYz */
    7225. 

  7225.     {   787456, "Creative", "PC-CAM 600"      ,0 },
    7226. 

  7226.     {  1138688, "Minolta",  "RD175"           ,0 },
    7227. 

  7227.     {  3840000, "Foculus",  "531C"            ,0 },
    7228. 

  7228.     {   307200, "Generic",  "640x480"         ,0 },
    7229. 

  7229.     {   786432, "AVT",      "F-080C"          ,0 },
    7230. 

  7230.     {  1447680, "AVT",      "F-145C"          ,0 },
    7231. 

  7231.     {  1920000, "AVT",      "F-201C"          ,0 },
    7232. 

  7232.     {  5067304, "AVT",      "F-510C"          ,0 },
    7233. 

  7233.     {  5067316, "AVT",      "F-510C"          ,0 },
    7234. 

  7234.     { 10134608, "AVT",      "F-510C"          ,0 },
    7235. 

  7235.     { 10134620, "AVT",      "F-510C"          ,0 },
    7236. 

  7236.     { 16157136, "AVT",      "F-810C"          ,0 },
    7237. 

  7237.     {  1409024, "Sony",     "XCD-SX910CR"     ,0 },
    7238. 

  7238.     {  2818048, "Sony",     "XCD-SX910CR"     ,0 },
    7239. 

  7239.     {  3884928, "Micron",   "2010"            ,0 },
    7240. 

  7240.     {  6624000, "Pixelink", "A782"            ,0 },
    7241. 

  7241.     { 13248000, "Pixelink", "A782"            ,0 },
    7242. 

  7242.     {  6291456, "RoverShot","3320AF"          ,0 },
    7243. 

  7243.     {  6553440, "Canon",    "PowerShot A460"  ,0 },
    7244. 

  7244.     {  6653280, "Canon",    "PowerShot A530"  ,0 },
    7245. 

  7245.     {  6573120, "Canon",    "PowerShot A610"  ,0 },
    7246. 

  7246.     {  9219600, "Canon",    "PowerShot A620"  ,0 },
    7247. 

  7247.     {  9243240, "Canon",    "PowerShot A470"  ,0 },
    7248. 

  7248.     { 10341600, "Canon",    "PowerShot A720 IS",0 },
    7249. 

  7249.     { 10383120, "Canon",    "PowerShot A630"  ,0 },
    7250. 

  7250.     { 12945240, "Canon",    "PowerShot A640"  ,0 },
    7251. 

  7251.     { 15636240, "Canon",    "PowerShot A650"  ,0 },
    7252. 

  7252.     {  5298000, "Canon",    "PowerShot SD300" ,0 },
    7253. 

  7253.     {  7710960, "Canon",    "PowerShot S3 IS" ,0 },
    7254. 

  7254.     { 15467760, "Canon",    "PowerShot SX110 IS",0 },
    7255. 

  7255.     { 15534576, "Canon",    "PowerShot SX120 IS",0 },
    7256. 

  7256.     { 18653760, "Canon",    "PowerShot SX20 IS",0 },
    7257. 

  7257.     { 19131120, "Canon",    "PowerShot SX220 HS",0 },
    7258. 

  7258.     { 21936096, "Canon",    "PowerShot SX30 IS",0 },
    7259. 

  7259.     {  5939200, "OLYMPUS",  "C770UZ"          ,0 },
    7260. 

  7260.     {  1581060, "NIKON",    "E900"            ,1 },  /* or E900s,E910 */
    7261. 

  7261.     {  2465792, "NIKON",    "E950"            ,1 },  /* or E800,E700 */
    7262. 

  7262.     {  2940928, "NIKON",    "E2100"           ,1 },  /* or E2500 */
    7263. 

  7263.     {  4771840, "NIKON",    "E990"            ,1 },  /* or E995, Oly C3030Z */
    7264. 

  7264.     {  4775936, "NIKON",    "E3700"           ,1 },  /* or Optio 33WR */
    7265. 

  7265.     {  5869568, "NIKON",    "E4300"           ,1 },  /* or DiMAGE Z2 */
    7266. 

  7266.     {  5865472, "NIKON",    "E4500"           ,1 },
    7267. 

  7267.     {  7438336, "NIKON",    "E5000"           ,1 },  /* or E5700 */
    7268. 

  7268.     {  8998912, "NIKON",    "COOLPIX S6"      ,1 },
    7269. 

  7269.     {  1976352, "CASIO",    "QV-2000UX"       ,1 },
    7270. 

  7270.     {  3217760, "CASIO",    "QV-3*00EX"       ,1 },
    7271. 

  7271.     {  6218368, "CASIO",    "QV-5700"         ,1 },
    7272. 

  7272.     {  6054400, "CASIO",    "QV-R41"          ,1 },
    7273. 

  7273.     {  7530816, "CASIO",    "QV-R51"          ,1 },
    7274. 

  7274.     {  7684000, "CASIO",    "QV-4000"         ,1 },
    7275. 

  7275.     {  2937856, "CASIO",    "EX-S20"          ,1 },
    7276. 

  7276.     {  4948608, "CASIO",    "EX-S100"         ,1 },
    7277. 

  7277.     {  7542528, "CASIO",    "EX-Z50"          ,1 },
    7278. 

  7278.     {  7562048, "CASIO",    "EX-Z500"         ,1 },
    7279. 

  7279.     {  7753344, "CASIO",    "EX-Z55"          ,1 },
    7280. 

  7280.     {  7816704, "CASIO",    "EX-Z60"          ,1 },
    7281. 

  7281.     { 10843712, "CASIO",    "EX-Z75"          ,1 },
    7282. 

  7282.     { 10834368, "CASIO",    "EX-Z750"         ,1 },
    7283. 

  7283.     { 12310144, "CASIO",    "EX-Z850"         ,1 },
    7284. 

  7284.     { 12489984, "CASIO",    "EX-Z8"           ,1 },
    7285. 

  7285.     { 15499264, "CASIO",    "EX-Z1050"        ,1 },
    7286. 

  7286.     { 18702336, "CASIO",    "EX-ZR100"        ,1 },
    7287. 

  7287.     {  7426656, "CASIO",    "EX-P505"         ,1 },
    7288. 

  7288.     {  9313536, "CASIO",    "EX-P600"         ,1 },
    7289. 

  7289.     { 10979200, "CASIO",    "EX-P700"         ,1 },
    7290. 

  7290.     {  3178560, "PENTAX",   "Optio S"         ,1 },
    7291. 

  7291.     {  4841984, "PENTAX",   "Optio S"         ,1 },
    7292. 

  7292.     {  6114240, "PENTAX",   "Optio S4"        ,1 },  /* or S4i, CASIO EX-Z4 */
    7293. 

  7293.     { 10702848, "PENTAX",   "Optio 750Z"      ,1 },
    7294. 

  7294.     { 15980544, "AGFAPHOTO","DC-833m"         ,1 },
    7295. 

  7295.     { 16098048, "SAMSUNG",  "S85"             ,1 },
    7296. 

  7296.     { 16215552, "SAMSUNG",  "S85"             ,1 },
    7297. 

  7297.     { 20487168, "SAMSUNG",  "WB550"           ,1 },
    7298. 

  7298.     { 24000000, "SAMSUNG",  "WB550"           ,1 },
    7299. 

  7299.     { 9994240, "ptGrey", "GRAS-50S5C" ,0 }, // KC: SUPPORT GRASSHOPPER
    7300. 

  7300.     { 10075968, "JaiPulnix","BB-500CL" ,0 }, // KC: SUPPORT BB-500CL
    7301. 

  7301.     { 10108896, "JaiPulnix","BB-500GE" ,0 }, // KC: SUPPORT BB-500GE
    7302. 

  7302.     { 10036800, "SVS", "SVS625CL" ,0 }, // KC: SUPPORT SVS625 cameralink
    7303. 

  7303.     { 12582980, "Sinar",    ""                ,0 },
    7304. 

  7304.     { 33292868, "Sinar",    ""                ,0 },
    7305. 

  7305.     { 44390468, "Sinar",    ""                ,0 } };
    7306. 

  7306.   static const char *corp[] =
    7307. 

  7307.     { "Canon", "NIKON", "EPSON", "KODAK", "Kodak", "OLYMPUS", "PENTAX",
    7308. 

  7308.       "MINOLTA", "Minolta", "Konica", "CASIO", "Sinar", "Phase One",
    7309. 

  7309.       "SAMSUNG", "Mamiya", "MOTOROLA", "LEICA" };
    7310. 

  7310. 

  7311. #ifdef LIBRAW_LIBRARY_BUILD
    7312. 

  7312.   RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY,0,2);
    7313. 

  7313. #endif
    7314. 

  7314. 

  7315.   tiff_flip = flip = filters = -1;	/* 0 is valid, so -1 is unknown */
    7316. 

  7316.   raw_height = raw_width = fuji_width = fuji_layout = cr2_slice[0] = 0;
    7317. 

  7317.   maximum = height = width = top_margin = left_margin = 0;
    7318. 

  7318.   cdesc[0] = desc[0] = artist[0] = make[0] = model[0] = model2[0] = 0;
    7319. 

  7319.   iso_speed = shutter = aperture = focal_len = unique_id = 0;
    7320. 

  7320.   tiff_nifds = 0;
    7321. 

  7321.   memset (tiff_ifd, 0, sizeof tiff_ifd);
    7322. 

  7322.   memset (gpsdata, 0, sizeof gpsdata);
    7323. 

  7323.   memset (cblack, 0, sizeof cblack);
    7324. 

  7324.   memset (white, 0, sizeof white);
    7325. 

  7325.   memset (mask, 0, sizeof mask);
    7326. 

  7326.   thumb_offset = thumb_length = thumb_width = thumb_height = 0;
    7327. 

  7327.   load_raw = thumb_load_raw = 0;
    7328. 

  7328.   write_thumb = &CLASS jpeg_thumb;
    7329. 

  7329.   data_offset = meta_length = tiff_bps = tiff_compress = 0;
    7330. 

  7330.   kodak_cbpp = zero_after_ff = dng_version = load_flags = 0;
    7331. 

  7331.   timestamp = shot_order = tiff_samples = black = is_foveon = 0;
    7332. 

  7332.   mix_green = profile_length = data_error = zero_is_bad = 0;
    7333. 

  7333.   pixel_aspect = is_raw = raw_color = 1;
    7334. 

  7334.   tile_width = tile_length = 0;
    7335. 

  7335.   for (i=0; i < 4; i++) {
    7336. 

  7336.     cam_mul[i] = i == 1;
    7337. 

  7337.     pre_mul[i] = i < 3;
    7338. 

  7338.     FORC3 cmatrix[c][i] = 0;
    7339. 

  7339.     FORC3 rgb_cam[c][i] = c == i;
    7340. 

  7340.   }
    7341. 

  7341.   colors = 3;
    7342. 

  7342.   for (i=0; i < 0x10000; i++) curve[i] = i;
    7343. 

  7343. 

  7344.   order = get2();
    7345. 

  7345.   hlen = get4();
    7346. 

  7346.   fseek (ifp, 0, SEEK_SET);
    7347. 

  7347.   fread (head, 1, 32, ifp);
    7348. 

  7348.   fseek (ifp, 0, SEEK_END);
    7349. 

  7349.   flen = fsize = ftell(ifp);
    7350. 

  7350.   if ((cp = (char *) memmem (head, 32, (char*)"MMMM", 4)) ||
    7351. 

  7351.       (cp = (char *) memmem (head, 32, (char*)"IIII", 4))) {
    7352. 

  7352.     parse_phase_one (cp-head);
    7353. 

  7353.     if (cp-head && parse_tiff(0)) apply_tiff();
    7354. 

  7354.   } else if (order == 0x4949 || order == 0x4d4d) {
    7355. 

  7355.     if (!memcmp (head+6,"HEAPCCDR",8)) {
    7356. 

  7356.       data_offset = hlen;
    7357. 

  7357.       parse_ciff (hlen, flen - hlen);
    7358. 

  7358.     } else if (parse_tiff(0)) apply_tiff();
    7359. 

  7359.   } else if (!memcmp (head,"\xff\xd8\xff\xe1",4) &&
    7360. 

  7360. 	     !memcmp (head+6,"Exif",4)) {
    7361. 

  7361.     fseek (ifp, 4, SEEK_SET);
    7362. 

  7362.     data_offset = 4 + get2();
    7363. 

  7363.     fseek (ifp, data_offset, SEEK_SET);
    7364. 

  7364.     if (fgetc(ifp) != 0xff)
    7365. 

  7365.       parse_tiff(12);
    7366. 

  7366.     thumb_offset = 0;
    7367. 

  7367.   } else if (!memcmp (head+25,"ARECOYK",7)) {
    7368. 

  7368.     strcpy (make, "Contax");
    7369. 

  7369.     strcpy (model,"N Digital");
    7370. 

  7370.     fseek (ifp, 33, SEEK_SET);
    7371. 

  7371.     get_timestamp(1);
    7372. 

  7372.     fseek (ifp, 60, SEEK_SET);
    7373. 

  7373.     FORC4 cam_mul[c ^ (c >> 1)] = get4();
    7374. 

  7374.   } else if (!strcmp (head, "PXN")) {
    7375. 

  7375.     strcpy (make, "Logitech");
    7376. 

  7376.     strcpy (model,"Fotoman Pixtura");
    7377. 

  7377.   } else if (!strcmp (head, "qktk")) {
    7378. 

  7378.     strcpy (make, "Apple");
    7379. 

  7379.     strcpy (model,"QuickTake 100");
    7380. 

  7380.     load_raw = &CLASS quicktake_100_load_raw;
    7381. 

  7381.   } else if (!strcmp (head, "qktn")) {
    7382. 

  7382.     strcpy (make, "Apple");
    7383. 

  7383.     strcpy (model,"QuickTake 150");
    7384. 

  7384.     load_raw = &CLASS kodak_radc_load_raw;
    7385. 

  7385.   } else if (!memcmp (head,"FUJIFILM",8)) {
    7386. 

  7386.     fseek (ifp, 84, SEEK_SET);
    7387. 

  7387.     thumb_offset = get4();
    7388. 

  7388.     thumb_length = get4();
    7389. 

  7389.     fseek (ifp, 92, SEEK_SET);
    7390. 

  7390.     parse_fuji (get4());
    7391. 

  7391.     if (thumb_offset > 120) {
    7392. 

  7392.       fseek (ifp, 120, SEEK_SET);
    7393. 

  7393.       is_raw += (i = get4()) && 1;
    7394. 

  7394.       if (is_raw == 2 && shot_select)
    7395. 

  7395. 	parse_fuji (i);
    7396. 

  7396.     }
    7397. 

  7397.     load_raw = &CLASS unpacked_load_raw;
    7398. 

  7398.     fseek (ifp, 100+28*(shot_select > 0), SEEK_SET);
    7399. 

  7399.     parse_tiff (data_offset = get4());
    7400. 

  7400.     parse_tiff (thumb_offset+12);
    7401. 

  7401.     apply_tiff();
    7402. 

  7402.   } else if (!memcmp (head,"RIFF",4)) {
    7403. 

  7403.     fseek (ifp, 0, SEEK_SET);
    7404. 

  7404.     parse_riff();
    7405. 

  7405.   } else if (!memcmp (head,"\0\001\0\001\0@",6)) {
    7406. 

  7406.     fseek (ifp, 6, SEEK_SET);
    7407. 

  7407.     fread (make, 1, 8, ifp);
    7408. 

  7408.     fread (model, 1, 8, ifp);
    7409. 

  7409.     fread (model2, 1, 16, ifp);
    7410. 

  7410.     data_offset = get2();
    7411. 

  7411.     get2();
    7412. 

  7412.     raw_width = get2();
    7413. 

  7413.     raw_height = get2();
    7414. 

  7414.     load_raw = &CLASS nokia_load_raw;
    7415. 

  7415.     filters = 0x61616161;
    7416. 

  7416.   } else if (!memcmp (head,"NOKIARAW",8)) {
    7417. 

  7417.     strcpy (make, "NOKIA");
    7418. 

  7418.     strcpy (model, "X2");
    7419. 

  7419.     order = 0x4949;
    7420. 

  7420.     fseek (ifp, 300, SEEK_SET);
    7421. 

  7421.     data_offset = get4();
    7422. 

  7422.     i = get4();
    7423. 

  7423.     width = get2();
    7424. 

  7424.     height = get2();
    7425. 

  7425.     data_offset += i - width * 5 / 4 * height;
    7426. 

  7426.     load_raw = &CLASS nokia_load_raw;
    7427. 

  7427.     filters = 0x61616161;
    7428. 

  7428.   } else if (!memcmp (head,"ARRI",4)) {
    7429. 

  7429.     order = 0x4949;
    7430. 

  7430.     fseek (ifp, 20, SEEK_SET);
    7431. 

  7431.     width = get4();
    7432. 

  7432.     height = get4();
    7433. 

  7433.     strcpy (make, "ARRI");
    7434. 

  7434.     fseek (ifp, 668, SEEK_SET);
    7435. 

  7435.     fread (model, 1, 64, ifp);
    7436. 

  7436.     data_offset = 4096;
    7437. 

  7437.     load_raw = &CLASS packed_load_raw;
    7438. 

  7438.     load_flags = 88;
    7439. 

  7439.     filters = 0x61616161;
    7440. 

  7440.   } else if (!memcmp (head+4,"RED1",4)) {
    7441. 

  7441.     strcpy (make, "RED");
    7442. 

  7442.     strcpy (model,"ONE");
    7443. 

  7443.     parse_redcine();
    7444. 

  7444.     load_raw = &CLASS redcine_load_raw;
    7445. 

  7445.     gamma_curve (1/2.4, 12.92, 1, 4095);
    7446. 

  7446.     filters = 0x49494949;
    7447. 

  7447.   } else if (!memcmp (head,"DSC-Image",9))
    7448. 

  7448.     parse_rollei();
    7449. 

  7449.   else if (!memcmp (head,"PWAD",4))
    7450. 

  7450.     parse_sinar_ia();
    7451. 

  7451.   else if (!memcmp (head,"\0MRM",4))
    7452. 

  7452.     parse_minolta(0);
    7453. 

  7453. #ifdef LIBRAW_DEMOSAIC_PACK_GPL2
    7454. 

  7454.   else if (!memcmp (head,"FOVb",4))
    7455. 

  7455.     parse_foveon();
    7456. 

  7456. #endif
    7457. 

  7457.   else if (!memcmp (head,"CI",2))
    7458. 

  7458.     parse_cine();
    7459. 

  7459.   else
    7460. 

  7460.     for (zero_fsize=i=0; i < sizeof table / sizeof *table; i++)
    7461. 

  7461.       if (fsize == table[i].fsize) {
    7462. 

  7462. 	strcpy (make,  table[i].t_make );
    7463. 

  7463. 	strcpy (model, table[i].t_model);
    7464. 

  7464. 	if (table[i].withjpeg)
    7465. 

  7465. 	  parse_external_jpeg();
    7466. 

  7466.       }
    7467. 

  7467.   if (zero_fsize) fsize = 0;
    7468. 

  7468.   if (make[0] == 0) parse_smal (0, flen);
    7469. 

  7469.   if (make[0] == 0) parse_jpeg (is_raw = 0);
    7470. 

  7470. 

  7471.   for (i=0; i < sizeof corp / sizeof *corp; i++)
    7472. 

  7472.     if (strstr (make, corp[i]))		/* Simplify company names */
    7473. 

  7473. 	strcpy (make, corp[i]);
    7474. 

  7474.   if (!strncmp (make,"KODAK",5) &&
    7475. 

  7475. 	((cp = strstr(model," DIGITAL CAMERA")) ||
    7476. 

  7476. 	 (cp = strstr(model," Digital Camera")) ||
    7477. 

  7477. 	 (cp = strstr(model,"FILE VERSION"))))
    7478. 

  7478.      *cp = 0;
    7479. 

  7479.   cp = make + strlen(make);		/* Remove trailing spaces */
    7480. 

  7480.   while (*--cp == ' ') *cp = 0;
    7481. 

  7481.   cp = model + strlen(model);
    7482. 

  7482.   while (*--cp == ' ') *cp = 0;
    7483. 

  7483.   i = strlen(make);			/* Remove make from model */
    7484. 

  7484.   if (!strncasecmp (model, make, i) && model[i++] == ' ')
    7485. 

  7485.     memmove (model, model+i, 64-i);
    7486. 

  7486.   if (!strncmp (model,"FinePix ",8))
    7487. 

  7487.     strcpy (model, model+8);
    7488. 

  7488.   if (!strncmp (model,"Digital Camera ",15))
    7489. 

  7489.     strcpy (model, model+15);
    7490. 

  7490.   desc[511] = artist[63] = make[63] = model[63] = model2[63] = 0;
    7491. 

  7491.   if (!is_raw) goto notraw;
    7492. 

  7492. 

  7493.   if (!height) height = raw_height;
    7494. 

  7494.   if (!width)  width  = raw_width;
    7495. 

  7495.   if (height == 2624 && width == 3936)	/* Pentax K10D and Samsung GX10 */
    7496. 

  7496.     { height  = 2616;   width  = 3896; }
    7497. 

  7497.   if (height == 3136 && width == 4864)  /* Pentax K20D and Samsung GX20 */
    7498. 

  7498.     { height  = 3124;   width  = 4688; filters = 0x16161616; }
    7499. 

  7499.   if (width == 4352 && (!strcmp(model,"K-r") || !strcmp(model,"K-x")))
    7500. 

  7500.     {			width  = 4309; filters = 0x16161616; }
    7501. 

  7501.   if (width >= 4960 && !strncmp(model,"K-5",3))
    7502. 

  7502.     { left_margin = 10; width  = 4950; filters = 0x16161616; }
    7503. 

  7503.   if (width >= 4960 && !strncmp(model,"K-5 II",6))
    7504. 

  7504.     { left_margin = 10; width  = 4948; filters = 0x16161616; }
    7505. 

  7505.   if (width == 4736 && !strcmp(model,"K-7"))
    7506. 

  7506.     { height  = 3122;   width  = 4684; filters = 0x16161616; top_margin = 2; }
    7507. 

  7507.   if (width == 7424 && !strcmp(model,"645D"))
    7508. 

  7508.     { height  = 5502;   width  = 7328; filters = 0x61616161; top_margin = 29;
    7509. 

  7509.       left_margin = 48; }
    7510. 

  7510.   if (height == 3014 && width == 4096)	/* Ricoh GX200 */
    7511. 

  7511. 			width  = 4014;
    7512. 

  7512.   if (dng_version) {
    7513. 

  7513.     if (filters == UINT_MAX) filters = 0;
    7514. 

  7514.     if (filters) is_raw = tiff_samples;
    7515. 

  7515.     else	 colors = tiff_samples;
    7516. 

  7516.     if (tiff_compress == 1)
    7517. 

  7517.       load_raw = &CLASS packed_dng_load_raw;
    7518. 

  7518.     if (tiff_compress == 7)
    7519. 

  7519.       load_raw = &CLASS lossless_dng_load_raw;
    7520. 

  7520.     goto dng_skip;
    7521. 

  7521.   }
    7522. 

  7522.   if ((is_canon = !strcmp(make,"Canon")))
    7523. 

  7523.     load_raw = memcmp (head+6,"HEAPCCDR",8) ?
    7524. 

  7524. 	&CLASS lossless_jpeg_load_raw : &CLASS canon_load_raw;
    7525. 

  7525.   if (!strcmp(make,"NIKON")) {
    7526. 

  7526.     if (!load_raw)
    7527. 

  7527.       load_raw = &CLASS packed_load_raw;
    7528. 

  7528.     if (model[0] == 'E')
    7529. 

  7529.       load_flags |= !data_offset << 2 | 2;
    7530. 

  7530.   }
    7531. 

  7531.   if (!strcmp(make,"CASIO")) {
    7532. 

  7532.     load_raw = &CLASS packed_load_raw;
    7533. 

  7533.     maximum = 0xf7f;
    7534. 

  7534.   }
    7535. 

  7535. 

  7536. /* Set parameters based on camera name (for non-DNG files). */
    7537. 

  7537. 

  7538.   if (is_foveon) {
    7539. 

  7539.     if (height*2 < width) pixel_aspect = 0.5;
    7540. 

  7540.     if (height   > width) pixel_aspect = 2;
    7541. 

  7541.     filters = 0;
    7542. 

  7542.     simple_coeff(0);
    7543. 

  7543.   } else if (is_canon && tiff_bps == 15) {
    7544. 

  7544.     switch (width) {
    7545. 

  7545.       case 3344: width -= 66;
    7546. 

  7546.       case 3872: width -= 6;
    7547. 

  7547.     }
    7548. 

  7548.     if (height > width) SWAP(height,width);
    7549. 

  7549.     filters = 0;
    7550. 

  7550.     load_raw = &CLASS canon_sraw_load_raw;
    7551. 

  7551.   } else if (!strcmp(model,"PowerShot 600")) {
    7552. 

  7552.     height = 613;
    7553. 

  7553.     width  = 854;
    7554. 

  7554.     raw_width = 896;
    7555. 

  7555.     pixel_aspect = 607/628.0;
    7556. 

  7556.     colors = 4;
    7557. 

  7557.     filters = 0xe1e4e1e4;
    7558. 

  7558.     load_raw = &CLASS canon_600_load_raw;
    7559. 

  7559.   } else if (!strcmp(model,"PowerShot A5") ||
    7560. 

  7560. 	     !strcmp(model,"PowerShot A5 Zoom")) {
    7561. 

  7561.     height = 773;
    7562. 

  7562.     width  = 960;
    7563. 

  7563.     raw_width = 992;
    7564. 

  7564.     pixel_aspect = 256/235.0;
    7565. 

  7565.     colors = 4;
    7566. 

  7566.     filters = 0x1e4e1e4e;
    7567. 

  7567.     goto canon_a5;
    7568. 

  7568.   } else if (!strcmp(model,"PowerShot A50")) {
    7569. 

  7569.     height =  968;
    7570. 

  7570.     width  = 1290;
    7571. 

  7571.     raw_width = 1320;
    7572. 

  7572.     colors = 4;
    7573. 

  7573.     filters = 0x1b4e4b1e;
    7574. 

  7574.     goto canon_a5;
    7575. 

  7575.   } else if (!strcmp(model,"PowerShot Pro70")) {
    7576. 

  7576.     height = 1024;
    7577. 

  7577.     width  = 1552;
    7578. 

  7578.     colors = 4;
    7579. 

  7579.     filters = 0x1e4b4e1b;
    7580. 

  7580.     goto canon_a5;
    7581. 

  7581.   } else if (!strcmp(model,"PowerShot SD300")) {
    7582. 

  7582.     height = 1752;
    7583. 

  7583.     width  = 2344;
    7584. 

  7584.     raw_height = 1766;
    7585. 

  7585.     raw_width  = 2400;
    7586. 

  7586.     top_margin  = 12;
    7587. 

  7587.     left_margin = 12;
    7588. 

  7588.     goto canon_a5;
    7589. 

  7589.   } else if (!strcmp(model,"PowerShot A460")) {
    7590. 

  7590.     height = 1960;
    7591. 

  7591.     width  = 2616;
    7592. 

  7592.     raw_height = 1968;
    7593. 

  7593.     raw_width  = 2664;
    7594. 

  7594.     top_margin  = 4;
    7595. 

  7595.     left_margin = 4;
    7596. 

  7596.     goto canon_a5;
    7597. 

  7597.   } else if (!strcmp(model,"PowerShot A530")) {
    7598. 

  7598.     height = 1984;
    7599. 

  7599.     width  = 2620;
    7600. 

  7600.     raw_height = 1992;
    7601. 

  7601.     raw_width  = 2672;
    7602. 

  7602.     top_margin  = 6;
    7603. 

  7603.     left_margin = 10;
    7604. 

  7604.     goto canon_a5;
    7605. 

  7605.   } else if (!strcmp(model,"PowerShot A610")) {
    7606. 

  7606.     if (canon_s2is()) strcpy (model+10, "S2 IS");
    7607. 

  7607.     height = 1960;
    7608. 

  7608.     width  = 2616;
    7609. 

  7609.     raw_height = 1968;
    7610. 

  7610.     raw_width  = 2672;
    7611. 

  7611.     top_margin  = 8;
    7612. 

  7612.     left_margin = 12;
    7613. 

  7613.     goto canon_a5;
    7614. 

  7614.   } else if (!strcmp(model,"PowerShot A620")) {
    7615. 

  7615.     height = 2328;
    7616. 

  7616.     width  = 3112;
    7617. 

  7617.     raw_height = 2340;
    7618. 

  7618.     raw_width  = 3152;
    7619. 

  7619.     top_margin  = 12;
    7620. 

  7620.     left_margin = 36;
    7621. 

  7621.     goto canon_a5;
    7622. 

  7622.   } else if (!strcmp(model,"PowerShot A470")) {
    7623. 

  7623.     height = 2328;
    7624. 

  7624.     width  = 3096;
    7625. 

  7625.     raw_height = 2346;
    7626. 

  7626.     raw_width  = 3152;
    7627. 

  7627.     top_margin  = 6;
    7628. 

  7628.     left_margin = 12;
    7629. 

  7629.     goto canon_a5;
    7630. 

  7630.   } else if (!strcmp(model,"PowerShot A720 IS")) {
    7631. 

  7631.     height = 2472;
    7632. 

  7632.     width  = 3298;
    7633. 

  7633.     raw_height = 2480;
    7634. 

  7634.     raw_width  = 3336;
    7635. 

  7635.     top_margin  = 5;
    7636. 

  7636.     left_margin = 6;
    7637. 

  7637.     goto canon_a5;
    7638. 

  7638.   } else if (!strcmp(model,"PowerShot A630")) {
    7639. 

  7639.     height = 2472;
    7640. 

  7640.     width  = 3288;
    7641. 

  7641.     raw_height = 2484;
    7642. 

  7642.     raw_width  = 3344;
    7643. 

  7643.     top_margin  = 6;
    7644. 

  7644.     left_margin = 12;
    7645. 

  7645.     goto canon_a5;
    7646. 

  7646.   } else if (!strcmp(model,"PowerShot A640")) {
    7647. 

  7647.     height = 2760;
    7648. 

  7648.     width  = 3672;
    7649. 

  7649.     raw_height = 2772;
    7650. 

  7650.     raw_width  = 3736;
    7651. 

  7651.     top_margin  = 6;
    7652. 

  7652.     left_margin = 12;
    7653. 

  7653.     goto canon_a5;
    7654. 

  7654.   } else if (!strcmp(model,"PowerShot A650")) {
    7655. 

  7655.     height = 3024;
    7656. 

  7656.     width  = 4032;
    7657. 

  7657.     raw_height = 3048;
    7658. 

  7658.     raw_width  = 4104;
    7659. 

  7659.     top_margin  = 12;
    7660. 

  7660.     left_margin = 48;
    7661. 

  7661.     goto canon_a5;
    7662. 

  7662.   } else if (!strcmp(model,"PowerShot S3 IS")) {
    7663. 

  7663.     height = 2128;
    7664. 

  7664.     width  = 2840;
    7665. 

  7665.     raw_height = 2136;
    7666. 

  7666.     raw_width  = 2888;
    7667. 

  7667.     top_margin  = 8;
    7668. 

  7668.     left_margin = 44;
    7669. 

  7669. canon_a5:
    7670. 

  7670.     tiff_bps = 10;
    7671. 

  7671.     load_raw = &CLASS packed_load_raw;
    7672. 

  7672.     load_flags = 40;
    7673. 

  7673.     if (raw_width > 1600) zero_is_bad = 1;
    7674. 

  7674.   } else if (!strcmp(model,"PowerShot SX110 IS")) {
    7675. 

  7675.     height = 2760;
    7676. 

  7676.     width  = 3684;
    7677. 

  7677.     raw_height = 2772;
    7678. 

  7678.     raw_width  = 3720;
    7679. 

  7679.     top_margin  = 12;
    7680. 

  7680.     left_margin = 6;
    7681. 

  7681.     load_raw = &CLASS packed_load_raw;
    7682. 

  7682.     load_flags = 40;
    7683. 

  7683.     zero_is_bad = 1;
    7684. 

  7684.   } else if (!strcmp(model,"PowerShot SX120 IS")) {
    7685. 

  7685.     height = 2742;
    7686. 

  7686.     width  = 3664;
    7687. 

  7687.     raw_height = 2778;
    7688. 

  7688.     raw_width  = 3728;
    7689. 

  7689.     top_margin  = 18;
    7690. 

  7690.     left_margin = 16;
    7691. 

  7691.     filters = 0x49494949;
    7692. 

  7692.     load_raw = &CLASS packed_load_raw;
    7693. 

  7693.     load_flags = 40;
    7694. 

  7694.     zero_is_bad = 1;
    7695. 

  7695.   } else if (!strcmp(model,"PowerShot SX20 IS")) {
    7696. 

  7696.     height = 3024;
    7697. 

  7697.     width  = 4032;
    7698. 

  7698.     raw_height = 3048;
    7699. 

  7699.     raw_width  = 4080;
    7700. 

  7700.     top_margin  = 12;
    7701. 

  7701.     left_margin = 24;
    7702. 

  7702.     load_raw = &CLASS packed_load_raw;
    7703. 

  7703.     load_flags = 40;
    7704. 

  7704.     zero_is_bad = 1;
    7705. 

  7705.   } else if (!strcmp(model,"PowerShot SX220 HS")) {
    7706. 

  7706.     height = 3043;
    7707. 

  7707.     width  = 4072;
    7708. 

  7708.     raw_height = 3060;
    7709. 

  7709.     raw_width  = 4168;
    7710. 

  7710.     mask[0][0] = top_margin = 16;
    7711. 

  7711.     mask[0][2] = top_margin + height;
    7712. 

  7712.     mask[0][3] = left_margin = 92;
    7713. 

  7713.     load_raw = &CLASS packed_load_raw;
    7714. 

  7714.     load_flags = 8;
    7715. 

  7715.     zero_is_bad = 1;
    7716. 

  7716.   } else if (!strcmp(model,"PowerShot SX50 HS")) {
    7717. 

  7717.     top_margin=16;
    7718. 

  7718.     left_margin=94;
    7719. 

  7719.     height = 3043;
    7720. 

  7720.     width  = 4072;
    7721. 

  7721.   } else if (!strcmp(model,"PowerShot SX30 IS")) {
    7722. 

  7722.     height = 3254;
    7723. 

  7723.     width  = 4366;
    7724. 

  7724.     raw_height = 3276;
    7725. 

  7725.     raw_width  = 4464;
    7726. 

  7726.     top_margin  = 10;
    7727. 

  7727.     left_margin = 25;
    7728. 

  7728.     filters = 0x16161616;
    7729. 

  7729.     load_raw = &CLASS packed_load_raw;
    7730. 

  7730.     load_flags = 40;
    7731. 

  7731.     zero_is_bad = 1;
    7732. 

  7732.   } else if (!strcmp(model,"PowerShot Pro90 IS")) {
    7733. 

  7733.     width  = 1896;
    7734. 

  7734.     colors = 4;
    7735. 

  7735.     filters = 0xb4b4b4b4;
    7736. 

  7736.   } else if (is_canon && raw_width == 2144) {
    7737. 

  7737.     height = 1550;
    7738. 

  7738.     width  = 2088;
    7739. 

  7739.     top_margin  = 8;
    7740. 

  7740.     left_margin = 4;
    7741. 

  7741.     if (!strcmp(model,"PowerShot G1")) {
    7742. 

  7742.       colors = 4;
    7743. 

  7743.       filters = 0xb4b4b4b4;
    7744. 

  7744.     }
    7745. 

  7745.   } else if (is_canon && raw_width == 2224) {
    7746. 

  7746.     height = 1448;
    7747. 

  7747.     width  = 2176;
    7748. 

  7748.     top_margin  = 6;
    7749. 

  7749.     left_margin = 48;
    7750. 

  7750.   } else if (is_canon && raw_width == 2376) {
    7751. 

  7751.     height = 1720;
    7752. 

  7752.     width  = 2312;
    7753. 

  7753.     top_margin  = 6;
    7754. 

  7754.     left_margin = 12;
    7755. 

  7755.   } else if (is_canon && raw_width == 2672) {
    7756. 

  7756.     height = 1960;
    7757. 

  7757.     width  = 2616;
    7758. 

  7758.     top_margin  = 6;
    7759. 

  7759.     left_margin = 12;
    7760. 

  7760.   } else if (is_canon && raw_width == 3152) {
    7761. 

  7761.     height = 2056;
    7762. 

  7762.     width  = 3088;
    7763. 

  7763.     top_margin  = 12;
    7764. 

  7764.     left_margin = 64;
    7765. 

  7765.     if (unique_id == 0x80000170)
    7766. 

  7766.       adobe_coeff ("Canon","EOS 300D");
    7767. 

  7767.   } else if (is_canon && raw_width == 3160) {
    7768. 

  7768.     height = 2328;
    7769. 

  7769.     width  = 3112;
    7770. 

  7770.     top_margin  = 12;
    7771. 

  7771.     left_margin = 44;
    7772. 

  7772.   } else if (is_canon && raw_width == 3344) {
    7773. 

  7773.     height = 2472;
    7774. 

  7774.     width  = 3288;
    7775. 

  7775.     top_margin  = 6;
    7776. 

  7776.     left_margin = 4;
    7777. 

  7777.   } else if (!strcmp(model,"EOS D2000C")) {
    7778. 

  7778.     filters = 0x61616161;
    7779. 

  7779.     black = curve[200];
    7780. 

  7780.   } else if (is_canon && raw_width == 3516) {
    7781. 

  7781.     top_margin  = 14;
    7782. 

  7782.     left_margin = 42;
    7783. 

  7783.     if (unique_id == 0x80000189)
    7784. 

  7784.       adobe_coeff ("Canon","EOS 350D");
    7785. 

  7785.     goto canon_cr2;
    7786. 

  7786.   } else if (is_canon && raw_width == 3596) {
    7787. 

  7787.     top_margin  = 12;
    7788. 

  7788.     left_margin = 74;
    7789. 

  7789.     goto canon_cr2;
    7790. 

  7790.   } else if (is_canon && raw_width == 3744) {
    7791. 

  7791.     height = 2760;
    7792. 

  7792.     width  = 3684;
    7793. 

  7793.     top_margin  = 16;
    7794. 

  7794.     left_margin = 8;
    7795. 

  7795.     if (unique_id > 0x2720000) {
    7796. 

  7796.       top_margin  = 12;
    7797. 

  7797.       left_margin = 52;
    7798. 

  7798.     }
    7799. 

  7799.   } else if (is_canon && raw_width == 3944) {
    7800. 

  7800.     height = 2602;
    7801. 

  7801.     width  = 3908;
    7802. 

  7802.     top_margin  = 18;
    7803. 

  7803.     left_margin = 30;
    7804. 

  7804.   } else if (is_canon && raw_width == 3948) {
    7805. 

  7805.     top_margin  = 18;
    7806. 

  7806.     left_margin = 42;
    7807. 

  7807.     height -= 2;
    7808. 

  7808.     if (unique_id == 0x80000236)
    7809. 

  7809.       adobe_coeff ("Canon","EOS 400D");
    7810. 

  7810.     if (unique_id == 0x80000254)
    7811. 

  7811.       adobe_coeff ("Canon","EOS 1000D");
    7812. 

  7812.     goto canon_cr2;
    7813. 

  7813.   } else if (is_canon && raw_width == 3984) {
    7814. 

  7814.     top_margin  = 20;
    7815. 

  7815.     left_margin = 76;
    7816. 

  7816.     height -= 2;
    7817. 

  7817.     goto canon_cr2;
    7818. 

  7818.   } else if (is_canon && raw_width == 4104) {
    7819. 

  7819.     height = 3024;
    7820. 

  7820.     width  = 4032;
    7821. 

  7821.     top_margin  = 12;
    7822. 

  7822.     left_margin = 48;
    7823. 

  7823.   } else if (is_canon && raw_width == 4152) {
    7824. 

  7824.     top_margin  = 12;
    7825. 

  7825.     left_margin = 192;
    7826. 

  7826.     goto canon_cr2;
    7827. 

  7827.   } else if (is_canon && raw_width == 4160) {
    7828. 

  7828.     height = 3048;
    7829. 

  7829.     width  = 4048;
    7830. 

  7830.     top_margin  = 11;
    7831. 

  7831.     left_margin = 104;
    7832. 

  7832.   } else if (is_canon && raw_width == 4176) {
    7833. 

  7833.     height = 3045;
    7834. 

  7834.     width  = 4072;
    7835. 

  7835.     left_margin = 96;
    7836. 

  7836.     mask[0][0] = top_margin = 17;
    7837. 

  7837.     mask[0][2] = raw_height;
    7838. 

  7838.     mask[0][3] = 80;
    7839. 

  7839.     filters = 0x49494949;
    7840. 

  7840.   } else if (is_canon && raw_width == 4312) {
    7841. 

  7841.     top_margin  = 18;
    7842. 

  7842.     left_margin = 22;
    7843. 

  7843.     height -= 2;
    7844. 

  7844.     if (unique_id == 0x80000176)
    7845. 

  7845.       adobe_coeff ("Canon","EOS 450D");
    7846. 

  7846.     goto canon_cr2;
    7847. 

  7847.   } else if (is_canon && raw_width == 4352) {
    7848. 

  7848.     top_margin  = 18;
    7849. 

  7849.     left_margin = 62;
    7850. 

  7850.     if (unique_id == 0x80000288)
    7851. 

  7851.       adobe_coeff ("Canon","EOS 1100D");
    7852. 

  7852.     goto canon_cr2;
    7853. 

  7853.   } else if (is_canon && raw_width == 4476) {
    7854. 

  7854.     top_margin  = 34;
    7855. 

  7855.     left_margin = 90;
    7856. 

  7856.     goto canon_cr2;
    7857. 

  7857.   } else if (is_canon && raw_width == 4480) {
    7858. 

  7858.     height = 3326;
    7859. 

  7859.     width  = 4432;
    7860. 

  7860.     top_margin  = 10;
    7861. 

  7861.     left_margin = 12;
    7862. 

  7862.     filters = 0x49494949;
    7863. 

  7863.   } else if (is_canon && raw_width == 4496) {
    7864. 

  7864.     height = 3316;
    7865. 

  7865.     width  = 4404;
    7866. 

  7866.     top_margin  = 50;
    7867. 

  7867.     left_margin = 80;
    7868. 

  7868.   } else if (is_canon && raw_width == 4832) {
    7869. 

  7869.     top_margin = unique_id == 0x80000261 ? 51:26;
    7870. 

  7870.     left_margin = 62;
    7871. 

  7871.     if (unique_id == 0x80000252)
    7872. 

  7872.       adobe_coeff ("Canon","EOS 500D");
    7873. 

  7873.     goto canon_cr2;
    7874. 

  7874.   } else if (is_canon && raw_width == 5108) {
    7875. 

  7875.     top_margin  = 13;
    7876. 

  7876.     left_margin = 98;
    7877. 

  7877.     goto canon_cr2;
    7878. 

  7878.   } else if (is_canon && raw_width == 5120) {
    7879. 

  7879.     height -= top_margin = 45;
    7880. 

  7880.     left_margin = 142;
    7881. 

  7881.     width = 4916;
    7882. 

  7882.   } else if (is_canon && raw_width == 5280) {
    7883. 

  7883.     top_margin  = 52;
    7884. 

  7884.     left_margin = 72;
    7885. 

  7885.     if (unique_id == 0x80000301)
    7886. 

  7886.       adobe_coeff ("Canon","EOS 650D");
    7887. 

  7887.     goto canon_cr2;
    7888. 

  7888.   } else if (is_canon && raw_width == 5344) {
    7889. 

  7889.     top_margin = 51;
    7890. 

  7890.     left_margin = 142;
    7891. 

  7891.     if (unique_id == 0x80000269) {
    7892. 

  7892.       top_margin = 100;
    7893. 

  7893.       left_margin = 126;
    7894. 

  7894.       height -= 2;
    7895. 

  7895.       adobe_coeff ("Canon","EOS-1D X");
    7896. 

  7896.     }
    7897. 

  7897.     if (unique_id == 0x80000270)
    7898. 

  7898.       adobe_coeff ("Canon","EOS 550D");
    7899. 

  7899.     if (unique_id == 0x80000286)
    7900. 

  7900.       adobe_coeff ("Canon","EOS 600D");
    7901. 

  7901.     goto canon_cr2;
    7902. 

  7902.   } else if (is_canon && raw_width == 5360) {
    7903. 

  7903.     top_margin = 51;
    7904. 

  7904.     left_margin = 158;
    7905. 

  7905.     goto canon_cr2;
    7906. 

  7906.   } else if (is_canon && raw_width == 5568) {
    7907. 

  7907.     top_margin = 38;
    7908. 

  7908.     left_margin = 72;
    7909. 

  7909.     goto canon_cr2;
    7910. 

  7910.   } else if (is_canon && raw_width == 5712) {
    7911. 

  7911.     height = 3752;
    7912. 

  7912.     width  = 5640;
    7913. 

  7913.     top_margin  = 20;
    7914. 

  7914.     left_margin = 62;
    7915. 

  7915.   } else if (is_canon && raw_width == 5792) {
    7916. 

  7916.     top_margin  = 51;
    7917. 

  7917.     left_margin = 158;
    7918. 

  7918. canon_cr2:
    7919. 

  7919.     height -= top_margin;
    7920. 

  7920.     width  -= left_margin;
    7921. 

  7921.   } else if (is_canon && raw_width == 5920) {
    7922. 

  7922.     height = 3870;
    7923. 

  7923.     width  = 5796;
    7924. 

  7924.     top_margin  = 80;
    7925. 

  7925.     left_margin = 122;
    7926. 

  7926.   } else if (!strcmp(model,"D1")) {
    7927. 

  7927.     cam_mul[0] *= 256/527.0;
    7928. 

  7928.     cam_mul[2] *= 256/317.0;
    7929. 

  7929.   } else if (!strcmp(model,"D1X")) {
    7930. 

  7930.     width -= 4;
    7931. 

  7931.     pixel_aspect = 0.5;
    7932. 

  7932.   } else if (!strcmp(model,"D40X") ||
    7933. 

  7933. 	     !strcmp(model,"D60")  ||
    7934. 

  7934. 	     !strcmp(model,"D80")  ||
    7935. 

  7935. 	     !strcmp(model,"D3000")) {
    7936. 

  7936.     height -= 3;
    7937. 

  7937.     width  -= 4;
    7938. 

  7938.   } else if (!strcmp(model,"D3")   ||
    7939. 

  7939. 	     !strcmp(model,"D3S")  ||
    7940. 

  7940. 	     !strcmp(model,"D700")) {
    7941. 

  7941.     width -= 4;
    7942. 

  7942.     left_margin = 2;
    7943. 

  7943.   } else if (!strcmp(model,"D3100")) {
    7944. 

  7944.     width -= 28;
    7945. 

  7945.     left_margin = 6;
    7946. 

  7946.   } else if (!strcmp(model,"D5000") ||
    7947. 

  7947. 	     !strcmp(model,"D90")) {
    7948. 

  7948.     width -= 42;
    7949. 

  7949.   } else if (!strcmp(model,"D5100") ||
    7950. 

  7950. 	     !strcmp(model,"D7000")) {
    7951. 

  7951.     width -= 44;
    7952. 

  7952.   } else if (!strcmp(model,"D3200") ||
    7953. 

  7953. 	     !strcmp(model,"D800E") ||
    7954. 

  7954. 	     !strcmp(model,"D600")  ||
    7955. 

  7955. 	     !strcmp(model,"D800")) {
    7956. 

  7956.     width -= 46;
    7957. 

  7957.   } else if (!strcmp(model,"D4")) {
    7958. 

  7958.     width -= 52;
    7959. 

  7959.     left_margin = 2;
    7960. 

  7960.   } else if (!strcmp(model,"D600")) {
    7961. 

  7961.     width -= 48;
    7962. 

  7962.   } else if (!strncmp(model,"D40",3) ||
    7963. 

  7963. 	     !strncmp(model,"D50",3) ||
    7964. 

  7964. 	     !strncmp(model,"D70",3)) {
    7965. 

  7965.     width--;
    7966. 

  7966.   } else if (!strcmp(model,"D100")) {
    7967. 

  7967.     if (load_flags)
    7968. 

  7968.       raw_width = (width += 3) + 3;
    7969. 

  7969.   } else if (!strcmp(model,"D200")) {
    7970. 

  7970.     left_margin = 1;
    7971. 

  7971.     width -= 4;
    7972. 

  7972.     filters = 0x94949494;
    7973. 

  7973.   } else if (!strncmp(model,"D2H",3)) {
    7974. 

  7974.     left_margin = 6;
    7975. 

  7975.     width -= 14;
    7976. 

  7976.   } else if (!strncmp(model,"D2X",3)) {
    7977. 

  7977.     if (width == 3264) width -= 32;
    7978. 

  7978.     else width -= 8;
    7979. 

  7979.   } else if (!strncmp(model,"D300",4)) {
    7980. 

  7980.     width -= 32;
    7981. 

  7981.   } else if (!strcmp(make,"NIKON") && raw_width == 4032) {
    7982. 

  7982.     adobe_coeff ("NIKON","COOLPIX P7700");
    7983. 

  7983.   } else if (!strncmp(model,"COOLPIX P",9)) {
    7984. 

  7984.     load_flags = 24;
    7985. 

  7985.     filters = 0x94949494;
    7986. 

  7986.     if (model[9] == '7' && iso_speed >= 400)
    7987. 

  7987.       black = 255;
    7988. 

  7988.   } else if (!strncmp(model,"1 ",2)) {
    7989. 

  7989.     height -= 2;
    7990. 

  7990.   } else if (fsize == 1581060) {
    7991. 

  7991.     height = 963;
    7992. 

  7992.     width = 1287;
    7993. 

  7993.     raw_width = 1632;
    7994. 

  7994.     maximum = 0x3f4;
    7995. 

  7995.     colors = 4;
    7996. 

  7996.     filters = 0x1e1e1e1e;
    7997. 

  7997.     simple_coeff(3);
    7998. 

  7998.     pre_mul[0] = 1.2085;
    7999. 

  7999.     pre_mul[1] = 1.0943;
    8000. 

  8000.     pre_mul[3] = 1.1103;
    8001. 

  8001.     goto e900;
    8002. 

  8002.   } else if (fsize == 2465792) {
    8003. 

  8003.     height = 1203;
    8004. 

  8004.     width  = 1616;
    8005. 

  8005.     raw_width = 2048;
    8006. 

  8006.     colors = 4;
    8007. 

  8007.     filters = 0x4b4b4b4b;
    8008. 

  8008.     adobe_coeff ("NIKON","E950");
    8009. 

  8009. e900:
    8010. 

  8010.     tiff_bps = 10;
    8011. 

  8011.     load_raw = &CLASS packed_load_raw;
    8012. 

  8012.     load_flags = 6;
    8013. 

  8013.   } else if (fsize == 4771840) {
    8014. 

  8014.     height = 1540;
    8015. 

  8015.     width  = 2064;
    8016. 

  8016.     colors = 4;
    8017. 

  8017.     filters = 0xe1e1e1e1;
    8018. 

  8018.     load_raw = &CLASS packed_load_raw;
    8019. 

  8019.     load_flags = 6;
    8020. 

  8020.     if (!timestamp && nikon_e995())
    8021. 

  8021.       strcpy (model, "E995");
    8022. 

  8022.     if (strcmp(model,"E995")) {
    8023. 

  8023.       filters = 0xb4b4b4b4;
    8024. 

  8024.       simple_coeff(3);
    8025. 

  8025.       pre_mul[0] = 1.196;
    8026. 

  8026.       pre_mul[1] = 1.246;
    8027. 

  8027.       pre_mul[2] = 1.018;
    8028. 

  8028.     }
    8029. 

  8029.   } else if (!strcmp(model,"E2100")) {
    8030. 

  8030.     if (!timestamp && !nikon_e2100()) goto cp_e2500;
    8031. 

  8031.     height = 1206;
    8032. 

  8032.     width  = 1616;
    8033. 

  8033.     load_flags = 30;
    8034. 

  8034.   } else if (!strcmp(model,"E2500")) {
    8035. 

  8035. cp_e2500:
    8036. 

  8036.     strcpy (model, "E2500");
    8037. 

  8037.     height = 1204;
    8038. 

  8038.     width  = 1616;
    8039. 

  8039.     colors = 4;
    8040. 

  8040.     filters = 0x4b4b4b4b;
    8041. 

  8041.   } else if (fsize == 4775936) {
    8042. 

  8042.     height = 1542;
    8043. 

  8043.     width  = 2064;
    8044. 

  8044.     load_raw = &CLASS packed_load_raw;
    8045. 

  8045.     load_flags = 30;
    8046. 

  8046.     if (!timestamp) nikon_3700();
    8047. 

  8047.     if (model[0] == 'E' && atoi(model+1) < 3700)
    8048. 

  8048.       filters = 0x49494949;
    8049. 

  8049.     if (!strcmp(model,"Optio 33WR")) {
    8050. 

  8050.       flip = 1;
    8051. 

  8051.       filters = 0x16161616;
    8052. 

  8052.     }
    8053. 

  8053.     if (make[0] == 'O') {
    8054. 

  8054.       i = find_green (12, 32, 1188864, 3576832);
    8055. 

  8055.       c = find_green (12, 32, 2383920, 2387016);
    8056. 

  8056.       if (abs(i) < abs(c)) {
    8057. 

  8057. 	SWAP(i,c);
    8058. 

  8058. 	load_flags = 24;
    8059. 

  8059.       }
    8060. 

  8060.       if (i < 0) filters = 0x61616161;
    8061. 

  8061.     }
    8062. 

  8062.   } else if (fsize == 5869568) {
    8063. 

  8063.     height = 1710;
    8064. 

  8064.     width  = 2288;
    8065. 

  8065.     filters = 0x16161616;
    8066. 

  8066.     if (!timestamp && minolta_z2()) {
    8067. 

  8067.       strcpy (make, "Minolta");
    8068. 

  8068.       strcpy (model,"DiMAGE Z2");
    8069. 

  8069.     }
    8070. 

  8070.     load_raw = &CLASS packed_load_raw;
    8071. 

  8071.     load_flags = 6 + 24*(make[0] == 'M');
    8072. 

  8072.   } else if (!strcmp(model,"E4500")) {
    8073. 

  8073.     height = 1708;
    8074. 

  8074.     width  = 2288;
    8075. 

  8075.     colors = 4;
    8076. 

  8076.     filters = 0xb4b4b4b4;
    8077. 

  8077.   } else if (fsize == 7438336) {
    8078. 

  8078.     height = 1924;
    8079. 

  8079.     width  = 2576;
    8080. 

  8080.     colors = 4;
    8081. 

  8081.     filters = 0xb4b4b4b4;
    8082. 

  8082.   } else if (fsize == 8998912) {
    8083. 

  8083.     height = 2118;
    8084. 

  8084.     width  = 2832;
    8085. 

  8085.     maximum = 0xf83;
    8086. 

  8086.     load_raw = &CLASS packed_load_raw;
    8087. 

  8087.     load_flags = 30;
    8088. 

  8088.   } else if (!strcmp(make,"FUJIFILM")) {
    8089. 

  8089.     if (!strcmp(model+7,"S2Pro")) {
    8090. 

  8090.       strcpy (model,"S2Pro");
    8091. 

  8091.       height = 2144;
    8092. 

  8092.       width  = 2880;
    8093. 

  8093.       flip = 6;
    8094. 

  8094.     } else if (load_raw != &CLASS packed_load_raw)
    8095. 

  8095.       maximum = (is_raw == 2 && shot_select) ? 0x2f00 : 0x3e00;
    8096. 

  8096.     top_margin = (raw_height - height) >> 2 << 1;
    8097. 

  8097.     left_margin = (raw_width - width ) >> 2 << 1;
    8098. 

  8098.     if (width == 2848) filters = 0x16161616;
    8099. 

  8099.     if (width == 3328) {
    8100. 

  8100.       width = 3262;
    8101. 

  8101.       left_margin = 34;
    8102. 

  8102.     }
    8103. 

  8103.     if (width == 4952) {
    8104. 

  8104.       left_margin = 0;
    8105. 

  8105.       filters = 2;
    8106. 

  8106.     }
    8107. 

  8107.     if (fuji_layout) raw_width *= is_raw;
    8108. 

  8108.   } else if (!strcmp(model,"RD175")) {
    8109. 

  8109.     height = 986;
    8110. 

  8110.     width = 1534;
    8111. 

  8111.     data_offset = 513;
    8112. 

  8112.     filters = 0x61616161;
    8113. 

  8113.     load_raw = &CLASS minolta_rd175_load_raw;
    8114. 

  8114.   } else if (!strcmp(model,"KD-400Z")) {
    8115. 

  8115.     height = 1712;
    8116. 

  8116.     width  = 2312;
    8117. 

  8117.     raw_width = 2336;
    8118. 

  8118.     goto konica_400z;
    8119. 

  8119.   } else if (!strcmp(model,"KD-510Z")) {
    8120. 

  8120.     goto konica_510z;
    8121. 

  8121.   } else if (!strcasecmp(make,"MINOLTA")) {
    8122. 

  8122.     load_raw = &CLASS unpacked_load_raw;
    8123. 

  8123.     maximum = 0xfff;
    8124. 

  8124.     if (!strncmp(model,"DiMAGE A",8)) {
    8125. 

  8125.       if (!strcmp(model,"DiMAGE A200"))
    8126. 

  8126. 	filters = 0x49494949;
    8127. 

  8127.       tiff_bps = 12;
    8128. 

  8128.       load_raw = &CLASS packed_load_raw;
    8129. 

  8129.     } else if (!strncmp(model,"ALPHA",5) ||
    8130. 

  8130. 	       !strncmp(model,"DYNAX",5) ||
    8131. 

  8131. 	       !strncmp(model,"MAXXUM",6)) {
    8132. 

  8132.       sprintf (model+20, "DYNAX %-10s", model+6+(model[0]=='M'));
    8133. 

  8133.       adobe_coeff (make, model+20);
    8134. 

  8134.       load_raw = &CLASS packed_load_raw;
    8135. 

  8135.     } else if (!strncmp(model,"DiMAGE G",8)) {
    8136. 

  8136.       if (model[8] == '4') {
    8137. 

  8137. 	height = 1716;
    8138. 

  8138. 	width  = 2304;
    8139. 

  8139.       } else if (model[8] == '5') {
    8140. 

  8140. konica_510z:
    8141. 

  8141. 	height = 1956;
    8142. 

  8142. 	width  = 2607;
    8143. 

  8143. 	raw_width = 2624;
    8144. 

  8144.       } else if (model[8] == '6') {
    8145. 

  8145. 	height = 2136;
    8146. 

  8146. 	width  = 2848;
    8147. 

  8147.       }
    8148. 

  8148.       data_offset += 14;
    8149. 

  8149.       filters = 0x61616161;
    8150. 

  8150. konica_400z:
    8151. 

  8151.       load_raw = &CLASS unpacked_load_raw;
    8152. 

  8152.       maximum = 0x3df;
    8153. 

  8153.       order = 0x4d4d;
    8154. 

  8154.     }
    8155. 

  8155.   } else if (!strcmp(model,"*ist D")) {
    8156. 

  8156.     load_raw = &CLASS unpacked_load_raw;
    8157. 

  8157.     data_error = -1;
    8158. 

  8158.   } else if (!strcmp(model,"*ist DS")) {
    8159. 

  8159.     height -= 2;
    8160. 

  8160.   } else if (!strcmp(model,"Optio S")) {
    8161. 

  8161.     if (fsize == 3178560) {
    8162. 

  8162.       height = 1540;
    8163. 

  8163.       width  = 2064;
    8164. 

  8164.       load_raw = &CLASS eight_bit_load_raw;
    8165. 

  8165.       cam_mul[0] *= 4;
    8166. 

  8166.       cam_mul[2] *= 4;
    8167. 

  8167.     } else {
    8168. 

  8168.       height = 1544;
    8169. 

  8169.       width  = 2068;
    8170. 

  8170.       raw_width = 3136;
    8171. 

  8171.       load_raw = &CLASS packed_load_raw;
    8172. 

  8172.       maximum = 0xf7c;
    8173. 

  8173.     }
    8174. 

  8174.   } else if (fsize == 6114240) {
    8175. 

  8175.     height = 1737;
    8176. 

  8176.     width  = 2324;
    8177. 

  8177.     raw_width = 3520;
    8178. 

  8178.     load_raw = &CLASS packed_load_raw;
    8179. 

  8179.     maximum = 0xf7a;
    8180. 

  8180.   } else if (!strcmp(model,"Optio 750Z")) {
    8181. 

  8181.     height = 2302;
    8182. 

  8182.     width  = 3072;
    8183. 

  8183.     load_raw = &CLASS packed_load_raw;
    8184. 

  8184.     load_flags = 30;
    8185. 

  8185.   } else if (!strcmp(model,"DC-833m")) {
    8186. 

  8186.     height = 2448;
    8187. 

  8187.     width  = 3264;
    8188. 

  8188.     order = 0x4949;
    8189. 

  8189.     filters = 0x61616161;
    8190. 

  8190.     load_raw = &CLASS unpacked_load_raw;
    8191. 

  8191.     maximum = 0xfc00;
    8192. 

  8192.   } else if (!strncmp(model,"S85",3)) {
    8193. 

  8193.     height = 2448;
    8194. 

  8194.     width  = 3264;
    8195. 

  8195.     raw_width = fsize/height/2;
    8196. 

  8196.     order = 0x4d4d;
    8197. 

  8197.     load_raw = &CLASS unpacked_load_raw;
    8198. 

  8198.   } else if (!strcmp(make,"SAMSUNG") && raw_width == 4704) {
    8199. 

  8199.     height -= top_margin = 8;
    8200. 

  8200.     width -= 2 * (left_margin = 8);
    8201. 

  8201.     load_flags = 32;
    8202. 

  8202.   } else if (!strcmp(make,"SAMSUNG") && raw_width == 5632) {
    8203. 

  8203.     order = 0x4949;
    8204. 

  8204.     height = 3694;
    8205. 

  8205.     top_margin = 2;
    8206. 

  8206.     width  = 5574 - (left_margin = 32 + tiff_bps);
    8207. 

  8207.     if (tiff_bps == 12) load_flags = 80;
    8208. 

  8208.   } else if (!strcmp(model,"EX1")) {
    8209. 

  8209.     order = 0x4949;
    8210. 

  8210.     height -= 20;
    8211. 

  8211.     top_margin = 2;
    8212. 

  8212.     if ((width -= 6) > 3682) {
    8213. 

  8213.       height -= 10;
    8214. 

  8214.       width  -= 46;
    8215. 

  8215.       top_margin = 8;
    8216. 

  8216.     }
    8217. 

  8217.   } else if (!strcmp(model,"WB2000")) {
    8218. 

  8218.     order = 0x4949;
    8219. 

  8219.     height -= 3;
    8220. 

  8220.     top_margin = 2;
    8221. 

  8221.     if ((width -= 10) > 3718) {
    8222. 

  8222.       height -= 28;
    8223. 

  8223.       width  -= 56;
    8224. 

  8224.       top_margin = 8;
    8225. 

  8225.     }
    8226. 

  8226.   } else if (fsize == 20487168) {
    8227. 

  8227.     height = 2808;
    8228. 

  8228.     width  = 3648;
    8229. 

  8229.     goto wb550;
    8230. 

  8230.   } else if (fsize == 24000000) {
    8231. 

  8231.     height = 3000;
    8232. 

  8232.     width  = 4000;
    8233. 

  8233. wb550:
    8234. 

  8234.     strcpy (model, "WB550");
    8235. 

  8235.     order = 0x4d4d;
    8236. 

  8236.     load_raw = &CLASS unpacked_load_raw;
    8237. 

  8237.     load_flags = 6;
    8238. 

  8238.     maximum = 0x3df;
    8239. 

  8239.   } else if (!strcmp(model,"EX2F")) {
    8240. 

  8240.     height = 3045;
    8241. 

  8241.     width  = 4070;
    8242. 

  8242.     top_margin = 3;
    8243. 

  8243.     order = 0x4949;
    8244. 

  8244.     filters = 0x49494949;
    8245. 

  8245.     load_raw = &CLASS unpacked_load_raw;
    8246. 

  8246.   } else if (!strcmp(model,"STV680 VGA")) {
    8247. 

  8247.     height = 484;
    8248. 

  8248.     width  = 644;
    8249. 

  8249.     load_raw = &CLASS eight_bit_load_raw;
    8250. 

  8250.     flip = 2;
    8251. 

  8251.     filters = 0x16161616;
    8252. 

  8252.     black = 16;
    8253. 

  8253.   }  else
    8254. 

  8254.       identify2(fsize,flen,head); /* Avoid MS VS 2008/2010 bug */
    8255. 

  8255. 

  8256.   if (!model[0])
    8257. 

  8257.     sprintf (model, "%dx%d", width, height);
    8258. 

  8258.   if (filters == UINT_MAX) filters = 0x94949494;
    8259. 

  8259.   if (raw_color) adobe_coeff (make, model);
    8260. 

  8260.   if (load_raw == &CLASS kodak_radc_load_raw)
    8261. 

  8261.     if (raw_color) adobe_coeff ("Apple","Quicktake");
    8262. 

  8262.   if (thumb_offset && !thumb_height) {
    8263. 

  8263.     fseek (ifp, thumb_offset, SEEK_SET);
    8264. 

  8264.     if (ljpeg_start (&jh, 1)) {
    8265. 

  8265.       thumb_width  = jh.wide;
    8266. 

  8266.       thumb_height = jh.high;
    8267. 

  8267.     }
    8268. 

  8268.   }
    8269. 

  8269. dng_skip:
    8270. 

  8270.   if (fuji_width) {
    8271. 

  8271.     fuji_width = width >> !fuji_layout;
    8272. 

  8272.     if (~fuji_width & 1) filters = 0x49494949;
    8273. 

  8273.     width = (height >> fuji_layout) + fuji_width;
    8274. 

  8274.     height = width - 1;
    8275. 

  8275.     pixel_aspect = 1;
    8276. 

  8276.   } else {
    8277. 

  8277.     if (raw_height < height) raw_height = height;
    8278. 

  8278.     if (raw_width  < width ) raw_width  = width;
    8279. 

  8279.   }
    8280. 

  8280.   if (!tiff_bps) tiff_bps = 12;
    8281. 

  8281.   if (!maximum) maximum = (1 << tiff_bps) - 1;
    8282. 

  8282.   if (!load_raw || height < 22) is_raw = 0;
    8283. 

  8283. #ifdef NO_JASPER
    8284. 

  8284.   if (load_raw == &CLASS redcine_load_raw) {
    8285. 

  8285. #ifdef DCRAW_VERBOSE
    8286. 

  8286.     fprintf (stderr,_("%s: You must link dcraw with %s!!\n"),
    8287. 

  8287. 	ifname, "libjasper");
    8288. 

  8288. #endif
    8289. 

  8289.     is_raw = 0;
    8290. 

  8290. #ifdef LIBRAW_LIBRARY_BUILD
    8291. 

  8291.     imgdata.process_warnings |= LIBRAW_WARN_NO_JASPER;
    8292. 

  8292. #endif
    8293. 

  8293.   }
    8294. 

  8294. #endif
    8295. 

  8295. #ifdef NO_JPEG
    8296. 

  8296.   if (load_raw == &CLASS kodak_jpeg_load_raw ||
    8297. 

  8297.       load_raw == &CLASS lossy_dng_load_raw) {
    8298. 

  8298. #ifdef DCRAW_VERBOSE
    8299. 

  8299.     fprintf (stderr,_("%s: You must link dcraw with %s!!\n"),
    8300. 

  8300. 	ifname, "libjpeg");
    8301. 

  8301. #endif
    8302. 

  8302.     is_raw = 0;
    8303. 

  8303. #ifdef LIBRAW_LIBRARY_BUILD
    8304. 

  8304.     imgdata.process_warnings |= LIBRAW_WARN_NO_JPEGLIB;
    8305. 

  8305. #endif
    8306. 

  8306.   }
    8307. 

  8307. #endif
    8308. 

  8308.   if (!cdesc[0])
    8309. 

  8309.     strcpy (cdesc, colors == 3 ? "RGBG":"GMCY");
    8310. 

  8310.   if (!raw_height) raw_height = height;
    8311. 

  8311.   if (!raw_width ) raw_width  = width;
    8312. 

  8312.   if (filters && colors == 3)
    8313. 

  8313.     filters |= ((filters >> 2 & 0x22222222) |
    8314. 

  8314. 		(filters << 2 & 0x88888888)) & filters << 1;
    8315. 

  8315. notraw:
    8316. 

  8316.   if (flip == -1) flip = tiff_flip;
    8317. 

  8317.   if (flip == -1) flip = 0;
    8318. 

  8318. #ifdef LIBRAW_LIBRARY_BUILD
    8319. 

  8319.   RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY,1,2);
    8320. 

  8320. #endif
    8321. 

  8321. }
    8322. 

  8322. 

  8323. void CLASS identify2(unsigned fsize, unsigned flen, char *head)
    8324. 

  8324. {
    8325. 

  8325.   short pana[][6] = {
    8326. 

  8326.     { 3130, 1743,  4,  0, -6,  0 },
    8327. 

  8327.     { 3130, 2055,  4,  0, -6,  0 },
    8328. 

  8328.     { 3130, 2319,  4,  0, -6,  0 },
    8329. 

  8329.     { 3170, 2103, 18,  0,-42, 20 },
    8330. 

  8330.     { 3170, 2367, 18, 13,-42,-21 },
    8331. 

  8331.     { 3177, 2367,  0,  0, -1,  0 },
    8332. 

  8332.     { 3304, 2458,  0,  0, -1,  0 },
    8333. 

  8333.     { 3330, 2463,  9,  0, -5,  0 },
    8334. 

  8334.     { 3330, 2479,  9,  0,-17,  4 },
    8335. 

  8335.     { 3370, 1899, 15,  0,-44, 20 },
    8336. 

  8336.     { 3370, 2235, 15,  0,-44, 20 },
    8337. 

  8337.     { 3370, 2511, 15, 10,-44,-21 },
    8338. 

  8338.     { 3690, 2751,  3,  0, -8, -3 },
    8339. 

  8339.     { 3710, 2751,  0,  0, -3,  0 },
    8340. 

  8340.     { 3724, 2450,  0,  0,  0, -2 },
    8341. 

  8341.     { 3770, 2487, 17,  0,-44, 19 },
    8342. 

  8342.     { 3770, 2799, 17, 15,-44,-19 },
    8343. 

  8343.     { 3880, 2170,  6,  0, -6,  0 },
    8344. 

  8344.     { 4060, 3018,  0,  0,  0, -2 },
    8345. 

  8345.     { 4290, 2391,  3,  0, -8, -1 },
    8346. 

  8346.     { 4330, 2439, 17, 15,-44,-19 },
    8347. 

  8347.     { 4508, 2962,  0,  0, -3, -4 },
    8348. 

  8348.     { 4508, 3330,  0,  0, -3, -6 } };
    8349. 

  8349. 

  8350. 

  8351.   struct jhead jh;
    8352. 

  8352.   int i;
    8353. 

  8353.  if (!strcmp(model,"N95")) {
    8354. 

  8354.     height = raw_height - (top_margin = 2);
    8355. 

  8355.   } else if (!strcmp(model,"531C")) {
    8356. 

  8356.     height = 1200;
    8357. 

  8357.     width  = 1600;
    8358. 

  8358.     load_raw = &CLASS unpacked_load_raw;
    8359. 

  8359.     filters = 0x49494949;
    8360. 

  8360.   } else if (!strcmp(model,"640x480")) {
    8361. 

  8361.     height = 480;
    8362. 

  8362.     width  = 640;
    8363. 

  8363.     load_raw = &CLASS eight_bit_load_raw;
    8364. 

  8364.     gamma_curve (0.45, 4.5, 1, 255);
    8365. 

  8365.   } else if (!strcmp(model,"F-080C")) {
    8366. 

  8366.     height = 768;
    8367. 

  8367.     width  = 1024;
    8368. 

  8368.     load_raw = &CLASS eight_bit_load_raw;
    8369. 

  8369.   } else if (!strcmp(model,"F-145C")) {
    8370. 

  8370.     height = 1040;
    8371. 

  8371.     width  = 1392;
    8372. 

  8372.     load_raw = &CLASS eight_bit_load_raw;
    8373. 

  8373.   } else if (!strcmp(model,"F-201C")) {
    8374. 

  8374.     height = 1200;
    8375. 

  8375.     width  = 1600;
    8376. 

  8376.     load_raw = &CLASS eight_bit_load_raw;
    8377. 

  8377.   } else if (!strcmp(model,"F-510C")) {
    8378. 

  8378.     height = 1958;
    8379. 

  8379.     width  = 2588;
    8380. 

  8380.     load_raw = fsize < 7500000 ?
    8381. 

  8381. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8382. 

  8382.     data_offset = fsize - width*height*(fsize >> 22);
    8383. 

  8383.     maximum = 0xfff0;
    8384. 

  8384.   } else if (!strcmp(model,"F-810C")) {
    8385. 

  8385.     height = 2469;
    8386. 

  8386.     width  = 3272;
    8387. 

  8387.     load_raw = &CLASS unpacked_load_raw;
    8388. 

  8388.     maximum = 0xfff0;
    8389. 

  8389.   } else if (!strcmp(model,"XCD-SX910CR")) {
    8390. 

  8390.     height = 1024;
    8391. 

  8391.     width  = 1375;
    8392. 

  8392.     raw_width = 1376;
    8393. 

  8393.     filters = 0x49494949;
    8394. 

  8394.     maximum = 0x3ff;
    8395. 

  8395.     load_raw = fsize < 2000000 ?
    8396. 

  8396. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8397. 

  8397.   } else if (!strcmp(model,"2010")) {
    8398. 

  8398.     height = 1207;
    8399. 

  8399.     width  = 1608;
    8400. 

  8400.     order = 0x4949;
    8401. 

  8401.     filters = 0x16161616;
    8402. 

  8402.     data_offset = 3212;
    8403. 

  8403.     maximum = 0x3ff;
    8404. 

  8404.     load_raw = &CLASS unpacked_load_raw;
    8405. 

  8405.   } else if (!strcmp(model,"A782")) {
    8406. 

  8406.     height = 3000;
    8407. 

  8407.     width  = 2208;
    8408. 

  8408.     filters = 0x61616161;
    8409. 

  8409.     load_raw = fsize < 10000000 ?
    8410. 

  8410. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8411. 

  8411.     maximum = 0xffc0;
    8412. 

  8412.   } else if (!strcmp(model,"3320AF")) {
    8413. 

  8413.     height = 1536;
    8414. 

  8414.     raw_width = width = 2048;
    8415. 

  8415.     filters = 0x61616161;
    8416. 

  8416.     load_raw = &CLASS unpacked_load_raw;
    8417. 

  8417.     maximum = 0x3ff;
    8418. 

  8418.     fseek (ifp, 0x300000, SEEK_SET);
    8419. 

  8419.     if ((order = guess_byte_order(0x10000)) == 0x4d4d) {
    8420. 

  8420.       height -= (top_margin = 16);
    8421. 

  8421.       width -= (left_margin = 28);
    8422. 

  8422.       maximum = 0xf5c0;
    8423. 

  8423.       strcpy (make, "ISG");
    8424. 

  8424.       model[0] = 0;
    8425. 

  8425.     }
    8426. 

  8426.   } else if (!strcmp(make,"Hasselblad")) {
    8427. 

  8427.     if (load_raw == &CLASS lossless_jpeg_load_raw)
    8428. 

  8428.       load_raw = &CLASS hasselblad_load_raw;
    8429. 

  8429.     if (raw_width == 7262) {
    8430. 

  8430.       height = 5444;
    8431. 

  8431.       width  = 7248;
    8432. 

  8432.       top_margin  = 4;
    8433. 

  8433.       left_margin = 7;
    8434. 

  8434.       filters = 0x61616161;
    8435. 

  8435.     } else if (raw_width == 7410) {
    8436. 

  8436.       height = 5502;
    8437. 

  8437.       width  = 7328;
    8438. 

  8438.       top_margin  = 4;
    8439. 

  8439.       left_margin = 41;
    8440. 

  8440.       filters = 0x61616161;
    8441. 

  8441.     } else if (raw_width == 9044) {
    8442. 

  8442.       height = 6716;
    8443. 

  8443.       width  = 8964;
    8444. 

  8444.       top_margin  = 8;
    8445. 

  8445.       left_margin = 40;
    8446. 

  8446.       black += load_flags = 256;
    8447. 

  8447.       maximum = 0x8101;
    8448. 

  8448.     } else if (raw_width == 4090) {
    8449. 

  8449.       strcpy (model, "V96C");
    8450. 

  8450.       height -= (top_margin = 6);
    8451. 

  8451.       width -= (left_margin = 3) + 7;
    8452. 

  8452.       filters = 0x61616161;
    8453. 

  8453.     }
    8454. 

  8454.   } else if (!strcmp(make,"Sinar")) {
    8455. 

  8455.     if (!memcmp(head,"8BPS",4)) {
    8456. 

  8456.       fseek (ifp, 14, SEEK_SET);
    8457. 

  8457.       height = get4();
    8458. 

  8458.       width  = get4();
    8459. 

  8459.       filters = 0x61616161;
    8460. 

  8460.       data_offset = 68;
    8461. 

  8461.     }
    8462. 

  8462.     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
    8463. 

  8463.     maximum = 0x3fff;
    8464. 

  8464.   } else if (!strcmp(make,"Leaf")) {
    8465. 

  8465.     maximum = 0x3fff;
    8466. 

  8466.     fseek (ifp, data_offset, SEEK_SET);
    8467. 

  8467.     if (ljpeg_start (&jh, 1) && jh.bits == 15)
    8468. 

  8468.       maximum = 0x1fff;
    8469. 

  8469.     if (tiff_samples > 1) filters = 0;
    8470. 

  8470.     if (tiff_samples > 1 || tile_length < raw_height) {
    8471. 

  8471.       load_raw = &CLASS leaf_hdr_load_raw;
    8472. 

  8472.       raw_width = tile_width;
    8473. 

  8473.     }
    8474. 

  8474.     if ((width | height) == 2048) {
    8475. 

  8475.       if (tiff_samples == 1) {
    8476. 

  8476. 	filters = 1;
    8477. 

  8477. 	strcpy (cdesc, "RBTG");
    8478. 

  8478. 	strcpy (model, "CatchLight");
    8479. 

  8479. 	top_margin =  8; left_margin = 18; height = 2032; width = 2016;
    8480. 

  8480.       } else {
    8481. 

  8481. 	strcpy (model, "DCB2");
    8482. 

  8482. 	top_margin = 10; left_margin = 16; height = 2028; width = 2022;
    8483. 

  8483.       }
    8484. 

  8484.     } else if (width+height == 3144+2060) {
    8485. 

  8485.       if (!model[0]) strcpy (model, "Cantare");
    8486. 

  8486.       if (width > height) {
    8487. 

  8487. 	 top_margin = 6; left_margin = 32; height = 2048;  width = 3072;
    8488. 

  8488. 	filters = 0x61616161;
    8489. 

  8489.       } else {
    8490. 

  8490. 	left_margin = 6;  top_margin = 32;  width = 2048; height = 3072;
    8491. 

  8491. 	filters = 0x16161616;
    8492. 

  8492.       }
    8493. 

  8493.       if (!cam_mul[0] || model[0] == 'V') filters = 0;
    8494. 

  8494.       else is_raw = tiff_samples;
    8495. 

  8495.     } else if (width == 2116) {
    8496. 

  8496.       strcpy (model, "Valeo 6");
    8497. 

  8497.       height -= 2 * (top_margin = 30);
    8498. 

  8498.       width -= 2 * (left_margin = 55);
    8499. 

  8499.       filters = 0x49494949;
    8500. 

  8500.     } else if (width == 3171) {
    8501. 

  8501.       strcpy (model, "Valeo 6");
    8502. 

  8502.       height -= 2 * (top_margin = 24);
    8503. 

  8503.       width -= 2 * (left_margin = 24);
    8504. 

  8504.       filters = 0x16161616;
    8505. 

  8505.     }
    8506. 

  8506.   } else if (!strcmp(make,"LEICA") || !strcmp(make,"Panasonic")) {
    8507. 

  8507.     if ((flen - data_offset) / (raw_width*8/7) == raw_height)
    8508. 

  8508.       load_raw = &CLASS panasonic_load_raw;
    8509. 

  8509.     if (!load_raw) {
    8510. 

  8510.       load_raw = &CLASS unpacked_load_raw;
    8511. 

  8511.       load_flags = 4;
    8512. 

  8512.     }
    8513. 

  8513.     zero_is_bad = 1;
    8514. 

  8514.     if ((height += 12) > raw_height) height = raw_height;
    8515. 

  8515.     for (i=0; i < sizeof pana / sizeof *pana; i++)
    8516. 

  8516.       if (raw_width == pana[i][0] && raw_height == pana[i][1]) {
    8517. 

  8517. 	left_margin = pana[i][2];
    8518. 

  8518. 	 top_margin = pana[i][3];
    8519. 

  8519. 	     width += pana[i][4];
    8520. 

  8520. 	    height += pana[i][5];
    8521. 

  8521.       }
    8522. 

  8522.     filters = 0x01010101 * (uchar) "\x94\x61\x49\x16"
    8523. 

  8523. 	[((filters-1) ^ (left_margin & 1) ^ (top_margin << 1)) & 3];
    8524. 

  8524.   } else if (!strcmp(model,"C770UZ")) {
    8525. 

  8525.     height = 1718;
    8526. 

  8526.     width  = 2304;
    8527. 

  8527.     filters = 0x16161616;
    8528. 

  8528.     load_raw = &CLASS packed_load_raw;
    8529. 

  8529.     load_flags = 30;
    8530. 

  8530.   } else if (!strcmp(make,"OLYMPUS")) {
    8531. 

  8531.     height += height & 1;
    8532. 

  8532.     filters = exif_cfa;
    8533. 

  8533.     if (width == 4100) width -= 4;
    8534. 

  8534.     if (width == 4080) width -= 24;
    8535. 

  8535.     if (load_raw == &CLASS unpacked_load_raw)
    8536. 

  8536.       load_flags = 4;
    8537. 

  8537.     tiff_bps = 12;
    8538. 

  8538.     if (!strcmp(model,"E-300") ||
    8539. 

  8539. 	!strcmp(model,"E-500")) {
    8540. 

  8540.       width -= 20;
    8541. 

  8541.       if (load_raw == &CLASS unpacked_load_raw) {
    8542. 

  8542. 	maximum = 0xfc3;
    8543. 

  8543. 	memset (cblack, 0, sizeof cblack);
    8544. 

  8544.       }
    8545. 

  8545.     } else if (!strcmp(model,"E-330")) {
    8546. 

  8546.       width -= 30;
    8547. 

  8547.       if (load_raw == &CLASS unpacked_load_raw)
    8548. 

  8548. 	maximum = 0xf79;
    8549. 

  8549.     } else if (!strcmp(model,"SP550UZ")) {
    8550. 

  8550.       thumb_length = flen - (thumb_offset = 0xa39800);
    8551. 

  8551.       thumb_height = 480;
    8552. 

  8552.       thumb_width  = 640;
    8553. 

  8553.     } else if (!strcmp(model,"XZ-2")) {
    8554. 

  8554.       load_raw = &CLASS packed_load_raw;
    8555. 

  8555.       load_flags = 24;
    8556. 

  8556.     }
    8557. 

  8557.   } else if (!strcmp(model,"N Digital")) {
    8558. 

  8558.     height = 2047;
    8559. 

  8559.     width  = 3072;
    8560. 

  8560.     filters = 0x61616161;
    8561. 

  8561.     data_offset = 0x1a00;
    8562. 

  8562.     load_raw = &CLASS packed_load_raw;
    8563. 

  8563.   } else if (!strcmp(model,"DSC-F828")) {
    8564. 

  8564.     width = 3288;
    8565. 

  8565.     left_margin = 5;
    8566. 

  8566.     mask[1][3] = -17;
    8567. 

  8567.     data_offset = 862144;
    8568. 

  8568.     load_raw = &CLASS sony_load_raw;
    8569. 

  8569.     filters = 0x9c9c9c9c;
    8570. 

  8570.     colors = 4;
    8571. 

  8571.     strcpy (cdesc, "RGBE");
    8572. 

  8572.   } else if (!strcmp(model,"DSC-V3")) {
    8573. 

  8573.     width = 3109;
    8574. 

  8574.     left_margin = 59;
    8575. 

  8575.     mask[0][1] = 9;
    8576. 

  8576.     data_offset = 787392;
    8577. 

  8577.     load_raw = &CLASS sony_load_raw;
    8578. 

  8578.   } else if (!strcmp(make,"SONY") && raw_width == 3984) {
    8579. 

  8579.     adobe_coeff ("SONY","DSC-R1");
    8580. 

  8580.     width = 3925;
    8581. 

  8581.     order = 0x4d4d;
    8582. 

  8582.   } else if (!strcmp(make,"SONY") && raw_width == 5504) {
    8583. 

  8583.     width -= 8;
    8584. 

  8584.   } else if (!strcmp(make,"SONY") && raw_width == 6048) {
    8585. 

  8585.     width -= 24;
    8586. 

  8586.   } else if (!strcmp(model,"DSLR-A100")) {
    8587. 

  8587.     if (width == 3880) {
    8588. 

  8588.       height--;
    8589. 

  8589.       width = ++raw_width;
    8590. 

  8590.     } else {
    8591. 

  8591.       order = 0x4d4d;
    8592. 

  8592.       load_flags = 2;
    8593. 

  8593.     }
    8594. 

  8594.     filters = 0x61616161;
    8595. 

  8595.   } else if (!strcmp(model,"DSLR-A350")) {
    8596. 

  8596.     height -= 4;
    8597. 

  8597.   } else if (!strcmp(model,"PIXL")) {
    8598. 

  8598.     height -= top_margin = 4;
    8599. 

  8599.     width -= left_margin = 32;
    8600. 

  8600.     gamma_curve (0, 7, 1, 255);
    8601. 

  8601.   } else if (!strcmp(model,"C603v")) {
    8602. 

  8602.     height = 480;
    8603. 

  8603.     width  = 640;
    8604. 

  8604.     if (fsize < 614400 || find_green (16, 16, 3840, 5120) < 25) goto c603v;
    8605. 

  8605.     strcpy (model,"KAI-0340");
    8606. 

  8606.     height -= 3;
    8607. 

  8607.     data_offset = 3840;
    8608. 

  8608.     order = 0x4949;
    8609. 

  8609.     load_raw = &CLASS unpacked_load_raw;
    8610. 

  8610.   } else if (!strcmp(model,"C603y")) {
    8611. 

  8611.     height = 2134;
    8612. 

  8612.     width  = 2848;
    8613. 

  8613. c603v:
    8614. 

  8614.     filters = 0;
    8615. 

  8615.     load_raw = &CLASS kodak_yrgb_load_raw;
    8616. 

  8616.     gamma_curve (0, 3.875, 1, 255);
    8617. 

  8617.   } else if (!strcmp(model,"C603")) {
    8618. 

  8618.     raw_height = height = 2152;
    8619. 

  8619.     raw_width  = width  = 2864;
    8620. 

  8620.     goto c603;
    8621. 

  8621.   } else if (!strcmp(model,"C330")) {
    8622. 

  8622.     height = 1744;
    8623. 

  8623.     width  = 2336;
    8624. 

  8624.     raw_height = 1779;
    8625. 

  8625.     raw_width  = 2338;
    8626. 

  8626.     top_margin = 33;
    8627. 

  8627.     left_margin = 1;
    8628. 

  8628. c603:
    8629. 

  8629.     order = 0x4949;
    8630. 

  8630.     if ((data_offset = fsize - raw_height*raw_width)) {
    8631. 

  8631.       fseek (ifp, 168, SEEK_SET);
    8632. 

  8632.       read_shorts (curve, 256);
    8633. 

  8633.     } else gamma_curve (0, 3.875, 1, 255);
    8634. 

  8634.     load_raw = &CLASS eight_bit_load_raw;
    8635. 

  8635.   } else if (!strncasecmp(model,"EasyShare",9)) {
    8636. 

  8636.     data_offset = data_offset < 0x15000 ? 0x15000 : 0x17000;
    8637. 

  8637.     load_raw = &CLASS packed_load_raw;
    8638. 

  8638.   } else if (!strcasecmp(make,"KODAK")) {
    8639. 

  8639.     if (filters == UINT_MAX) filters = 0x61616161;
    8640. 

  8640.     if (!strncmp(model,"NC2000",6)) {
    8641. 

  8641.       width -= 4;
    8642. 

  8642.       left_margin = 2;
    8643. 

  8643.     } else if (!strcmp(model,"EOSDCS3B")) {
    8644. 

  8644.       width -= 4;
    8645. 

  8645.       left_margin = 2;
    8646. 

  8646.     } else if (!strcmp(model,"EOSDCS1")) {
    8647. 

  8647.       width -= 4;
    8648. 

  8648.       left_margin = 2;
    8649. 

  8649.     } else if (!strcmp(model,"DCS420")) {
    8650. 

  8650.       width -= 4;
    8651. 

  8651.       left_margin = 2;
    8652. 

  8652.     } else if (!strncmp(model,"DCS460 ",7)) {
    8653. 

  8653.       model[6] = 0;
    8654. 

  8654.       width -= 4;
    8655. 

  8655.       left_margin = 2;
    8656. 

  8656.     } else if (!strcmp(model,"DCS460A")) {
    8657. 

  8657.       width -= 4;
    8658. 

  8658.       left_margin = 2;
    8659. 

  8659.       colors = 1;
    8660. 

  8660.       filters = 0;
    8661. 

  8661.     } else if (!strcmp(model,"DCS660M")) {
    8662. 

  8662.       black = 214;
    8663. 

  8663.       colors = 1;
    8664. 

  8664.       filters = 0;
    8665. 

  8665.     } else if (!strcmp(model,"DCS760M")) {
    8666. 

  8666.       colors = 1;
    8667. 

  8667.       filters = 0;
    8668. 

  8668.     }
    8669. 

  8669.     if (!strcmp(model+4,"20X"))
    8670. 

  8670.       strcpy (cdesc, "MYCY");
    8671. 

  8671.     if (strstr(model,"DC25")) {
    8672. 

  8672.       strcpy (model, "DC25");
    8673. 

  8673.       data_offset = 15424;
    8674. 

  8674.     }
    8675. 

  8675.     if (!strncmp(model,"DC2",3)) {
    8676. 

  8676.       raw_height = height = 242;
    8677. 

  8677.       if (flen < 100000) {
    8678. 

  8678. 	raw_width = 256; width = 249;
    8679. 

  8679. 	pixel_aspect = (4.0*height) / (3.0*width);
    8680. 

  8680.       } else {
    8681. 

  8681. 	raw_width = 512; width = 501;
    8682. 

  8682. 	pixel_aspect = (493.0*height) / (373.0*width);
    8683. 

  8683.       }
    8684. 

  8684.       data_offset += raw_width + 1;
    8685. 

  8685.       colors = 4;
    8686. 

  8686.       filters = 0x8d8d8d8d;
    8687. 

  8687.       simple_coeff(1);
    8688. 

  8688.       pre_mul[1] = 1.179;
    8689. 

  8689.       pre_mul[2] = 1.209;
    8690. 

  8690.       pre_mul[3] = 1.036;
    8691. 

  8691.       load_raw = &CLASS eight_bit_load_raw;
    8692. 

  8692.     } else if (!strcmp(model,"40")) {
    8693. 

  8693.       strcpy (model, "DC40");
    8694. 

  8694.       height = 512;
    8695. 

  8695.       width  = 768;
    8696. 

  8696.       data_offset = 1152;
    8697. 

  8697.       load_raw = &CLASS kodak_radc_load_raw;
    8698. 

  8698.     } else if (strstr(model,"DC50")) {
    8699. 

  8699.       strcpy (model, "DC50");
    8700. 

  8700.       height = 512;
    8701. 

  8701.       width  = 768;
    8702. 

  8702.       data_offset = 19712;
    8703. 

  8703.       load_raw = &CLASS kodak_radc_load_raw;
    8704. 

  8704.     } else if (strstr(model,"DC120")) {
    8705. 

  8705.       strcpy (model, "DC120");
    8706. 

  8706.       height = 976;
    8707. 

  8707.       width  = 848;
    8708. 

  8708.       pixel_aspect = height/0.75/width;
    8709. 

  8709.       load_raw = tiff_compress == 7 ?
    8710. 

  8710. 	&CLASS kodak_jpeg_load_raw : &CLASS kodak_dc120_load_raw;
    8711. 

  8711.     } else if (!strcmp(model,"DCS200")) {
    8712. 

  8712.       thumb_height = 128;
    8713. 

  8713.       thumb_width  = 192;
    8714. 

  8714.       thumb_offset = 6144;
    8715. 

  8715.       thumb_misc   = 360;
    8716. 

  8716.       write_thumb = &CLASS layer_thumb;
    8717. 

  8717.       height = 1024;
    8718. 

  8718.       width  = 1536;
    8719. 

  8719.       data_offset = 79872;
    8720. 

  8720.       load_raw = &CLASS eight_bit_load_raw;
    8721. 

  8721.       black = 17;
    8722. 

  8722.     }
    8723. 

  8723.   } else if (!strcmp(model,"Fotoman Pixtura")) {
    8724. 

  8724.     height = 512;
    8725. 

  8725.     width  = 768;
    8726. 

  8726.     data_offset = 3632;
    8727. 

  8727.     load_raw = &CLASS kodak_radc_load_raw;
    8728. 

  8728.     filters = 0x61616161;
    8729. 

  8729.     simple_coeff(2);
    8730. 

  8730.   } else if (!strncmp(model,"QuickTake",9)) {
    8731. 

  8731.     if (head[5]) strcpy (model+10, "200");
    8732. 

  8732.     fseek (ifp, 544, SEEK_SET);
    8733. 

  8733.     height = get2();
    8734. 

  8734.     width  = get2();
    8735. 

  8735.     data_offset = (get4(),get2()) == 30 ? 738:736;
    8736. 

  8736.     if (height > width) {
    8737. 

  8737.       SWAP(height,width);
    8738. 

  8738.       fseek (ifp, data_offset-6, SEEK_SET);
    8739. 

  8739.       flip = ~get2() & 3 ? 5:6;
    8740. 

  8740.     }
    8741. 

  8741.     filters = 0x61616161;
    8742. 

  8742.   } else if (!strcmp(make,"Rollei") && !load_raw) {
    8743. 

  8743.     switch (raw_width) {
    8744. 

  8744.       case 1316:
    8745. 

  8745. 	height = 1030;
    8746. 

  8746. 	width  = 1300;
    8747. 

  8747. 	top_margin  = 1;
    8748. 

  8748. 	left_margin = 6;
    8749. 

  8749. 	break;
    8750. 

  8750.       case 2568:
    8751. 

  8751. 	height = 1960;
    8752. 

  8752. 	width  = 2560;
    8753. 

  8753. 	top_margin  = 2;
    8754. 

  8754. 	left_margin = 8;
    8755. 

  8755.     }
    8756. 

  8756.     filters = 0x16161616;
    8757. 

  8757.     load_raw = &CLASS rollei_load_raw;
    8758. 

  8758.   } else if (!strcmp(model,"PC-CAM 600")) {
    8759. 

  8759.     height = 768;
    8760. 

  8760.     data_offset = width = 1024;
    8761. 

  8761.     filters = 0x49494949;
    8762. 

  8762.     load_raw = &CLASS eight_bit_load_raw;
    8763. 

  8763.   } else if (!strcmp(model,"QV-2000UX")) {
    8764. 

  8764.     height = 1208;
    8765. 

  8765.     width  = 1632;
    8766. 

  8766.     data_offset = width * 2;
    8767. 

  8767.     load_raw = &CLASS eight_bit_load_raw;
    8768. 

  8768.   } else if (fsize == 3217760) {
    8769. 

  8769.     height = 1546;
    8770. 

  8770.     width  = 2070;
    8771. 

  8771.     raw_width = 2080;
    8772. 

  8772.     load_raw = &CLASS eight_bit_load_raw;
    8773. 

  8773.   } else if (!strcmp(model,"QV-4000")) {
    8774. 

  8774.     height = 1700;
    8775. 

  8775.     width  = 2260;
    8776. 

  8776.     load_raw = &CLASS unpacked_load_raw;
    8777. 

  8777.     maximum = 0xffff;
    8778. 

  8778.   } else if (!strcmp(model,"QV-5700")) {
    8779. 

  8779.     height = 1924;
    8780. 

  8780.     width  = 2576;
    8781. 

  8781.     raw_width = 3232;
    8782. 

  8782.     tiff_bps = 10;
    8783. 

  8783.   } else if (!strcmp(model,"QV-R41")) {
    8784. 

  8784.     height = 1720;
    8785. 

  8785.     width  = 2312;
    8786. 

  8786.     raw_width = 3520;
    8787. 

  8787.     left_margin = 2;
    8788. 

  8788.   } else if (!strcmp(model,"QV-R51")) {
    8789. 

  8789.     height = 1926;
    8790. 

  8790.     width  = 2580;
    8791. 

  8791.     raw_width = 3904;
    8792. 

  8792.   } else if (!strcmp(model,"EX-S20")) {
    8793. 

  8793.     height = 1208;
    8794. 

  8794.     width  = 1620;
    8795. 

  8795.     raw_width = 2432;
    8796. 

  8796.     flip = 3;
    8797. 

  8797.   } else if (!strcmp(model,"EX-S100")) {
    8798. 

  8798.     height = 1544;
    8799. 

  8799.     width  = 2058;
    8800. 

  8800.     raw_width = 3136;
    8801. 

  8801.   } else if (!strcmp(model,"EX-Z50")) {
    8802. 

  8802.     height = 1931;
    8803. 

  8803.     width  = 2570;
    8804. 

  8804.     raw_width = 3904;
    8805. 

  8805.   } else if (!strcmp(model,"EX-Z500")) {
    8806. 

  8806.     height = 1937;
    8807. 

  8807.     width  = 2577;
    8808. 

  8808.     raw_width = 3904;
    8809. 

  8809.     filters = 0x16161616;
    8810. 

  8810.   } else if (!strcmp(model,"EX-Z55")) {
    8811. 

  8811.     height = 1960;
    8812. 

  8812.     width  = 2570;
    8813. 

  8813.     raw_width = 3904;
    8814. 

  8814.   } else if (!strcmp(model,"EX-Z60")) {
    8815. 

  8815.     height = 2145;
    8816. 

  8816.     width  = 2833;
    8817. 

  8817.     raw_width = 3584;
    8818. 

  8818.     filters = 0x16161616;
    8819. 

  8819.     tiff_bps = 10;
    8820. 

  8820.   } else if (!strcmp(model,"EX-Z75")) {
    8821. 

  8821.     height = 2321;
    8822. 

  8822.     width  = 3089;
    8823. 

  8823.     raw_width = 4672;
    8824. 

  8824.     maximum = 0xfff;
    8825. 

  8825.   } else if (!strcmp(model,"EX-Z750")) {
    8826. 

  8826.     height = 2319;
    8827. 

  8827.     width  = 3087;
    8828. 

  8828.     raw_width = 4672;
    8829. 

  8829.     maximum = 0xfff;
    8830. 

  8830.   } else if (!strcmp(model,"EX-Z850")) {
    8831. 

  8831.     height = 2468;
    8832. 

  8832.     width  = 3279;
    8833. 

  8833.     raw_width = 4928;
    8834. 

  8834.     maximum = 0xfff;
    8835. 

  8835.   } else if (!strcmp(model,"EX-Z8")) {
    8836. 

  8836.     height = 2467;
    8837. 

  8837.     width  = 3281;
    8838. 

  8838.     raw_height = 2502;
    8839. 

  8839.     raw_width  = 4992;
    8840. 

  8840.     maximum = 0xfff;
    8841. 

  8841.   } else if (fsize == 15499264) {	/* EX-Z1050 or EX-Z1080 */
    8842. 

  8842.     height = 2752;
    8843. 

  8843.     width  = 3672;
    8844. 

  8844.     raw_width = 5632;
    8845. 

  8845.   } else if (!strcmp(model,"EX-ZR100")) {
    8846. 

  8846.     height = 3044;
    8847. 

  8847.     width  = 4072;
    8848. 

  8848.     raw_width = 4096;
    8849. 

  8849.     load_flags = 80;
    8850. 

  8850.   } else if (!strcmp(model,"EX-P505")) {
    8851. 

  8851.     height = 1928;
    8852. 

  8852.     width  = 2568;
    8853. 

  8853.     raw_width = 3852;
    8854. 

  8854.     maximum = 0xfff;
    8855. 

  8855.   } else if (fsize == 9313536) {	/* EX-P600 or QV-R61 */
    8856. 

  8856.     height = 2142;
    8857. 

  8857.     width  = 2844;
    8858. 

  8858.     raw_width = 4288;
    8859. 

  8859.   } else if (!strcmp(model,"EX-P700")) {
    8860. 

  8860.     height = 2318;
    8861. 

  8861.     width  = 3082;
    8862. 

  8862.     raw_width = 4672;
    8863. 

  8863.   }
    8864. 

  8864.   else if (!strcmp(model,"GRAS-50S5C")) {
    8865. 

  8865.    height = 2048;
    8866. 

  8866.    width = 2440;
    8867. 

  8867.    load_raw = &CLASS unpacked_load_raw;
    8868. 

  8868.    data_offset = 0;
    8869. 

  8869.    filters = 0x49494949;
    8870. 

  8870.    order = 0x4949;
    8871. 

  8871.    maximum = 0xfffC;
    8872. 

  8872.   } else if (!strcmp(model,"BB-500CL")) {
    8873. 

  8873.    height = 2058;
    8874. 

  8874.    width = 2448;
    8875. 

  8875.    load_raw = &CLASS unpacked_load_raw;
    8876. 

  8876.    data_offset = 0;
    8877. 

  8877.    filters = 0x94949494;
    8878. 

  8878.    order = 0x4949;
    8879. 

  8879.    maximum = 0x3fff;
    8880. 

  8880.   } else if (!strcmp(model,"BB-500GE")) {
    8881. 

  8881.    height = 2058;
    8882. 

  8882.    width = 2456;
    8883. 

  8883.    load_raw = &CLASS unpacked_load_raw;
    8884. 

  8884.    data_offset = 0;
    8885. 

  8885.    filters = 0x94949494;
    8886. 

  8886.    order = 0x4949;
    8887. 

  8887.    maximum = 0x3fff;
    8888. 

  8888.   } else if (!strcmp(model,"SVS625CL")) {
    8889. 

  8889.    height = 2050;
    8890. 

  8890.    width = 2448;
    8891. 

  8891.    load_raw = &CLASS unpacked_load_raw;
    8892. 

  8892.    data_offset = 0;
    8893. 

  8893.    filters = 0x94949494;
    8894. 

  8894.    order = 0x4949;
    8895. 

  8895.    maximum = 0x0fff;
    8896. 

  8896.   }
    8897. 

  8897. }
    8898. 

  8898. 

  8899. 

  8900. #line 10147 "dcraw/dcraw.c"
    8901. 

  8901. void CLASS convert_to_rgb()
    8902. 

  8902. {
    8903. 

  8903. #ifndef LIBRAW_LIBRARY_BUILD
    8904. 

  8904.   int row, col, c;
    8905. 

  8905. #endif
    8906. 

  8906.   int  i, j, k;
    8907. 

  8907. #ifndef LIBRAW_LIBRARY_BUILD
    8908. 

  8908.   ushort *img;
    8909. 

  8909.   float out[3];
    8910. 

  8910. #endif
    8911. 

  8911.   float out_cam[3][4];
    8912. 

  8912.   double num, inverse[3][3];
    8913. 

  8913.   static const double xyzd50_srgb[3][3] =
    8914. 

  8914.   { { 0.436083, 0.385083, 0.143055 },
    8915. 

  8915.     { 0.222507, 0.716888, 0.060608 },
    8916. 

  8916.     { 0.013930, 0.097097, 0.714022 } };
    8917. 

  8917.   static const double rgb_rgb[3][3] =
    8918. 

  8918.   { { 1,0,0 }, { 0,1,0 }, { 0,0,1 } };
    8919. 

  8919.   static const double adobe_rgb[3][3] =
    8920. 

  8920.   { { 0.715146, 0.284856, 0.000000 },
    8921. 

  8921.     { 0.000000, 1.000000, 0.000000 },
    8922. 

  8922.     { 0.000000, 0.041166, 0.958839 } };
    8923. 

  8923.   static const double wide_rgb[3][3] =
    8924. 

  8924.   { { 0.593087, 0.404710, 0.002206 },
    8925. 

  8925.     { 0.095413, 0.843149, 0.061439 },
    8926. 

  8926.     { 0.011621, 0.069091, 0.919288 } };
    8927. 

  8927.   static const double prophoto_rgb[3][3] =
    8928. 

  8928.   { { 0.529317, 0.330092, 0.140588 },
    8929. 

  8929.     { 0.098368, 0.873465, 0.028169 },
    8930. 

  8930.     { 0.016879, 0.117663, 0.865457 } };
    8931. 

  8931.   static const double (*out_rgb[])[3] =
    8932. 

  8932.   { rgb_rgb, adobe_rgb, wide_rgb, prophoto_rgb, xyz_rgb };
    8933. 

  8933.   static const char *name[] =
    8934. 

  8934.   { "sRGB", "Adobe RGB (1998)", "WideGamut D65", "ProPhoto D65", "XYZ" };
    8935. 

  8935.   static const unsigned phead[] =
    8936. 

  8936.   { 1024, 0, 0x2100000, 0x6d6e7472, 0x52474220, 0x58595a20, 0, 0, 0,
    8937. 

  8937.     0x61637370, 0, 0, 0x6e6f6e65, 0, 0, 0, 0, 0xf6d6, 0x10000, 0xd32d };
    8938. 

  8938.   unsigned pbody[] =
    8939. 

  8939.   { 10, 0x63707274, 0, 36,	/* cprt */
    8940. 

  8940. 	0x64657363, 0, 40,	/* desc */
    8941. 

  8941. 	0x77747074, 0, 20,	/* wtpt */
    8942. 

  8942. 	0x626b7074, 0, 20,	/* bkpt */
    8943. 

  8943. 	0x72545243, 0, 14,	/* rTRC */
    8944. 

  8944. 	0x67545243, 0, 14,	/* gTRC */
    8945. 

  8945. 	0x62545243, 0, 14,	/* bTRC */
    8946. 

  8946. 	0x7258595a, 0, 20,	/* rXYZ */
    8947. 

  8947. 	0x6758595a, 0, 20,	/* gXYZ */
    8948. 

  8948. 	0x6258595a, 0, 20 };	/* bXYZ */
    8949. 

  8949.   static const unsigned pwhite[] = { 0xf351, 0x10000, 0x116cc };
    8950. 

  8950.   unsigned pcurve[] = { 0x63757276, 0, 1, 0x1000000 };
    8951. 

  8951. 

  8952. #ifdef LIBRAW_LIBRARY_BUILD
    8953. 

  8953.   RUN_CALLBACK(LIBRAW_PROGRESS_CONVERT_RGB,0,2);
    8954. 

  8954. #endif
    8955. 

  8955.   gamma_curve (gamm[0], gamm[1], 0, 0);
    8956. 

  8956.   memcpy (out_cam, rgb_cam, sizeof out_cam);
    8957. 

  8957. #ifndef LIBRAW_LIBRARY_BUILD
    8958. 

  8958.   raw_color |= colors == 1 || document_mode ||
    8959. 

  8959. 		output_color < 1 || output_color > 5;
    8960. 

  8960. #else
    8961. 

  8961.   raw_color |= colors == 1 || 
    8962. 

  8962. 		output_color < 1 || output_color > 5;
    8963. 

  8963. #endif
    8964. 

  8964.   if (!raw_color) {
    8965. 

  8965.     oprof = (unsigned *) calloc (phead[0], 1);
    8966. 

  8966.     merror (oprof, "convert_to_rgb()");
    8967. 

  8967.     memcpy (oprof, phead, sizeof phead);
    8968. 

  8968.     if (output_color == 5) oprof[4] = oprof[5];
    8969. 

  8969.     oprof[0] = 132 + 12*pbody[0];
    8970. 

  8970.     for (i=0; i < pbody[0]; i++) {
    8971. 

  8971.       oprof[oprof[0]/4] = i ? (i > 1 ? 0x58595a20 : 0x64657363) : 0x74657874;
    8972. 

  8972.       pbody[i*3+2] = oprof[0];
    8973. 

  8973.       oprof[0] += (pbody[i*3+3] + 3) & -4;
    8974. 

  8974.     }
    8975. 

  8975.     memcpy (oprof+32, pbody, sizeof pbody);
    8976. 

  8976.     oprof[pbody[5]/4+2] = strlen(name[output_color-1]) + 1;
    8977. 

  8977.     memcpy ((char *)oprof+pbody[8]+8, pwhite, sizeof pwhite);
    8978. 

  8978.     pcurve[3] = (short)(256/gamm[5]+0.5) << 16;
    8979. 

  8979.     for (i=4; i < 7; i++)
    8980. 

  8980.       memcpy ((char *)oprof+pbody[i*3+2], pcurve, sizeof pcurve);
    8981. 

  8981.     pseudoinverse ((double (*)[3]) out_rgb[output_color-1], inverse, 3);
    8982. 

  8982.     for (i=0; i < 3; i++)
    8983. 

  8983.       for (j=0; j < 3; j++) {
    8984. 

  8984. 	for (num = k=0; k < 3; k++)
    8985. 

  8985. 	  num += xyzd50_srgb[i][k] * inverse[j][k];
    8986. 

  8986. 	oprof[pbody[j*3+23]/4+i+2] = num * 0x10000 + 0.5;
    8987. 

  8987.       }
    8988. 

  8988.     for (i=0; i < phead[0]/4; i++)
    8989. 

  8989.       oprof[i] = htonl(oprof[i]);
    8990. 

  8990.     strcpy ((char *)oprof+pbody[2]+8, "auto-generated by dcraw");
    8991. 

  8991.     strcpy ((char *)oprof+pbody[5]+12, name[output_color-1]);
    8992. 

  8992.     for (i=0; i < 3; i++)
    8993. 

  8993.       for (j=0; j < colors; j++)
    8994. 

  8994. 	for (out_cam[i][j] = k=0; k < 3; k++)
    8995. 

  8995. 	  out_cam[i][j] += out_rgb[output_color-1][i][k] * rgb_cam[k][j];
    8996. 

  8996.   }
    8997. 

  8997. #ifdef DCRAW_VERBOSE
    8998. 

  8998.   if (verbose)
    8999. 

  8999.     fprintf (stderr, raw_color ? _("Building histograms...\n") :
    9000. 

  9000. 	_("Converting to %s colorspace...\n"), name[output_color-1]);
    9001. 

  9001. #endif
    9002. 

  9002. #ifdef LIBRAW_LIBRARY_BUILD
    9003. 

  9003.   convert_to_rgb_loop(out_cam);
    9004. 

  9004. #else
    9005. 

  9005.   memset (histogram, 0, sizeof histogram);
    9006. 

  9006.   for (img=image[0], row=0; row < height; row++)
    9007. 

  9007.     for (col=0; col < width; col++, img+=4) {
    9008. 

  9008.       if (!raw_color) {
    9009. 

  9009. 	out[0] = out[1] = out[2] = 0;
    9010. 

  9010. 	FORCC {
    9011. 

  9011. 	  out[0] += out_cam[0][c] * img[c];
    9012. 

  9012. 	  out[1] += out_cam[1][c] * img[c];
    9013. 

  9013. 	  out[2] += out_cam[2][c] * img[c];
    9014. 

  9014. 	}
    9015. 

  9015. 	FORC3 img[c] = CLIP((int) out[c]);
    9016. 

  9016.       }
    9017. 

  9017.       else if (document_mode)
    9018. 

  9018. 	img[0] = img[fcol(row,col)];
    9019. 

  9019.       FORCC histogram[c][img[c] >> 3]++;
    9020. 

  9020.     }
    9021. 

  9021. #endif
    9022. 

  9022.   if (colors == 4 && output_color) colors = 3;
    9023. 

  9023. #ifndef LIBRAW_LIBRARY_BUILD
    9024. 

  9024.   if (document_mode && filters) colors = 1;
    9025. 

  9025. #endif
    9026. 

  9026. #ifdef LIBRAW_LIBRARY_BUILD
    9027. 

  9027.   RUN_CALLBACK(LIBRAW_PROGRESS_CONVERT_RGB,1,2);
    9028. 

  9028. #endif
    9029. 

  9029. }
    9030. 

  9030. 

  9031. void CLASS fuji_rotate()
    9032. 

  9032. {
    9033. 

  9033.   int i, row, col;
    9034. 

  9034.   double step;
    9035. 

  9035.   float r, c, fr, fc;
    9036. 

  9036.   unsigned ur, uc;
    9037. 

  9037.   ushort wide, high, (*img)[4], (*pix)[4];
    9038. 

  9038. 

  9039.   if (!fuji_width) return;
    9040. 

  9040. #ifdef DCRAW_VERBOSE
    9041. 

  9041.   if (verbose)
    9042. 

  9042.     fprintf (stderr,_("Rotating image 45 degrees...\n"));
    9043. 

  9043. #endif
    9044. 

  9044.   fuji_width = (fuji_width - 1 + shrink) >> shrink;
    9045. 

  9045.   step = sqrt(0.5);
    9046. 

  9046.   wide = fuji_width / step;
    9047. 

  9047.   high = (height - fuji_width) / step;
    9048. 

  9048.   img = (ushort (*)[4]) calloc (wide*high, sizeof *img);
    9049. 

  9049.   merror (img, "fuji_rotate()");
    9050. 

  9050. 

  9051. #ifdef LIBRAW_LIBRARY_BUILD
    9052. 

  9052.   RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE,0,2);
    9053. 

  9053. #endif
    9054. 

  9054. 

  9055.   for (row=0; row < high; row++)
    9056. 

  9056.     for (col=0; col < wide; col++) {
    9057. 

  9057.       ur = r = fuji_width + (row-col)*step;
    9058. 

  9058.       uc = c = (row+col)*step;
    9059. 

  9059.       if (ur > height-2 || uc > width-2) continue;
    9060. 

  9060.       fr = r - ur;
    9061. 

  9061.       fc = c - uc;
    9062. 

  9062.       pix = image + ur*width + uc;
    9063. 

  9063.       for (i=0; i < colors; i++)
    9064. 

  9064. 	img[row*wide+col][i] =
    9065. 

  9065. 	  (pix[    0][i]*(1-fc) + pix[      1][i]*fc) * (1-fr) +
    9066. 

  9066. 	  (pix[width][i]*(1-fc) + pix[width+1][i]*fc) * fr;
    9067. 

  9067.     }
    9068. 

  9068. 

  9069.   free (image);
    9070. 

  9070.   width  = wide;
    9071. 

  9071.   height = high;
    9072. 

  9072.   image  = img;
    9073. 

  9073.   fuji_width = 0;
    9074. 

  9074. #ifdef LIBRAW_LIBRARY_BUILD
    9075. 

  9075.   RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE,1,2);
    9076. 

  9076. #endif
    9077. 

  9077. }
    9078. 

  9078. 

  9079. void CLASS stretch()
    9080. 

  9080. {
    9081. 

  9081.   ushort newdim, (*img)[4], *pix0, *pix1;
    9082. 

  9082.   int row, col, c;
    9083. 

  9083.   double rc, frac;
    9084. 

  9084. 

  9085.   if (pixel_aspect == 1) return;
    9086. 

  9086. #ifdef LIBRAW_LIBRARY_BUILD
    9087. 

  9087.   RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH,0,2);
    9088. 

  9088. #endif
    9089. 

  9089. #ifdef DCRAW_VERBOSE
    9090. 

  9090.   if (verbose) fprintf (stderr,_("Stretching the image...\n"));
    9091. 

  9091. #endif
    9092. 

  9092.   if (pixel_aspect < 1) {
    9093. 

  9093.     newdim = height / pixel_aspect + 0.5;
    9094. 

  9094.     img = (ushort (*)[4]) calloc (width*newdim, sizeof *img);
    9095. 

  9095.     merror (img, "stretch()");
    9096. 

  9096.     for (rc=row=0; row < newdim; row++, rc+=pixel_aspect) {
    9097. 

  9097.       frac = rc - (c = rc);
    9098. 

  9098.       pix0 = pix1 = image[c*width];
    9099. 

  9099.       if (c+1 < height) pix1 += width*4;
    9100. 

  9100.       for (col=0; col < width; col++, pix0+=4, pix1+=4)
    9101. 

  9101. 	FORCC img[row*width+col][c] = pix0[c]*(1-frac) + pix1[c]*frac + 0.5;
    9102. 

  9102.     }
    9103. 

  9103.     height = newdim;
    9104. 

  9104.   } else {
    9105. 

  9105.     newdim = width * pixel_aspect + 0.5;
    9106. 

  9106.     img = (ushort (*)[4]) calloc (height*newdim, sizeof *img);
    9107. 

  9107.     merror (img, "stretch()");
    9108. 

  9108.     for (rc=col=0; col < newdim; col++, rc+=1/pixel_aspect) {
    9109. 

  9109.       frac = rc - (c = rc);
    9110. 

  9110.       pix0 = pix1 = image[c];
    9111. 

  9111.       if (c+1 < width) pix1 += 4;
    9112. 

  9112.       for (row=0; row < height; row++, pix0+=width*4, pix1+=width*4)
    9113. 

  9113. 	FORCC img[row*newdim+col][c] = pix0[c]*(1-frac) + pix1[c]*frac + 0.5;
    9114. 

  9114.     }
    9115. 

  9115.     width = newdim;
    9116. 

  9116.   }
    9117. 

  9117.   free (image);
    9118. 

  9118.   image = img;
    9119. 

  9119. #ifdef LIBRAW_LIBRARY_BUILD
    9120. 

  9120.   RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH,1,2);
    9121. 

  9121. #endif
    9122. 

  9122. }
    9123. 

  9123. 

  9124. int CLASS flip_index (int row, int col)
    9125. 

  9125. {
    9126. 

  9126.   if (flip & 4) SWAP(row,col);
    9127. 

  9127.   if (flip & 2) row = iheight - 1 - row;
    9128. 

  9128.   if (flip & 1) col = iwidth  - 1 - col;
    9129. 

  9129.   return row * iwidth + col;
    9130. 

  9130. }
    9131. 

  9131. #line 10403 "dcraw/dcraw.c"
    9132. 

  9132. void CLASS tiff_set (ushort *ntag,
    9133. 

  9133. 	ushort tag, ushort type, int count, int val)
    9134. 

  9134. {
    9135. 

  9135.   struct tiff_tag *tt;
    9136. 

  9136.   int c;
    9137. 

  9137. 

  9138.   tt = (struct tiff_tag *)(ntag+1) + (*ntag)++;
    9139. 

  9139.   tt->tag = tag;
    9140. 

  9140.   tt->type = type;
    9141. 

  9141.   tt->count = count;
    9142. 

  9142.   if (type < 3 && count <= 4)
    9143. 

  9143.     FORC(4) tt->val.c[c] = val >> (c << 3);
    9144. 

  9144.   else if (type == 3 && count <= 2)
    9145. 

  9145.     FORC(2) tt->val.s[c] = val >> (c << 4);
    9146. 

  9146.   else tt->val.i = val;
    9147. 

  9147. }
    9148. 

  9148. 

  9149. #define TOFF(ptr) ((char *)(&(ptr)) - (char *)th)
    9150. 

  9150. 

  9151. void CLASS tiff_head (struct tiff_hdr *th, int full)
    9152. 

  9152. {
    9153. 

  9153.   int c, psize=0;
    9154. 

  9154.   struct tm *t;
    9155. 

  9155. 

  9156.   memset (th, 0, sizeof *th);
    9157. 

  9157.   th->t_order = htonl(0x4d4d4949) >> 16;
    9158. 

  9158.   th->magic = 42;
    9159. 

  9159.   th->ifd = 10;
    9160. 

  9160.   if (full) {
    9161. 

  9161.     tiff_set (&th->ntag, 254, 4, 1, 0);
    9162. 

  9162.     tiff_set (&th->ntag, 256, 4, 1, width);
    9163. 

  9163.     tiff_set (&th->ntag, 257, 4, 1, height);
    9164. 

  9164.     tiff_set (&th->ntag, 258, 3, colors, output_bps);
    9165. 

  9165.     if (colors > 2)
    9166. 

  9166.       th->tag[th->ntag-1].val.i = TOFF(th->bps);
    9167. 

  9167.     FORC4 th->bps[c] = output_bps;
    9168. 

  9168.     tiff_set (&th->ntag, 259, 3, 1, 1);
    9169. 

  9169.     tiff_set (&th->ntag, 262, 3, 1, 1 + (colors > 1));
    9170. 

  9170.   }
    9171. 

  9171.   tiff_set (&th->ntag, 270, 2, 512, TOFF(th->t_desc));
    9172. 

  9172.   tiff_set (&th->ntag, 271, 2, 64, TOFF(th->t_make));
    9173. 

  9173.   tiff_set (&th->ntag, 272, 2, 64, TOFF(th->t_model));
    9174. 

  9174.   if (full) {
    9175. 

  9175.     if (oprof) psize = ntohl(oprof[0]);
    9176. 

  9176.     tiff_set (&th->ntag, 273, 4, 1, sizeof *th + psize);
    9177. 

  9177.     tiff_set (&th->ntag, 277, 3, 1, colors);
    9178. 

  9178.     tiff_set (&th->ntag, 278, 4, 1, height);
    9179. 

  9179.     tiff_set (&th->ntag, 279, 4, 1, height*width*colors*output_bps/8);
    9180. 

  9180.   } else
    9181. 

  9181.     tiff_set (&th->ntag, 274, 3, 1, "12435867"[flip]-'0');
    9182. 

  9182.   tiff_set (&th->ntag, 282, 5, 1, TOFF(th->rat[0]));
    9183. 

  9183.   tiff_set (&th->ntag, 283, 5, 1, TOFF(th->rat[2]));
    9184. 

  9184.   tiff_set (&th->ntag, 284, 3, 1, 1);
    9185. 

  9185.   tiff_set (&th->ntag, 296, 3, 1, 2);
    9186. 

  9186.   tiff_set (&th->ntag, 305, 2, 32, TOFF(th->soft));
    9187. 

  9187.   tiff_set (&th->ntag, 306, 2, 20, TOFF(th->date));
    9188. 

  9188.   tiff_set (&th->ntag, 315, 2, 64, TOFF(th->t_artist));
    9189. 

  9189.   tiff_set (&th->ntag, 34665, 4, 1, TOFF(th->nexif));
    9190. 

  9190.   if (psize) tiff_set (&th->ntag, 34675, 7, psize, sizeof *th);
    9191. 

  9191.   tiff_set (&th->nexif, 33434, 5, 1, TOFF(th->rat[4]));
    9192. 

  9192.   tiff_set (&th->nexif, 33437, 5, 1, TOFF(th->rat[6]));
    9193. 

  9193.   tiff_set (&th->nexif, 34855, 3, 1, iso_speed);
    9194. 

  9194.   tiff_set (&th->nexif, 37386, 5, 1, TOFF(th->rat[8]));
    9195. 

  9195.   if (gpsdata[1]) {
    9196. 

  9196.     tiff_set (&th->ntag, 34853, 4, 1, TOFF(th->ngps));
    9197. 

  9197.     tiff_set (&th->ngps,  0, 1,  4, 0x202);
    9198. 

  9198.     tiff_set (&th->ngps,  1, 2,  2, gpsdata[29]);
    9199. 

  9199.     tiff_set (&th->ngps,  2, 5,  3, TOFF(th->gps[0]));
    9200. 

  9200.     tiff_set (&th->ngps,  3, 2,  2, gpsdata[30]);
    9201. 

  9201.     tiff_set (&th->ngps,  4, 5,  3, TOFF(th->gps[6]));
    9202. 

  9202.     tiff_set (&th->ngps,  5, 1,  1, gpsdata[31]);
    9203. 

  9203.     tiff_set (&th->ngps,  6, 5,  1, TOFF(th->gps[18]));
    9204. 

  9204.     tiff_set (&th->ngps,  7, 5,  3, TOFF(th->gps[12]));
    9205. 

  9205.     tiff_set (&th->ngps, 18, 2, 12, TOFF(th->gps[20]));
    9206. 

  9206.     tiff_set (&th->ngps, 29, 2, 12, TOFF(th->gps[23]));
    9207. 

  9207.     memcpy (th->gps, gpsdata, sizeof th->gps);
    9208. 

  9208.   }
    9209. 

  9209.   th->rat[0] = th->rat[2] = 300;
    9210. 

  9210.   th->rat[1] = th->rat[3] = 1;
    9211. 

  9211.   FORC(6) th->rat[4+c] = 1000000;
    9212. 

  9212.   th->rat[4] *= shutter;
    9213. 

  9213.   th->rat[6] *= aperture;
    9214. 

  9214.   th->rat[8] *= focal_len;
    9215. 

  9215.   strncpy (th->t_desc, desc, 512);
    9216. 

  9216.   strncpy (th->t_make, make, 64);
    9217. 

  9217.   strncpy (th->t_model, model, 64);
    9218. 

  9218.   strcpy (th->soft, "dcraw v"DCRAW_VERSION);
    9219. 

  9219.   t = localtime (&timestamp);
    9220. 

  9220.   sprintf (th->date, "%04d:%02d:%02d %02d:%02d:%02d",
    9221. 

  9221.       t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec);
    9222. 

  9222.   strncpy (th->t_artist, artist, 64);
    9223. 

  9223. }
    9224. 

  9224. 

  9225. #ifdef LIBRAW_LIBRARY_BUILD
    9226. 

  9226. void CLASS jpeg_thumb_writer (FILE *tfp,char *t_humb,int t_humb_length)
    9227. 

  9227. {
    9228. 

  9228.   ushort exif[5];
    9229. 

  9229.   struct tiff_hdr th;
    9230. 

  9230.   fputc (0xff, tfp);
    9231. 

  9231.   fputc (0xd8, tfp);
    9232. 

  9232.   if (strcmp (t_humb+6, "Exif")) {
    9233. 

  9233.     memcpy (exif, "\xff\xe1  Exif\0\0", 10);
    9234. 

  9234.     exif[1] = htons (8 + sizeof th);
    9235. 

  9235.     fwrite (exif, 1, sizeof exif, tfp);
    9236. 

  9236.     tiff_head (&th, 0);
    9237. 

  9237.     fwrite (&th, 1, sizeof th, tfp);
    9238. 

  9238.   }
    9239. 

  9239.   fwrite (t_humb+2, 1, t_humb_length-2, tfp);
    9240. 

  9240. }
    9241. 

  9241. 

  9242. void CLASS jpeg_thumb()
    9243. 

  9243. {
    9244. 

  9244.   char *thumb;
    9245. 

  9245. 

  9246.   thumb = (char *) malloc (thumb_length);
    9247. 

  9247.   merror (thumb, "jpeg_thumb()");
    9248. 

  9248.   fread (thumb, 1, thumb_length, ifp);
    9249. 

  9249.   jpeg_thumb_writer(ofp,thumb,thumb_length);
    9250. 

  9250.   free (thumb);
    9251. 

  9251. }
    9252. 

  9252. #else
    9253. 

  9253. void CLASS jpeg_thumb()
    9254. 

  9254. {
    9255. 

  9255.   char *thumb;
    9256. 

  9256.   ushort exif[5];
    9257. 

  9257.   struct tiff_hdr th;
    9258. 

  9258. 

  9259.   thumb = (char *) malloc (thumb_length);
    9260. 

  9260.   merror (thumb, "jpeg_thumb()");
    9261. 

  9261.   fread (thumb, 1, thumb_length, ifp);
    9262. 

  9262.   fputc (0xff, ofp);
    9263. 

  9263.   fputc (0xd8, ofp);
    9264. 

  9264.   if (strcmp (thumb+6, "Exif")) {
    9265. 

  9265.     memcpy (exif, "\xff\xe1  Exif\0\0", 10);
    9266. 

  9266.     exif[1] = htons (8 + sizeof th);
    9267. 

  9267.     fwrite (exif, 1, sizeof exif, ofp);
    9268. 

  9268.     tiff_head (&th, 0);
    9269. 

  9269.     fwrite (&th, 1, sizeof th, ofp);
    9270. 

  9270.   }
    9271. 

  9271.   fwrite (thumb+2, 1, thumb_length-2, ofp);
    9272. 

  9272.   free (thumb);
    9273. 

  9273. }
    9274. 

  9274. #endif
    9275. 

  9275. 

  9276. void CLASS write_ppm_tiff()
    9277. 

  9277. {
    9278. 

  9278.   struct tiff_hdr th;
    9279. 

  9279.   uchar *ppm;
    9280. 

  9280.   ushort *ppm2;
    9281. 

  9281.   int c, row, col, soff, rstep, cstep;
    9282. 

  9282.   int perc, val, total, t_white=0x2000;
    9283. 

  9283. 

  9284.   perc = width * height * 0.01;		/* 99th percentile white level */
    9285. 

  9285.   if (fuji_width) perc /= 2;
    9286. 

  9286.   if (!((highlight & ~2) || no_auto_bright))
    9287. 

  9287.     for (t_white=c=0; c < colors; c++) {
    9288. 

  9288.       for (val=0x2000, total=0; --val > 32; )
    9289. 

  9289. 	if ((total += histogram[c][val]) > perc) break;
    9290. 

  9290.       if (t_white < val) t_white = val;
    9291. 

  9291.     }
    9292. 

  9292.   gamma_curve (gamm[0], gamm[1], 2, (t_white << 3)/bright);
    9293. 

  9293.   iheight = height;
    9294. 

  9294.   iwidth  = width;
    9295. 

  9295.   if (flip & 4) SWAP(height,width);
    9296. 

  9296.   ppm = (uchar *) calloc (width, colors*output_bps/8);
    9297. 

  9297.   ppm2 = (ushort *) ppm;
    9298. 

  9298.   merror (ppm, "write_ppm_tiff()");
    9299. 

  9299.   if (output_tiff) {
    9300. 

  9300.     tiff_head (&th, 1);
    9301. 

  9301.     fwrite (&th, sizeof th, 1, ofp);
    9302. 

  9302.     if (oprof)
    9303. 

  9303.       fwrite (oprof, ntohl(oprof[0]), 1, ofp);
    9304. 

  9304.   } else if (colors > 3)
    9305. 

  9305.     fprintf (ofp,
    9306. 

  9306.       "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLTYPE %s\nENDHDR\n",
    9307. 

  9307. 	width, height, colors, (1 << output_bps)-1, cdesc);
    9308. 

  9308.   else
    9309. 

  9309.     fprintf (ofp, "P%d\n%d %d\n%d\n",
    9310. 

  9310. 	colors/2+5, width, height, (1 << output_bps)-1);
    9311. 

  9311.   soff  = flip_index (0, 0);
    9312. 

  9312.   cstep = flip_index (0, 1) - soff;
    9313. 

  9313.   rstep = flip_index (1, 0) - flip_index (0, width);
    9314. 

  9314.   for (row=0; row < height; row++, soff += rstep) {
    9315. 

  9315.     for (col=0; col < width; col++, soff += cstep)
    9316. 

  9316.       if (output_bps == 8)
    9317. 

  9317. 	   FORCC ppm [col*colors+c] = curve[image[soff][c]] >> 8;
    9318. 

  9318.       else FORCC ppm2[col*colors+c] = curve[image[soff][c]];
    9319. 

  9319.     if (output_bps == 16 && !output_tiff && htons(0x55aa) != 0x55aa)
    9320. 

  9320.       swab ((char*)ppm2, (char*)ppm2, width*colors*2);
    9321. 

  9321.     fwrite (ppm, colors*output_bps/8, width, ofp);
    9322. 

  9322.   }
    9323. 

  9323.   free (ppm);
    9324. 

  9324. }
    9325. 

  9325.