PageRenderTime 129ms CodeModel.GetById 17ms RepoModel.GetById 1ms app.codeStats 2ms

/Source/LibRawLite/internal/dcraw_common.cpp

https://bitbucket.org/tiran/freeimage
C++ | 9385 lines | 8885 code | 356 blank | 144 comment | 2909 complexity | 62d53896f8a38f0d2f613bfbf11e9212 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, GPL-2.0, GPL-3.0, LGPL-3.0, BSD-2-Clause, LGPL-2.1, BSD-3-Clause 
    

  1. /* 
    2. 

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

    4. 

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

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

    7. 

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

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

    10. 

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

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

    13. 

  13. 3. LibRaw Software License 27032010
    14. 

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

    16. 

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

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

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

    20. 

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

  21.    for more information
    22. 

  22. */
    23. 

  23. 

  24. #include <math.h>
    25. 

  25. #define CLASS LibRaw::
    26. 

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

  27. #define LIBRAW_LIBRARY_BUILD
    28. 

  28. #define LIBRAW_IO_REDEFINED
    29. 

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

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

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

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

  33. int CLASS fcol (int row, int col)
    34. 

  34. {
    35. 

  35.   static const char filter[16][16] =
    36. 

  36.   { { 2,1,1,3,2,3,2,0,3,2,3,0,1,2,1,0 },
    37. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  52.   static const char filter2[6][6] =
    53. 

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

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

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

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

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

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

  59. 

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

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

  62.   return FC(row,col);
    63. 

  63. }
    64. 

  64. 

  65. #ifndef __GLIBC__
    66. 

  66. char *my_memmem (char *haystack, size_t haystacklen,
    67. 

  67. 	      char *needle, size_t needlelen)
    68. 

  68. {
    69. 

  69.   char *c;
    70. 

  70.   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
    71. 

  71.     if (!memcmp (c, needle, needlelen))
    72. 

  72.       return c;
    73. 

  73.   return 0;
    74. 

  74. }
    75. 

  75. #define memmem my_memmem
    76. 

  76. #endif
    77. 

  77. ushort CLASS sget2 (uchar *s)
    78. 

  78. {
    79. 

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

  80.     return s[0] | s[1] << 8;
    81. 

  81.   else				/* "MM" means big-endian */
    82. 

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

  83. }
    84. 

  84. 

  85. ushort CLASS get2()
    86. 

  86. {
    87. 

  87.   uchar str[2] = { 0xff,0xff };
    88. 

  88.   fread (str, 1, 2, ifp);
    89. 

  89.   return sget2(str);
    90. 

  90. }
    91. 

  91. 

  92. unsigned CLASS sget4 (uchar *s)
    93. 

  93. {
    94. 

  94.   if (order == 0x4949)
    95. 

  95.     return s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
    96. 

  96.   else
    97. 

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

  98. }
    99. 

  99. #define sget4(s) sget4((uchar *)s)
    100. 

  100. 

  101. unsigned CLASS get4()
    102. 

  102. {
    103. 

  103.   uchar str[4] = { 0xff,0xff,0xff,0xff };
    104. 

  104.   fread (str, 1, 4, ifp);
    105. 

  105.   return sget4(str);
    106. 

  106. }
    107. 

  107. 

  108. unsigned CLASS getint (int type)
    109. 

  109. {
    110. 

  110.   return type == 3 ? get2() : get4();
    111. 

  111. }
    112. 

  112. 

  113. float CLASS int_to_float (int i)
    114. 

  114. {
    115. 

  115.   union { int i; float f; } u;
    116. 

  116.   u.i = i;
    117. 

  117.   return u.f;
    118. 

  118. }
    119. 

  119. 

  120. double CLASS getreal (int type)
    121. 

  121. {
    122. 

  122.   union { char c[8]; double d; } u;
    123. 

  123.   int i, rev;
    124. 

  124. 

  125.   switch (type) {
    126. 

  126.     case 3: return (unsigned short) get2();
    127. 

  127.     case 4: return (unsigned int) get4();
    128. 

  128.     case 5:  u.d = (unsigned int) get4();
    129. 

  129.       return u.d / (unsigned int) get4();
    130. 

  130.     case 8: return (signed short) get2();
    131. 

  131.     case 9: return (signed int) get4();
    132. 

  132.     case 10: u.d = (signed int) get4();
    133. 

  133.       return u.d / (signed int) get4();
    134. 

  134.     case 11: return int_to_float (get4());
    135. 

  135.     case 12:
    136. 

  136.       rev = 7 * ((order == 0x4949) == (ntohs(0x1234) == 0x1234));
    137. 

  137.       for (i=0; i < 8; i++)
    138. 

  138. 	u.c[i ^ rev] = fgetc(ifp);
    139. 

  139.       return u.d;
    140. 

  140.     default: return fgetc(ifp);
    141. 

  141.   }
    142. 

  142. }
    143. 

  143. 

  144. void CLASS read_shorts (ushort *pixel, int count)
    145. 

  145. {
    146. 

  146.   if (fread (pixel, 2, count, ifp) < count) derror();
    147. 

  147.   if ((order == 0x4949) == (ntohs(0x1234) == 0x1234))
    148. 

  148.     swab ((char*)pixel, (char*)pixel, count*2);
    149. 

  149. }
    150. 

  150. 

  151. void CLASS canon_600_fixed_wb (int temp)
    152. 

  152. {
    153. 

  153.   static const short mul[4][5] = {
    154. 

  154.     {  667, 358,397,565,452 },
    155. 

  155.     {  731, 390,367,499,517 },
    156. 

  156.     { 1119, 396,348,448,537 },
    157. 

  157.     { 1399, 485,431,508,688 } };
    158. 

  158.   int lo, hi, i;
    159. 

  159.   float frac=0;
    160. 

  160. 

  161.   for (lo=4; --lo; )
    162. 

  162.     if (*mul[lo] <= temp) break;
    163. 

  163.   for (hi=0; hi < 3; hi++)
    164. 

  164.     if (*mul[hi] >= temp) break;
    165. 

  165.   if (lo != hi)
    166. 

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

  167.   for (i=1; i < 5; i++)
    168. 

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

  169. }
    170. 

  170. 

  171. /* Return values:  0 = white  1 = near white  2 = not white */
    172. 

  172. int CLASS canon_600_color (int ratio[2], int mar)
    173. 

  173. {
    174. 

  174.   int clipped=0, target, miss;
    175. 

  175. 

  176.   if (flash_used) {
    177. 

  177.     if (ratio[1] < -104)
    178. 

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

  179.     if (ratio[1] >   12)
    180. 

  180.       { ratio[1] =   12; clipped = 1; }
    181. 

  181.   } else {
    182. 

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

  183.     if (ratio[1] < -50)
    184. 

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

  185.     if (ratio[1] > 307)
    186. 

  186.       { ratio[1] = 307; clipped = 1; }
    187. 

  187.   }
    188. 

  188.   target = flash_used || ratio[1] < 197
    189. 

  189. 	? -38 - (398 * ratio[1] >> 10)
    190. 

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

  191.   if (target - mar <= ratio[0] &&
    192. 

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

  193.   miss = target - ratio[0];
    194. 

  194.   if (abs(miss) >= mar*4) return 2;
    195. 

  195.   if (miss < -20) miss = -20;
    196. 

  196.   if (miss > mar) miss = mar;
    197. 

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

  198.   return 1;
    199. 

  199. }
    200. 

  200. 

  201. void CLASS canon_600_auto_wb()
    202. 

  202. {
    203. 

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

  204.   int test[8], total[2][8], ratio[2][2], stat[2];
    205. 

  205. 

  206.   memset (&total, 0, sizeof total);
    207. 

  207.   i = canon_ev + 0.5;
    208. 

  208.   if      (i < 10) mar = 150;
    209. 

  209.   else if (i > 12) mar = 20;
    210. 

  210.   else mar = 280 - 20 * i;
    211. 

  211.   if (flash_used) mar = 80;
    212. 

  212.   for (row=14; row < height-14; row+=4)
    213. 

  213.     for (col=10; col < width; col+=2) {
    214. 

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

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

  216. 		    BAYER(row+(i >> 1),col+(i & 1));
    217. 

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

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

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

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

  221.       for (i=0; i < 2; i++) {
    222. 

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

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

  224. 	stat[i] = canon_600_color (ratio[i], mar);
    225. 

  225.       }
    226. 

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

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

  228. 	if (stat[i])
    229. 

  229. 	  for (j=0; j < 2; j++)
    230. 

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

  231.       for (i=0; i < 8; i++)
    232. 

  232. 	total[st][i] += test[i];
    233. 

  233.       count[st]++;
    234. 

  234. next: ;
    235. 

  235.     }
    236. 

  236.   if (count[0] | count[1]) {
    237. 

  237.     st = count[0]*200 < count[1];
    238. 

  238.     for (i=0; i < 4; i++)
    239. 

  239.       pre_mul[i] = 1.0 / (total[st][i] + total[st][i+4]);
    240. 

  240.   }
    241. 

  241. }
    242. 

  242. 

  243. void CLASS canon_600_coeff()
    244. 

  244. {
    245. 

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

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

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

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

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

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

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

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

  253.   float mc, yc;
    254. 

  254. 

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

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

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

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

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

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

  261.   }
    262. 

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

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

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

  265. }
    266. 

  266. 

  267. void CLASS canon_600_load_raw()
    268. 

  268. {
    269. 

  269.   uchar  data[1120], *dp;
    270. 

  270.   ushort *pix;
    271. 

  271.   int irow, row;
    272. 

  272. 

  273.   for (irow=row=0; irow < height; irow++) {
    274. 

  274.     if (fread (data, 1, 1120, ifp) < 1120) derror();
    275. 

  275.     pix = raw_image + row*raw_width;
    276. 

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

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

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

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

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

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

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

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

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

  285.     }
    286. 

  286.     if ((row+=2) > height) row = 1;
    287. 

  287.   }
    288. 

  288. }
    289. 

  289. 

  290. void CLASS canon_600_correct()
    291. 

  291. {
    292. 

  292.   int row, col, val;
    293. 

  293.   static const short mul[4][2] =
    294. 

  294.   { { 1141,1145 }, { 1128,1109 }, { 1178,1149 }, { 1128,1109 } };
    295. 

  295. 

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

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

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

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

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

  301.     }
    302. 

  302.   canon_600_fixed_wb(1311);
    303. 

  303.   canon_600_auto_wb();
    304. 

  304.   canon_600_coeff();
    305. 

  305.   maximum = (0x3ff - black) * 1109 >> 9;
    306. 

  306.   black = 0;
    307. 

  307. }
    308. 

  308. 

  309. int CLASS canon_s2is()
    310. 

  310. {
    311. 

  311.   unsigned row;
    312. 

  312. 

  313.   for (row=0; row < 100; row++) {
    314. 

  314.     fseek (ifp, row*3340 + 3284, SEEK_SET);
    315. 

  315.     if (getc(ifp) > 15) return 1;
    316. 

  316.   }
    317. 

  317.   return 0;
    318. 

  318. }
    319. 

  319. 

  320. /*
    321. 

  321.    getbits(-1) initializes the buffer
    322. 

  322.    getbits(n) where 0 <= n <= 25 returns an n-bit integer
    323. 

  323.  */
    324. 

  324. unsigned CLASS getbithuff (int nbits, ushort *huff)
    325. 

  325. {
    326. 

  326. #ifdef LIBRAW_NOTHREADS
    327. 

  327.   static unsigned bitbuf=0;
    328. 

  328.   static int vbits=0, reset=0;
    329. 

  329. #else
    330. 

  330. #define bitbuf tls->getbits.bitbuf
    331. 

  331. #define vbits  tls->getbits.vbits
    332. 

  332. #define reset  tls->getbits.reset
    333. 

  333. #endif
    334. 

  334.   unsigned c;
    335. 

  335. 

  336.   if (nbits == -1)
    337. 

  337.     return bitbuf = vbits = reset = 0;
    338. 

  338.   if (nbits == 0 || vbits < 0) return 0;
    339. 

  339.   while (!reset && vbits < nbits && (c = fgetc(ifp)) != EOF &&
    340. 

  340.     !(reset = zero_after_ff && c == 0xff && fgetc(ifp))) {
    341. 

  341.     bitbuf = (bitbuf << 8) + (uchar) c;
    342. 

  342.     vbits += 8;
    343. 

  343.   }
    344. 

  344.   c = bitbuf << (32-vbits) >> (32-nbits);
    345. 

  345.   if (huff) {
    346. 

  346.     vbits -= huff[c] >> 8;
    347. 

  347.     c = (uchar) huff[c];
    348. 

  348.   } else
    349. 

  349.     vbits -= nbits;
    350. 

  350.   if (vbits < 0) derror();
    351. 

  351.   return c;
    352. 

  352. #ifndef LIBRAW_NOTHREADS
    353. 

  353. #undef bitbuf
    354. 

  354. #undef vbits
    355. 

  355. #undef reset
    356. 

  356. #endif
    357. 

  357. }
    358. 

  358. 

  359. #define getbits(n) getbithuff(n,0)
    360. 

  360. #define gethuff(h) getbithuff(*h,h+1)
    361. 

  361. 

  362. /*
    363. 

  363.    Construct a decode tree according the specification in *source.
    364. 

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

  365.    3-bit, etc.  Bytes after that are the leaf values.
    366. 

    367. 

  367.    For example, if the source is
    368. 

    369. 

  369.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,
    370. 

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

    372. 

  372.    then the code is
    373. 

    374. 

  374. 	00		0x04
    375. 

  375. 	010		0x03
    376. 

  376. 	011		0x05
    377. 

  377. 	100		0x06
    378. 

  378. 	101		0x02
    379. 

  379. 	1100		0x07
    380. 

  380. 	1101		0x01
    381. 

  381. 	11100		0x08
    382. 

  382. 	11101		0x09
    383. 

  383. 	11110		0x00
    384. 

  384. 	111110		0x0a
    385. 

  385. 	1111110		0x0b
    386. 

  386. 	1111111		0xff
    387. 

  387.  */
    388. 

  388. ushort * CLASS make_decoder_ref (const uchar **source)
    389. 

  389. {
    390. 

  390.   int max, len, h, i, j;
    391. 

  391.   const uchar *count;
    392. 

  392.   ushort *huff;
    393. 

  393. 

  394.   count = (*source += 16) - 17;
    395. 

  395.   for (max=16; max && !count[max]; max--);
    396. 

  396.   huff = (ushort *) calloc (1 + (1 << max), sizeof *huff);
    397. 

  397.   merror (huff, "make_decoder()");
    398. 

  398.   huff[0] = max;
    399. 

  399.   for (h=len=1; len <= max; len++)
    400. 

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

  401.       for (j=0; j < 1 << (max-len); j++)
    402. 

  402. 	if (h <= 1 << max)
    403. 

  403. 	  huff[h++] = len << 8 | **source;
    404. 

  404.   return huff;
    405. 

  405. }
    406. 

  406. 

  407. ushort * CLASS make_decoder (const uchar *source)
    408. 

  408. {
    409. 

  409.   return make_decoder_ref (&source);
    410. 

  410. }
    411. 

  411. 

  412. void CLASS crw_init_tables (unsigned table, ushort *huff[2])
    413. 

  413. {
    414. 

  414.   static const uchar first_tree[3][29] = {
    415. 

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

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

  417.     { 0,2,2,3,1,1,1,1,2,0,0,0,0,0,0,0,
    418. 

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

  419.     { 0,0,6,3,1,1,2,0,0,0,0,0,0,0,0,0,
    420. 

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

  421.   };
    422. 

  422.   static const uchar second_tree[3][180] = {
    423. 

  423.     { 0,2,2,2,1,4,2,1,2,5,1,1,0,0,0,139,
    424. 

  424.       0x03,0x04,0x02,0x05,0x01,0x06,0x07,0x08,
    425. 

  425.       0x12,0x13,0x11,0x14,0x09,0x15,0x22,0x00,0x21,0x16,0x0a,0xf0,
    426. 

  426.       0x23,0x17,0x24,0x31,0x32,0x18,0x19,0x33,0x25,0x41,0x34,0x42,
    427. 

  427.       0x35,0x51,0x36,0x37,0x38,0x29,0x79,0x26,0x1a,0x39,0x56,0x57,
    428. 

  428.       0x28,0x27,0x52,0x55,0x58,0x43,0x76,0x59,0x77,0x54,0x61,0xf9,
    429. 

  429.       0x71,0x78,0x75,0x96,0x97,0x49,0xb7,0x53,0xd7,0x74,0xb6,0x98,
    430. 

  430.       0x47,0x48,0x95,0x69,0x99,0x91,0xfa,0xb8,0x68,0xb5,0xb9,0xd6,
    431. 

  431.       0xf7,0xd8,0x67,0x46,0x45,0x94,0x89,0xf8,0x81,0xd5,0xf6,0xb4,
    432. 

  432.       0x88,0xb1,0x2a,0x44,0x72,0xd9,0x87,0x66,0xd4,0xf5,0x3a,0xa7,
    433. 

  433.       0x73,0xa9,0xa8,0x86,0x62,0xc7,0x65,0xc8,0xc9,0xa1,0xf4,0xd1,
    434. 

  434.       0xe9,0x5a,0x92,0x85,0xa6,0xe7,0x93,0xe8,0xc1,0xc6,0x7a,0x64,
    435. 

  435.       0xe1,0x4a,0x6a,0xe6,0xb3,0xf1,0xd3,0xa5,0x8a,0xb2,0x9a,0xba,
    436. 

  436.       0x84,0xa4,0x63,0xe5,0xc5,0xf3,0xd2,0xc4,0x82,0xaa,0xda,0xe4,
    437. 

  437.       0xf2,0xca,0x83,0xa3,0xa2,0xc3,0xea,0xc2,0xe2,0xe3,0xff,0xff  },
    438. 

  438.     { 0,2,2,1,4,1,4,1,3,3,1,0,0,0,0,140,
    439. 

  439.       0x02,0x03,0x01,0x04,0x05,0x12,0x11,0x06,
    440. 

  440.       0x13,0x07,0x08,0x14,0x22,0x09,0x21,0x00,0x23,0x15,0x31,0x32,
    441. 

  441.       0x0a,0x16,0xf0,0x24,0x33,0x41,0x42,0x19,0x17,0x25,0x18,0x51,
    442. 

  442.       0x34,0x43,0x52,0x29,0x35,0x61,0x39,0x71,0x62,0x36,0x53,0x26,
    443. 

  443.       0x38,0x1a,0x37,0x81,0x27,0x91,0x79,0x55,0x45,0x28,0x72,0x59,
    444. 

  444.       0xa1,0xb1,0x44,0x69,0x54,0x58,0xd1,0xfa,0x57,0xe1,0xf1,0xb9,
    445. 

  445.       0x49,0x47,0x63,0x6a,0xf9,0x56,0x46,0xa8,0x2a,0x4a,0x78,0x99,
    446. 

  446.       0x3a,0x75,0x74,0x86,0x65,0xc1,0x76,0xb6,0x96,0xd6,0x89,0x85,
    447. 

  447.       0xc9,0xf5,0x95,0xb4,0xc7,0xf7,0x8a,0x97,0xb8,0x73,0xb7,0xd8,
    448. 

  448.       0xd9,0x87,0xa7,0x7a,0x48,0x82,0x84,0xea,0xf4,0xa6,0xc5,0x5a,
    449. 

  449.       0x94,0xa4,0xc6,0x92,0xc3,0x68,0xb5,0xc8,0xe4,0xe5,0xe6,0xe9,
    450. 

  450.       0xa2,0xa3,0xe3,0xc2,0x66,0x67,0x93,0xaa,0xd4,0xd5,0xe7,0xf8,
    451. 

  451.       0x88,0x9a,0xd7,0x77,0xc4,0x64,0xe2,0x98,0xa5,0xca,0xda,0xe8,
    452. 

  452.       0xf3,0xf6,0xa9,0xb2,0xb3,0xf2,0xd2,0x83,0xba,0xd3,0xff,0xff  },
    453. 

  453.     { 0,0,6,2,1,3,3,2,5,1,2,2,8,10,0,117,
    454. 

  454.       0x04,0x05,0x03,0x06,0x02,0x07,0x01,0x08,
    455. 

  455.       0x09,0x12,0x13,0x14,0x11,0x15,0x0a,0x16,0x17,0xf0,0x00,0x22,
    456. 

  456.       0x21,0x18,0x23,0x19,0x24,0x32,0x31,0x25,0x33,0x38,0x37,0x34,
    457. 

  457.       0x35,0x36,0x39,0x79,0x57,0x58,0x59,0x28,0x56,0x78,0x27,0x41,
    458. 

  458.       0x29,0x77,0x26,0x42,0x76,0x99,0x1a,0x55,0x98,0x97,0xf9,0x48,
    459. 

  459.       0x54,0x96,0x89,0x47,0xb7,0x49,0xfa,0x75,0x68,0xb6,0x67,0x69,
    460. 

  460.       0xb9,0xb8,0xd8,0x52,0xd7,0x88,0xb5,0x74,0x51,0x46,0xd9,0xf8,
    461. 

  461.       0x3a,0xd6,0x87,0x45,0x7a,0x95,0xd5,0xf6,0x86,0xb4,0xa9,0x94,
    462. 

  462.       0x53,0x2a,0xa8,0x43,0xf5,0xf7,0xd4,0x66,0xa7,0x5a,0x44,0x8a,
    463. 

  463.       0xc9,0xe8,0xc8,0xe7,0x9a,0x6a,0x73,0x4a,0x61,0xc7,0xf4,0xc6,
    464. 

  464.       0x65,0xe9,0x72,0xe6,0x71,0x91,0x93,0xa6,0xda,0x92,0x85,0x62,
    465. 

  465.       0xf3,0xc5,0xb2,0xa4,0x84,0xba,0x64,0xa5,0xb3,0xd2,0x81,0xe5,
    466. 

  466.       0xd3,0xaa,0xc4,0xca,0xf2,0xb1,0xe4,0xd1,0x83,0x63,0xea,0xc3,
    467. 

  467.       0xe2,0x82,0xf1,0xa3,0xc2,0xa1,0xc1,0xe3,0xa2,0xe1,0xff,0xff  }
    468. 

  468.   };
    469. 

  469.   if (table > 2) table = 2;
    470. 

  470.   huff[0] = make_decoder ( first_tree[table]);
    471. 

  471.   huff[1] = make_decoder (second_tree[table]);
    472. 

  472. }
    473. 

  473. 

  474. /*
    475. 

  475.    Return 0 if the image starts with compressed data,
    476. 

  476.    1 if it starts with uncompressed low-order bits.
    477. 

    478. 

  478.    In Canon compressed data, 0xff is always followed by 0x00.
    479. 

  479.  */
    480. 

  480. int CLASS canon_has_lowbits()
    481. 

  481. {
    482. 

  482.   uchar test[0x4000];
    483. 

  483.   int ret=1, i;
    484. 

  484. 

  485.   fseek (ifp, 0, SEEK_SET);
    486. 

  486.   fread (test, 1, sizeof test, ifp);
    487. 

  487.   for (i=540; i < sizeof test - 1; i++)
    488. 

  488.     if (test[i] == 0xff) {
    489. 

  489.       if (test[i+1]) return 1;
    490. 

  490.       ret=0;
    491. 

  491.     }
    492. 

  492.   return ret;
    493. 

  493. }
    494. 

  494. 

  495. void CLASS canon_load_raw()
    496. 

  496. {
    497. 

  497.   ushort *pixel, *prow, *huff[2];
    498. 

  498.   int nblocks, lowbits, i, c, row, r, save, val;
    499. 

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

  500. 

  501.   crw_init_tables (tiff_compress, huff);
    502. 

  502.   lowbits = canon_has_lowbits();
    503. 

  503.   if (!lowbits) maximum = 0x3ff;
    504. 

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

  505.   zero_after_ff = 1;
    506. 

  506.   getbits(-1);
    507. 

  507.   for (row=0; row < raw_height; row+=8) {
    508. 

  508.     pixel = raw_image + row*raw_width;
    509. 

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

  510.     for (block=0; block < nblocks; block++) {
    511. 

  511.       memset (diffbuf, 0, sizeof diffbuf);
    512. 

  512.       for (i=0; i < 64; i++ ) {
    513. 

  513. 	leaf = gethuff(huff[i > 0]);
    514. 

  514. 	if (leaf == 0 && i) break;
    515. 

  515. 	if (leaf == 0xff) continue;
    516. 

  516. 	i  += leaf >> 4;
    517. 

  517. 	len = leaf & 15;
    518. 

  518. 	if (len == 0) continue;
    519. 

  519. 	diff = getbits(len);
    520. 

  520. 	if ((diff & (1 << (len-1))) == 0)
    521. 

  521. 	  diff -= (1 << len) - 1;
    522. 

  522. 	if (i < 64) diffbuf[i] = diff;
    523. 

  523.       }
    524. 

  524.       diffbuf[0] += carry;
    525. 

  525.       carry = diffbuf[0];
    526. 

  526.       for (i=0; i < 64; i++ ) {
    527. 

  527. 	if (pnum++ % raw_width == 0)
    528. 

  528. 	  base[0] = base[1] = 512;
    529. 

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

  530. 	  derror();
    531. 

  531.       }
    532. 

  532.     }
    533. 

  533.     if (lowbits) {
    534. 

  534.       save = ftell(ifp);
    535. 

  535.       fseek (ifp, 26 + row*raw_width/4, SEEK_SET);
    536. 

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

  537. 	c = fgetc(ifp);
    538. 

  538. 	for (r=0; r < 8; r+=2, prow++) {
    539. 

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

  540. 	  if (raw_width == 2672 && val < 512) val += 2;
    541. 

  541. 	  *prow = val;
    542. 

  542. 	}
    543. 

  543.       }
    544. 

  544.       fseek (ifp, save, SEEK_SET);
    545. 

  545.     }
    546. 

  546.   }
    547. 

  547.   FORC(2) free (huff[c]);
    548. 

  548. }
    549. 

  549. int CLASS ljpeg_start (struct jhead *jh, int info_only)
    550. 

  550. {
    551. 

  551.   int c, tag, len;
    552. 

  552.   uchar data[0x10000];
    553. 

  553.   const uchar *dp;
    554. 

  554. 

  555.   memset (jh, 0, sizeof *jh);
    556. 

  556.   jh->restart = INT_MAX;
    557. 

  557.   fread (data, 2, 1, ifp);
    558. 

  558.   if (data[1] != 0xd8) return 0;
    559. 

  559.   do {
    560. 

  560.     fread (data, 2, 2, ifp);
    561. 

  561.     tag =  data[0] << 8 | data[1];
    562. 

  562.     len = (data[2] << 8 | data[3]) - 2;
    563. 

  563.     if (tag <= 0xff00) return 0;
    564. 

  564.     fread (data, 1, len, ifp);
    565. 

  565.     switch (tag) {
    566. 

  566.       case 0xffc3:
    567. 

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

  568.       case 0xffc0:
    569. 

  569. 	jh->bits = data[0];
    570. 

  570. 	jh->high = data[1] << 8 | data[2];
    571. 

  571. 	jh->wide = data[3] << 8 | data[4];
    572. 

  572. 	jh->clrs = data[5] + jh->sraw;
    573. 

  573. 	if (len == 9 && !dng_version) getc(ifp);
    574. 

  574. 	break;
    575. 

  575.       case 0xffc4:
    576. 

  576. 	if (info_only) break;
    577. 

  577. 	for (dp = data; dp < data+len && (c = *dp++) < 4; )
    578. 

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

  579. 	break;
    580. 

  580.       case 0xffda:
    581. 

  581. 	jh->psv = data[1+data[0]*2];
    582. 

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

  583. 	break;
    584. 

  584.       case 0xffdd:
    585. 

  585. 	jh->restart = data[0] << 8 | data[1];
    586. 

  586.     }
    587. 

  587.   } while (tag != 0xffda);
    588. 

  588.   if (info_only) return 1;
    589. 

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

  590.   if (jh->sraw) {
    591. 

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

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

  593.   }
    594. 

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

  595.   merror (jh->row, "ljpeg_start()");
    596. 

  596.   return zero_after_ff = 1;
    597. 

  597. }
    598. 

  598. 

  599. void CLASS ljpeg_end (struct jhead *jh)
    600. 

  600. {
    601. 

  601.   int c;
    602. 

  602.   FORC4 if (jh->free[c]) free (jh->free[c]);
    603. 

  603.   free (jh->row);
    604. 

  604. }
    605. 

  605. 

  606. int CLASS ljpeg_diff (ushort *huff)
    607. 

  607. {
    608. 

  608.   int len, diff;
    609. 

  609. 

  610.   len = gethuff(huff);
    611. 

  611.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    612. 

  612.     return -32768;
    613. 

  613.   diff = getbits(len);
    614. 

  614.   if ((diff & (1 << (len-1))) == 0)
    615. 

  615.     diff -= (1 << len) - 1;
    616. 

  616.   return diff;
    617. 

  617. }
    618. 

  618. 

  619. #ifdef LIBRAW_LIBRARY_BUILD
    620. 

  620. int CLASS ljpeg_diff_new (LibRaw_bit_buffer& bits, LibRaw_byte_buffer* buf,ushort *huff)
    621. 

  621. {
    622. 

  622.   int len, diff;
    623. 

  623. 

  624.   len = bits._gethuff_lj(buf,*huff,huff+1);
    625. 

  625.   if (len == 16 && (!dng_version || dng_version >= 0x1010000))
    626. 

  626.     return -32768;
    627. 

  627.   diff = bits._getbits_lj(buf,len);
    628. 

  628.   if ((diff & (1 << (len-1))) == 0)
    629. 

  629.     diff -= (1 << len) - 1;
    630. 

  630.   return diff;
    631. 

  631. }
    632. 

  632. 

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

  634. {
    635. 

  635.   int col, c, diff, pred, spred=0;
    636. 

  636.   ushort mark=0, *row[3];
    637. 

  637. 

  638.   if (jrow * jh->wide % jh->restart == 0) {
    639. 

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

  640.     if (jrow) {
    641. 

  641.         bytes->unseek2();
    642. 

  642.         do mark = (mark << 8) + (c = bytes->get_byte());
    643. 

  643.         while (c != EOF && mark >> 4 != 0xffd);
    644. 

  644.     }
    645. 

  645.     bits.reset();
    646. 

  646.   }
    647. 

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

  648.   for (col=0; col < jh->wide; col++)
    649. 

  649.     FORC(jh->clrs) {
    650. 

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

  651.       if (jh->sraw && c <= jh->sraw && (col | c))
    652. 

  652. 		    pred = spred;
    653. 

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

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

  655.       if (jrow && col) switch (jh->psv) {
    656. 

  656. 	case 1:	break;
    657. 

  657. 	case 2: pred = row[1][0];					break;
    658. 

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

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

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

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

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

  663. 	default: pred = 0;
    664. 

  664.       }
    665. 

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

  666.       if (c <= jh->sraw) spred = **row;
    667. 

  667.       row[0]++; row[1]++;
    668. 

  668.     }
    669. 

  669.   return row[2];
    670. 

  670. }
    671. 

  671. 

  672. #endif
    673. 

  673. 

  674. 

  675. ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
    676. 

  676. {
    677. 

  677.   int col, c, diff, pred, spred=0;
    678. 

  678.   ushort mark=0, *row[3];
    679. 

  679. 

  680.   if (jrow * jh->wide % jh->restart == 0) {
    681. 

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

  682.     if (jrow) {
    683. 

  683.       fseek (ifp, -2, SEEK_CUR);
    684. 

  684.       do mark = (mark << 8) + (c = fgetc(ifp));
    685. 

  685.       while (c != EOF && mark >> 4 != 0xffd);
    686. 

  686.     }
    687. 

  687.     getbits(-1);
    688. 

  688.   }
    689. 

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

  690.   for (col=0; col < jh->wide; col++)
    691. 

  691.     FORC(jh->clrs) {
    692. 

  692.       diff = ljpeg_diff (jh->huff[c]);
    693. 

  693.       if (jh->sraw && c <= jh->sraw && (col | c))
    694. 

  694. 		    pred = spred;
    695. 

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

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

  697.       if (jrow && col) switch (jh->psv) {
    698. 

  698. 	case 1:	break;
    699. 

  699. 	case 2: pred = row[1][0];					break;
    700. 

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

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

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

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

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

  705. 	default: pred = 0;
    706. 

  706.       }
    707. 

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

  708.       if (c <= jh->sraw) spred = **row;
    709. 

  709.       row[0]++; row[1]++;
    710. 

  710.     }
    711. 

  711.   return row[2];
    712. 

  712. }
    713. 

  713. 

  714. void CLASS lossless_jpeg_load_raw()
    715. 

  715. {
    716. 

  716.   int jwide, jrow, jcol, val, i, row=0, col=0;
    717. 

  717. #ifndef LIBRAW_LIBRARY_BUILD
    718. 

  718.   int jidx,j;
    719. 

  719. #endif
    720. 

  720.   struct jhead jh;
    721. 

  721.   ushort *rp;
    722. 

  722. 

  723. #ifdef LIBRAW_LIBRARY_BUILD
    724. 

  724.   int save_min = 0;
    725. 

  725.   unsigned slicesW[16],slicesWcnt=0,slices;
    726. 

  726.   unsigned *offset;
    727. 

  727.   unsigned t_y=0,t_x=0,t_s=0,slice=0,pixelsInSlice,pixno;
    728. 

  728.   if (!strcasecmp(make,"KODAK"))
    729. 

  729.       save_min = 1;
    730. 

  730. #endif
    731. 

  731. 

  732. #ifdef LIBRAW_LIBRARY_BUILD
    733. 

  733.   if (cr2_slice[0]>15)
    734. 

  734.       throw LIBRAW_EXCEPTION_IO_EOF; // change many slices
    735. 

  735. #else
    736. 

  736.   if (cr2_slice[0]>15)
    737. 

  737.   {
    738. 

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

  739.       return;
    740. 

  740.   }
    741. 

  741. #endif
    742. 

  742. 

  743. 

  744.   if (!ljpeg_start (&jh, 0)) return;
    745. 

  745.   jwide = jh.wide * jh.clrs;
    746. 

  746. 

  747. #ifdef LIBRAW_LIBRARY_BUILD
    748. 

  748.   if(cr2_slice[0])
    749. 

  749.       {
    750. 

  750.           for(i=0;i<cr2_slice[0];i++)
    751. 

  751.               slicesW[slicesWcnt++] = cr2_slice[1];
    752. 

  752.           slicesW[slicesWcnt++] = cr2_slice[2];
    753. 

  753.       }
    754. 

  754.   else
    755. 

  755.       {
    756. 

  756.           // not sliced
    757. 

  757.           slicesW[slicesWcnt++] = raw_width; // safe fallback
    758. 

  758.       }
    759. 

  759.        
    760. 

  760.   slices = slicesWcnt * jh.high;
    761. 

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

  762. 

  763.   for(slice=0;slice<slices;slice++)
    764. 

  764.       {
    765. 

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

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

  767.               throw LIBRAW_EXCEPTION_IO_BADFILE; 
    768. 

  768.           t_y++;
    769. 

  769.           if(t_y == jh.high)
    770. 

  770.               {
    771. 

  771.                   t_y = 0;
    772. 

  772.                   t_x += slicesW[t_s++];
    773. 

  773.               }
    774. 

  774.       }
    775. 

  775.   offset[slices] = offset[slices-1];
    776. 

  776.   slice = 1; // next slice
    777. 

  777.   pixno = offset[0]; 
    778. 

  778.   pixelsInSlice = slicesW[0];
    779. 

  779. #endif
    780. 

  780. 

  781. #ifdef LIBRAW_LIBRARY_BUILD
    782. 

  782.   LibRaw_byte_buffer *buf=NULL;
    783. 

  783.   if(data_size)
    784. 

  784.       buf = ifp->make_byte_buffer(data_size);
    785. 

  785.   LibRaw_bit_buffer bits;
    786. 

  786. #endif
    787. 

  787. 

  788.   for (jrow=0; jrow < jh.high; jrow++) {
    789. 

  789. #ifdef LIBRAW_LIBRARY_BUILD
    790. 

  790.       if (buf)
    791. 

  791.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    792. 

  792.       else
    793. 

  793. #endif
    794. 

  794.     rp = ljpeg_row (jrow, &jh);
    795. 

  795.     if (load_flags & 1)
    796. 

  796.       row = jrow & 1 ? height-1-jrow/2 : jrow/2;
    797. 

  797.     for (jcol=0; jcol < jwide; jcol++) {
    798. 

  798.       val = curve[*rp++];
    799. 

  799. #ifndef LIBRAW_LIBRARY_BUILD
    800. 

  800.       // slow dcraw way to calculate row/col
    801. 

  801.       if (cr2_slice[0]) {
    802. 

  802. 	jidx = jrow*jwide + jcol;
    803. 

  803. 	i = jidx / (cr2_slice[1]*jh.high);
    804. 

  804. 	if ((j = i >= cr2_slice[0]))
    805. 

  805. 		 i  = cr2_slice[0];
    806. 

  806. 	jidx -= i * (cr2_slice[1]*jh.high);
    807. 

  807. 	row = jidx / cr2_slice[1+j];
    808. 

  808. 	col = jidx % cr2_slice[1+j] + i*cr2_slice[1];
    809. 

  809.       }
    810. 

  810. #else
    811. 

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

  812.       if(buf) 
    813. 

  813.           {
    814. 

  814.               if(!(load_flags & 1))
    815. 

  815.                   row = pixno/raw_width;
    816. 

  816.               col = pixno % raw_width;
    817. 

  817.               pixno++;
    818. 

  818.               if (0 == --pixelsInSlice)
    819. 

  819.                   {
    820. 

  820.                       unsigned o = offset[slice++];
    821. 

  821.                       pixno = o & 0x0fffffff;
    822. 

  822.                       pixelsInSlice = slicesW[o>>28];
    823. 

  823.                   }
    824. 

  824.           }
    825. 

  825. #endif
    826. 

  826.       if (raw_width == 3984 && (col -= 2) < 0)
    827. 

  827. 	col += (row--,raw_width);
    828. 

  828.       if (row >= 0) RAW(row,col) = val;
    829. 

  829. #ifndef LIBRAW_LIBRARY_BUILD
    830. 

  830.       if (++col >= raw_width)
    831. 

  831. 	col = (row++,0);
    832. 

  832. #else
    833. 

  833.       if(!buf) // 1D or 1Ds case
    834. 

  834.          if (++col >= raw_width)
    835. 

  835.             col = (row++,0);
    836. 

  836. #endif
    837. 

  837.     }
    838. 

  838.   }
    839. 

  839.   ljpeg_end (&jh);
    840. 

  840. #ifdef LIBRAW_LIBRARY_BUILD
    841. 

  841.   if(buf)
    842. 

  842.       delete buf;
    843. 

  843.   free(offset);
    844. 

  844. #endif
    845. 

  845. }
    846. 

  846. 

  847. void CLASS canon_sraw_load_raw()
    848. 

  848. {
    849. 

  849.   struct jhead jh;
    850. 

  850.   short *rp=0, (*ip)[4];
    851. 

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

  852.   int v[3]={0,0,0}, ver, hue;
    853. 

  853.   char *cp;
    854. 

  854. 

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

  856.   jwide = (jh.wide >>= 1) * jh.clrs;
    857. 

  857. 

  858. #ifdef LIBRAW_LIBRARY_BUILD
    859. 

  859.   if(!data_size)
    860. 

  860.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    861. 

  861.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    862. 

  862.   LibRaw_bit_buffer bits;
    863. 

  863. #endif
    864. 

  864. 

  865.   for (ecol=slice=0; slice <= cr2_slice[0]; slice++) {
    866. 

  866.     scol = ecol;
    867. 

  867.     ecol += cr2_slice[1] * 2 / jh.clrs;
    868. 

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

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

  870.       ip = (short (*)[4]) image + row*width;
    871. 

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

  872. 	if ((jcol %= jwide) == 0)
    873. 

  873. #ifdef LIBRAW_LIBRARY_BUILD
    874. 

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

  875. #else
    876. 

  876.             rp = (short *) ljpeg_row (jrow++, &jh);
    877. 

  877. #endif
    878. 

  878. 	if (col >= width) continue;
    879. 

  879. 	FORC (jh.clrs-2)
    880. 

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

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

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

  883.       }
    884. 

  884.     }
    885. 

  885.   }
    886. 

  886.   for (cp=model2; *cp && !isdigit(*cp); cp++);
    887. 

  887.   sscanf (cp, "%d.%d.%d", v, v+1, v+2);
    888. 

  888.   ver = (v[0]*1000 + v[1])*1000 + v[2];
    889. 

  889.   hue = (jh.sraw+1) << 2;
    890. 

  890.   if (unique_id >= 0x80000281 || (unique_id == 0x80000218 && ver > 1000006))
    891. 

  891.     hue = jh.sraw << 1;
    892. 

  892.   ip = (short (*)[4]) image;
    893. 

  893.   rp = ip[0];
    894. 

  894.   for (row=0; row < height; row++, ip+=width) {
    895. 

  895.     if (row & (jh.sraw >> 1))
    896. 

  896.       for (col=0; col < width; col+=2)
    897. 

  897. 	for (c=1; c < 3; c++)
    898. 

  898. 	  if (row == height-1)
    899. 

  899. 	       ip[col][c] =  ip[col-width][c];
    900. 

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

  901.     for (col=1; col < width; col+=2)
    902. 

  902.       for (c=1; c < 3; c++)
    903. 

  903. 	if (col == width-1)
    904. 

  904. 	     ip[col][c] =  ip[col-1][c];
    905. 

  905. 	else ip[col][c] = (ip[col-1][c] + ip[col+1][c] + 1) >> 1;
    906. 

  906.   }
    907. 

  907.   for ( ; rp < ip[0]; rp+=4) {
    908. 

  908.     if (unique_id == 0x80000218 ||
    909. 

  909. 	unique_id == 0x80000250 ||
    910. 

  910. 	unique_id == 0x80000261 ||
    911. 

  911. 	unique_id == 0x80000281 ||
    912. 

  912. 	unique_id == 0x80000287) {
    913. 

  913.       rp[1] = (rp[1] << 2) + hue;
    914. 

  914.       rp[2] = (rp[2] << 2) + hue;
    915. 

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

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

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

  918.     } else {
    919. 

  919.       if (unique_id < 0x80000218) rp[0] -= 512;
    920. 

  920.       pix[0] = rp[0] + rp[2];
    921. 

  921.       pix[2] = rp[0] + rp[1];
    922. 

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

  923.     }
    924. 

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

  925.   }
    926. 

  926. #ifdef LIBRAW_LIBRARY_BUILD
    927. 

  927.   delete buf;
    928. 

  928. #endif
    929. 

  929.   ljpeg_end (&jh);
    930. 

  930.   maximum = 0x3fff;
    931. 

  931. }
    932. 

  932. 

  933. #ifndef LIBRAW_LIBRARY_BUILD
    934. 

  934. void CLASS adobe_copy_pixel (unsigned row, unsigned col, ushort **rp)
    935. 

  935. {
    936. 

  936.   int c;
    937. 

  937. 

  938.   if (is_raw == 2 && shot_select) (*rp)++;
    939. 

  939.   if (raw_image) {
    940. 

  940.     if (row < raw_height && col < raw_width)
    941. 

  941.       RAW(row,col) = curve[**rp];
    942. 

  942.     *rp += is_raw;
    943. 

  943.   } else {
    944. 

  944.     if (row < height && col < width)
    945. 

  945.       FORC(tiff_samples)
    946. 

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

  947.     *rp += tiff_samples;
    948. 

  948.   }
    949. 

  949.   if (is_raw == 2 && shot_select) (*rp)--;
    950. 

  950. }
    951. 

  951. #else
    952. 

  952. void CLASS adobe_copy_pixel_raw (unsigned row, unsigned col, ushort **rp)
    953. 

  953. {
    954. 

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

  955.   if (row < raw_height && col < raw_width)
    956. 

  956.     RAW(row,col) = curve[**rp];
    957. 

  957.   *rp += is_raw;
    958. 

  958.   if (is_raw == 2 && shot_select) (*rp)--;
    959. 

  959. }
    960. 

  960. void CLASS adobe_copy_pixel_color (unsigned row, unsigned col, ushort **rp)
    961. 

  961. {
    962. 

  962.   int c;
    963. 

  963. 

  964.   if (is_raw == 2 && shot_select) (*rp)++;
    965. 

  965.   if (row < height && col < width)
    966. 

  966.     FORC(tiff_samples)
    967. 

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

  968.   *rp += tiff_samples;
    969. 

  969.   if (is_raw == 2 && shot_select) (*rp)--;
    970. 

  970. }
    971. 

  971. #endif
    972. 

  972. 

  973. 

  974. void CLASS lossless_dng_load_raw()
    975. 

  975. {
    976. 

  976.   unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col;
    977. 

  977.   struct jhead jh;
    978. 

  978.   ushort *rp;
    979. 

  979. 

  980.   while (trow < raw_height) {
    981. 

  981.     save = ftell(ifp);
    982. 

  982.     if (tile_length < INT_MAX)
    983. 

  983.       fseek (ifp, get4(), SEEK_SET);
    984. 

  984.     if (!ljpeg_start (&jh, 0)) break;
    985. 

  985.     jwide = jh.wide;
    986. 

  986.     if (filters) jwide *= jh.clrs;
    987. 

  987.     jwide /= is_raw;
    988. 

  988. #ifdef LIBRAW_LIBRARY_BUILD
    989. 

  989.     if(!data_size)
    990. 

  990.         throw LIBRAW_EXCEPTION_IO_BADFILE;
    991. 

  991.     LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    992. 

  992.     LibRaw_bit_buffer bits;
    993. 

  993. #endif
    994. 

  994. 

  995. #ifndef LIBRAW_LIBRARY_BUILD
    996. 

  996.     for (row=col=jrow=0; jrow < jh.high; jrow++) {
    997. 

  997.       rp = ljpeg_row (jrow, &jh);
    998. 

  998.       for (jcol=0; jcol < jwide; jcol++) {
    999. 

  999. 	adobe_copy_pixel (trow+row, tcol+col, &rp);
    1000. 

  1000. 	if (++col >= tile_width || col >= raw_width)
    1001. 

  1001. 	  row += 1 + (col = 0);
    1002. 

  1002.       }
    1003. 

  1003.     }
    1004. 

  1004. #else
    1005. 

  1005.     if(raw_image)
    1006. 

  1006.       {
    1007. 

  1007.         for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1008. 

  1008. #ifdef LIBRAW_LIBRARY_BUILD
    1009. 

  1009.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    1010. 

  1010. #else
    1011. 

  1011.           rp = ljpeg_row (jrow, &jh);
    1012. 

  1012. #endif
    1013. 

  1013.           for (jcol=0; jcol < jwide; jcol++) {
    1014. 

  1014.             adobe_copy_pixel_raw (trow+row, tcol+col, &rp);
    1015. 

  1015.             if (++col >= tile_width || col >= raw_width)
    1016. 

  1016.               row += 1 + (col = 0);
    1017. 

  1017.           }
    1018. 

  1018.         }
    1019. 

  1019.       }
    1020. 

  1020.     else
    1021. 

  1021.       {
    1022. 

  1022.         for (row=col=jrow=0; jrow < jh.high; jrow++) {
    1023. 

  1023. #ifdef LIBRAW_LIBRARY_BUILD
    1024. 

  1024.           rp = ljpeg_row_new (jrow, &jh,bits,buf);
    1025. 

  1025. #else
    1026. 

  1026.           rp = ljpeg_row (jrow, &jh);
    1027. 

  1027. #endif
    1028. 

  1028.           for (jcol=0; jcol < jwide; jcol++) {
    1029. 

  1029.             adobe_copy_pixel_color (trow+row, tcol+col, &rp);
    1030. 

  1030.             if (++col >= tile_width || col >= raw_width)
    1031. 

  1031.               row += 1 + (col = 0);
    1032. 

  1032.           }
    1033. 

  1033.         }
    1034. 

  1034.       }
    1035. 

  1035. #endif
    1036. 

  1036.     fseek (ifp, save+4, SEEK_SET);
    1037. 

  1037.     if ((tcol += tile_width) >= raw_width)
    1038. 

  1038.       trow += tile_length + (tcol = 0);
    1039. 

  1039.     ljpeg_end (&jh);
    1040. 

  1040. #ifdef LIBRAW_LIBRARY_BUILD
    1041. 

  1041.     delete buf;
    1042. 

  1042. #endif
    1043. 

  1043.   }
    1044. 

  1044. }
    1045. 

  1045. 

  1046. void CLASS packed_dng_load_raw()
    1047. 

  1047. {
    1048. 

  1048.   ushort *pixel, *rp;
    1049. 

  1049.   int row, col;
    1050. 

  1050. 

  1051.   pixel = (ushort *) calloc (raw_width * tiff_samples, sizeof *pixel);
    1052. 

  1052.   merror (pixel, "packed_dng_load_raw()");
    1053. 

  1053. 

  1054. #ifdef LIBRAW_LIBRARY_BUILD
    1055. 

  1055.   int dsz= raw_height*raw_width * tiff_samples * tiff_bps/8;
    1056. 

  1056.   LibRaw_byte_buffer *buf = NULL;
    1057. 

  1057.   if (tiff_bps != 16)
    1058. 

  1058.       {
    1059. 

  1059.           buf = ifp->make_byte_buffer(dsz);
    1060. 

  1060.       }
    1061. 

  1061.   LibRaw_bit_buffer bits;
    1062. 

  1062. #endif
    1063. 

  1063. 

  1064.   for (row=0; row < raw_height; row++) {
    1065. 

  1065.     if (tiff_bps == 16)
    1066. 

  1066.       read_shorts (pixel, raw_width * tiff_samples);
    1067. 

  1067.     else {
    1068. 

  1068. #ifdef LIBRAW_LIBRARY_BUILD
    1069. 

  1069.         bits.reset();
    1070. 

  1070.         for (col=0; col < raw_width * tiff_samples; col++)
    1071. 

  1071.             pixel[col] = bits._getbits(buf,tiff_bps,zero_after_ff);
    1072. 

  1072. 

  1073. #else
    1074. 

  1074.       getbits(-1);
    1075. 

  1075.       for (col=0; col < raw_width * tiff_samples; col++)
    1076. 

  1076. 	pixel[col] = getbits(tiff_bps);
    1077. 

  1077. #endif
    1078. 

  1078.     }
    1079. 

  1079. #ifndef LIBRAW_LIBRARY_BUILD
    1080. 

  1080.     for (rp=pixel, col=0; col < raw_width; col++)
    1081. 

  1081.       adobe_copy_pixel (row, col, &rp);
    1082. 

  1082. #else
    1083. 

  1083.     if(raw_image)
    1084. 

  1084.       for (rp=pixel, col=0; col < raw_width; col++)
    1085. 

  1085.         adobe_copy_pixel_raw (row, col, &rp);
    1086. 

  1086.     else
    1087. 

  1087.       for (rp=pixel, col=0; col < raw_width; col++)
    1088. 

  1088.         adobe_copy_pixel_color (row, col, &rp);
    1089. 

  1089. #endif
    1090. 

  1090.   }
    1091. 

  1091.   free (pixel);
    1092. 

  1092. #ifdef LIBRAW_LIBRARY_BUILD
    1093. 

  1093.     if(buf)
    1094. 

  1094.         delete buf;
    1095. 

  1095. #endif
    1096. 

  1096. }
    1097. 

  1097. 

  1098. void CLASS pentax_load_raw()
    1099. 

  1099. {
    1100. 

  1100.   ushort bit[2][15], huff[4097];
    1101. 

  1101.   int dep, row, col, diff, c, i;
    1102. 

  1102.   ushort vpred[2][2] = {{0,0},{0,0}}, hpred[2];
    1103. 

  1103. 

  1104.   fseek (ifp, meta_offset, SEEK_SET);
    1105. 

  1105.   dep = (get2() + 12) & 15;
    1106. 

  1106.   fseek (ifp, 12, SEEK_CUR);
    1107. 

  1107.   FORC(dep) bit[0][c] = get2();
    1108. 

  1108.   FORC(dep) bit[1][c] = fgetc(ifp);
    1109. 

  1109.   FORC(dep)
    1110. 

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

  1111.       huff[++i] = bit[1][c] << 8 | c;
    1112. 

  1112.   huff[0] = 12;
    1113. 

  1113.   fseek (ifp, data_offset, SEEK_SET);
    1114. 

  1114.   getbits(-1);
    1115. 

  1115.   for (row=0; row < raw_height; row++)
    1116. 

  1116.     for (col=0; col < raw_width; col++) {
    1117. 

  1117.       diff = ljpeg_diff (huff);
    1118. 

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

  1119.       else	   hpred[col & 1] += diff;
    1120. 

  1120.       RAW(row,col) = hpred[col & 1];
    1121. 

  1121.       if (hpred[col & 1] >> tiff_bps) derror();
    1122. 

  1122.     }
    1123. 

  1123. }
    1124. 

  1124. 

  1125. void CLASS nikon_load_raw()
    1126. 

  1126. {
    1127. 

  1127.   static const uchar nikon_tree[][32] = {
    1128. 

  1128.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy */
    1129. 

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

  1130.     { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0,	/* 12-bit lossy after split */
    1131. 

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

  1132.     { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0,  /* 12-bit lossless */
    1133. 

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

  1134.     { 0,1,4,3,1,1,1,1,1,2,0,0,0,0,0,0,	/* 14-bit lossy */
    1135. 

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

  1136.     { 0,1,5,1,1,1,1,1,1,1,2,0,0,0,0,0,	/* 14-bit lossy after split */
    1137. 

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

  1138.     { 0,1,4,2,2,3,1,2,0,0,0,0,0,0,0,0,	/* 14-bit lossless */
    1139. 

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

  1140.   ushort *huff, ver0, ver1, vpred[2][2], hpred[2], csize;
    1141. 

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

  1142. 

  1143.   fseek (ifp, meta_offset, SEEK_SET);
    1144. 

  1144.   ver0 = fgetc(ifp);
    1145. 

  1145.   ver1 = fgetc(ifp);
    1146. 

  1146.   if (ver0 == 0x49 || ver1 == 0x58)
    1147. 

  1147.     fseek (ifp, 2110, SEEK_CUR);
    1148. 

  1148.   if (ver0 == 0x46) tree = 2;
    1149. 

  1149.   if (tiff_bps == 14) tree += 3;
    1150. 

  1150.   read_shorts (vpred[0], 4);
    1151. 

  1151.   max = 1 << tiff_bps & 0x7fff;
    1152. 

  1152.   if ((csize = get2()) > 1)
    1153. 

  1153.     step = max / (csize-1);
    1154. 

  1154.   if (ver0 == 0x44 && ver1 == 0x20 && step > 0) {
    1155. 

  1155.     for (i=0; i < csize; i++)
    1156. 

  1156.       curve[i*step] = get2();
    1157. 

  1157.     for (i=0; i < max; i++)
    1158. 

  1158.       curve[i] = ( curve[i-i%step]*(step-i%step) +
    1159. 

  1159. 		   curve[i-i%step+step]*(i%step) ) / step;
    1160. 

  1160.     fseek (ifp, meta_offset+562, SEEK_SET);
    1161. 

  1161.     split = get2();
    1162. 

  1162.   } else if (ver0 != 0x46 && csize <= 0x4001)
    1163. 

  1163.     read_shorts (curve, max=csize);
    1164. 

  1164.   while (curve[max-2] == curve[max-1]) max--;
    1165. 

  1165.   huff = make_decoder (nikon_tree[tree]);
    1166. 

  1166.   fseek (ifp, data_offset, SEEK_SET);
    1167. 

  1167. #ifdef LIBRAW_LIBRARY_BUILD
    1168. 

  1168.   if(!data_size)
    1169. 

  1169.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1170. 

  1170.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1171. 

  1171.   LibRaw_bit_buffer bits;
    1172. 

  1172.   bits.reset();
    1173. 

  1173. #else
    1174. 

  1174.   getbits(-1);
    1175. 

  1175. #endif
    1176. 

  1176.   for (min=row=0; row < height; row++) {
    1177. 

  1177.     if (split && row == split) {
    1178. 

  1178.       free (huff);
    1179. 

  1179.       huff = make_decoder (nikon_tree[tree+1]);
    1180. 

  1180.       max += (min = 16) << 1;
    1181. 

  1181.     }
    1182. 

  1182.     for (col=0; col < raw_width; col++) {
    1183. 

  1183. #ifdef LIBRAW_LIBRARY_BUILD
    1184. 

  1184.         i = bits._gethuff(buf,*huff,huff+1,zero_after_ff);
    1185. 

  1185. #else
    1186. 

  1186.       i = gethuff(huff);
    1187. 

  1187. #endif
    1188. 

  1188.       len = i & 15;
    1189. 

  1189.       shl = i >> 4;
    1190. 

  1190. #ifdef LIBRAW_LIBRARY_BUILD
    1191. 

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

  1192. #else
    1193. 

  1193.       diff = ((getbits(len-shl) << 1) + 1) << shl >> 1;
    1194. 

  1194. #endif
    1195. 

  1195.       if ((diff & (1 << (len-1))) == 0)
    1196. 

  1196. 	diff -= (1 << len) - !shl;
    1197. 

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

  1198.       else	   hpred[col & 1] += diff;
    1199. 

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

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

  1201.     }
    1202. 

  1202.   }
    1203. 

  1203. #ifdef LIBRAW_LIBRARY_BUILD
    1204. 

  1204.   delete buf;
    1205. 

  1205. #endif
    1206. 

  1206.   free (huff);
    1207. 

  1207. }
    1208. 

  1208. 

  1209. /*
    1210. 

  1210.    Returns 1 for a Coolpix 995, 0 for anything else.
    1211. 

  1211.  */
    1212. 

  1212. int CLASS nikon_e995()
    1213. 

  1213. {
    1214. 

  1214.   int i, histo[256];
    1215. 

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

  1216. 

  1217.   memset (histo, 0, sizeof histo);
    1218. 

  1218.   fseek (ifp, -2000, SEEK_END);
    1219. 

  1219.   for (i=0; i < 2000; i++)
    1220. 

  1220.     histo[fgetc(ifp)]++;
    1221. 

  1221.   for (i=0; i < 4; i++)
    1222. 

  1222.     if (histo[often[i]] < 200)
    1223. 

  1223.       return 0;
    1224. 

  1224.   return 1;
    1225. 

  1225. }
    1226. 

  1226. 

  1227. /*
    1228. 

  1228.    Returns 1 for a Coolpix 2100, 0 for anything else.
    1229. 

  1229.  */
    1230. 

  1230. int CLASS nikon_e2100()
    1231. 

  1231. {
    1232. 

  1232.   uchar t[12];
    1233. 

  1233.   int i;
    1234. 

  1234. 

  1235.   fseek (ifp, 0, SEEK_SET);
    1236. 

  1236.   for (i=0; i < 1024; i++) {
    1237. 

  1237.     fread (t, 1, 12, ifp);
    1238. 

  1238.     if (((t[2] & t[4] & t[7] & t[9]) >> 4
    1239. 

  1239. 	& t[1] & t[6] & t[8] & t[11] & 3) != 3)
    1240. 

  1240.       return 0;
    1241. 

  1241.   }
    1242. 

  1242.   return 1;
    1243. 

  1243. }
    1244. 

  1244. 

  1245. void CLASS nikon_3700()
    1246. 

  1246. {
    1247. 

  1247.   int bits, i;
    1248. 

  1248.   uchar dp[24];
    1249. 

  1249.   static const struct {
    1250. 

  1250.     int bits;
    1251. 

  1251.     char t_make[12], t_model[15];
    1252. 

  1252.   } table[] = {
    1253. 

  1253.     { 0x00, "PENTAX",  "Optio 33WR" },
    1254. 

  1254.     { 0x03, "NIKON",   "E3200" },
    1255. 

  1255.     { 0x32, "NIKON",   "E3700" },
    1256. 

  1256.     { 0x33, "OLYMPUS", "C740UZ" } };
    1257. 

  1257. 

  1258.   fseek (ifp, 3072, SEEK_SET);
    1259. 

  1259.   fread (dp, 1, 24, ifp);
    1260. 

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

  1261.   for (i=0; i < sizeof table / sizeof *table; i++)
    1262. 

  1262.     if (bits == table[i].bits) {
    1263. 

  1263.       strcpy (make,  table[i].t_make );
    1264. 

  1264.       strcpy (model, table[i].t_model);
    1265. 

  1265.     }
    1266. 

  1266. }
    1267. 

  1267. 

  1268. /*
    1269. 

  1269.    Separates a Minolta DiMAGE Z2 from a Nikon E4300.
    1270. 

  1270.  */
    1271. 

  1271. int CLASS minolta_z2()
    1272. 

  1272. {
    1273. 

  1273.   int i, nz;
    1274. 

  1274.   char tail[424];
    1275. 

  1275. 

  1276.   fseek (ifp, -sizeof tail, SEEK_END);
    1277. 

  1277.   fread (tail, 1, sizeof tail, ifp);
    1278. 

  1278.   for (nz=i=0; i < sizeof tail; i++)
    1279. 

  1279.     if (tail[i]) nz++;
    1280. 

  1280.   return nz > 20;
    1281. 

  1281. }
    1282. 

  1282. void CLASS ppm_thumb()
    1283. 

  1283. {
    1284. 

  1284.   char *thumb;
    1285. 

  1285.   thumb_length = thumb_width*thumb_height*3;
    1286. 

  1286.   thumb = (char *) malloc (thumb_length);
    1287. 

  1287.   merror (thumb, "ppm_thumb()");
    1288. 

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

  1289.   fread  (thumb, 1, thumb_length, ifp);
    1290. 

  1290.   fwrite (thumb, 1, thumb_length, ofp);
    1291. 

  1291.   free (thumb);
    1292. 

  1292. }
    1293. 

  1293. 

  1294. void CLASS ppm16_thumb()
    1295. 

  1295. {
    1296. 

  1296.   int i;
    1297. 

  1297.   char *thumb;
    1298. 

  1298.   thumb_length = thumb_width*thumb_height*3;
    1299. 

  1299.   thumb = (char *) calloc (thumb_length,2);
    1300. 

  1300.   merror (thumb, "ppm16_thumb()");
    1301. 

  1301.   read_shorts ((ushort *) thumb, thumb_length);
    1302. 

  1302.   for (i=0; i < thumb_length; i++)
    1303. 

  1303.     thumb[i] = ((ushort *) thumb)[i] >> 8;
    1304. 

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

  1305.   fwrite (thumb, 1, thumb_length, ofp);
    1306. 

  1306.   free (thumb);
    1307. 

  1307. }
    1308. 

  1308. 

  1309. void CLASS layer_thumb()
    1310. 

  1310. {
    1311. 

  1311.   int i, c;
    1312. 

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

  1313. 

  1314.   colors = thumb_misc >> 5 & 7;
    1315. 

  1315.   thumb_length = thumb_width*thumb_height;
    1316. 

  1316.   thumb = (char *) calloc (colors, thumb_length);
    1317. 

  1317.   merror (thumb, "layer_thumb()");
    1318. 

  1318.   fprintf (ofp, "P%d\n%d %d\n255\n",
    1319. 

  1319. 	5 + (colors >> 1), thumb_width, thumb_height);
    1320. 

  1320.   fread (thumb, thumb_length, colors, ifp);
    1321. 

  1321.   for (i=0; i < thumb_length; i++)
    1322. 

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

  1323.   free (thumb);
    1324. 

  1324. }
    1325. 

  1325. 

  1326. void CLASS rollei_thumb()
    1327. 

  1327. {
    1328. 

  1328.   unsigned i;
    1329. 

  1329.   ushort *thumb;
    1330. 

  1330. 

  1331.   thumb_length = thumb_width * thumb_height;
    1332. 

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

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

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

  1335.   read_shorts (thumb, thumb_length);
    1336. 

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

  1337.     putc (thumb[i] << 3, ofp);
    1338. 

  1338.     putc (thumb[i] >> 5  << 2, ofp);
    1339. 

  1339.     putc (thumb[i] >> 11 << 3, ofp);
    1340. 

  1340.   }
    1341. 

  1341.   free (thumb);
    1342. 

  1342. }
    1343. 

  1343. 

  1344. void CLASS rollei_load_raw()
    1345. 

  1345. {
    1346. 

  1346.   uchar pixel[10];
    1347. 

  1347.   unsigned iten=0, isix, i, buffer=0, todo[16];
    1348. 

  1348. 

  1349.   isix = raw_width * raw_height * 5 / 8;
    1350. 

  1350.   while (fread (pixel, 1, 10, ifp) == 10) {
    1351. 

  1351.     for (i=0; i < 10; i+=2) {
    1352. 

  1352.       todo[i]   = iten++;
    1353. 

  1353.       todo[i+1] = pixel[i] << 8 | pixel[i+1];
    1354. 

  1354.       buffer    = pixel[i] >> 2 | buffer << 6;
    1355. 

  1355.     }
    1356. 

  1356.     for (   ; i < 16; i+=2) {
    1357. 

  1357.       todo[i]   = isix++;
    1358. 

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

  1359.     }
    1360. 

  1360.     for (i=0; i < 16; i+=2)
    1361. 

  1361.       raw_image[todo[i]] = (todo[i+1] & 0x3ff);
    1362. 

  1362.   }
    1363. 

  1363.   maximum = 0x3ff;
    1364. 

  1364. }
    1365. 

  1365. 

  1366. int CLASS raw (unsigned row, unsigned col)
    1367. 

  1367. {
    1368. 

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

  1369. }
    1370. 

  1370. 

  1371. void CLASS phase_one_flat_field (int is_float, int nc)
    1372. 

  1372. {
    1373. 

  1373.   ushort head[8];
    1374. 

  1374.   unsigned wide, y, x, c, rend, cend, row, col;
    1375. 

  1375.   float *mrow, num, mult[4];
    1376. 

  1376. 

  1377.   read_shorts (head, 8);
    1378. 

  1378.   wide = head[2] / head[4];
    1379. 

  1379.   mrow = (float *) calloc (nc*wide, sizeof *mrow);
    1380. 

  1380.   merror (mrow, "phase_one_flat_field()");
    1381. 

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

  1382.     for (x=0; x < wide; x++)
    1383. 

  1383.       for (c=0; c < nc; c+=2) {
    1384. 

  1384. 	num = is_float ? getreal(11) : get2()/32768.0;
    1385. 

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

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

  1387.       }
    1388. 

  1388.     if (y==0) continue;
    1389. 

  1389.     rend = head[1] + y*head[5];
    1390. 

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

  1391.       for (x=1; x < wide; x++) {
    1392. 

  1392. 	for (c=0; c < nc; c+=2) {
    1393. 

  1393. 	  mult[c] = mrow[c*wide+x-1];
    1394. 

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

  1395. 	}
    1396. 

  1396. 	cend = head[0] + x*head[4];
    1397. 

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

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

  1399. 	  if (!(c & 1)) {
    1400. 

  1400. 	    c = RAW(row,col) * mult[c];
    1401. 

  1401. 	    RAW(row,col) = LIM(c,0,65535);
    1402. 

  1402. 	  }
    1403. 

  1403. 	  for (c=0; c < nc; c+=2)
    1404. 

  1404. 	    mult[c] += mult[c+1];
    1405. 

  1405. 	}
    1406. 

  1406.       }
    1407. 

  1407.       for (x=0; x < wide; x++)
    1408. 

  1408. 	for (c=0; c < nc; c+=2)
    1409. 

  1409. 	  mrow[c*wide+x] += mrow[(c+1)*wide+x];
    1410. 

  1410.     }
    1411. 

  1411.   }
    1412. 

  1412.   free (mrow);
    1413. 

  1413. }
    1414. 

  1414. 

  1415. void CLASS phase_one_correct()
    1416. 

  1416. {
    1417. 

  1417.   unsigned entries, tag, data, save, col, row, type;
    1418. 

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

  1419.   int head[9], diff, mindiff=INT_MAX, off_412=0;
    1420. 

  1420.   static const signed char dir[12][2] =
    1421. 

  1421.     { {-1,-1}, {-1,1}, {1,-1}, {1,1}, {-2,0}, {0,-2}, {0,2}, {2,0},
    1422. 

  1422.       {-2,-2}, {-2,2}, {2,-2}, {2,2} };
    1423. 

  1423.   float poly[8], num, cfrac, frac, mult[2], *yval[2];
    1424. 

  1424.   ushort *xval[2];
    1425. 

  1425. 

  1426.   if (half_size || !meta_length) return;
    1427. 

  1427. #ifdef DCRAW_VERBOSE
    1428. 

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

  1429. #endif
    1430. 

  1430.   fseek (ifp, meta_offset, SEEK_SET);
    1431. 

  1431.   order = get2();
    1432. 

  1432.   fseek (ifp, 6, SEEK_CUR);
    1433. 

  1433.   fseek (ifp, meta_offset+get4(), SEEK_SET);
    1434. 

  1434.   entries = get4();  get4();
    1435. 

  1435.   while (entries--) {
    1436. 

  1436.     tag  = get4();
    1437. 

  1437.     len  = get4();
    1438. 

  1438.     data = get4();
    1439. 

  1439.     save = ftell(ifp);
    1440. 

  1440.     fseek (ifp, meta_offset+data, SEEK_SET);
    1441. 

  1441.     if (tag == 0x419) {				/* Polynomial curve */
    1442. 

  1442.       for (get4(), i=0; i < 8; i++)
    1443. 

  1443. 	poly[i] = getreal(11);
    1444. 

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

  1445.       for (i=0; i < 0x10000; i++) {
    1446. 

  1446. 	num = (poly[5]*i + poly[3])*i + poly[1];
    1447. 

  1447. 	curve[i] = LIM(num,0,65535);
    1448. 

  1448.       } goto apply;				/* apply to right half */
    1449. 

  1449.     } else if (tag == 0x41a) {			/* Polynomial curve */
    1450. 

  1450.       for (i=0; i < 4; i++)
    1451. 

  1451. 	poly[i] = getreal(11);
    1452. 

  1452.       for (i=0; i < 0x10000; i++) {
    1453. 

  1453. 	for (num=0, j=4; j--; )
    1454. 

  1454. 	  num = num * i + poly[j];
    1455. 

  1455. 	curve[i] = LIM(num+i,0,65535);
    1456. 

  1456.       } apply:					/* apply to whole image */
    1457. 

  1457.       for (row=0; row < raw_height; row++)
    1458. 

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

  1459. 	  RAW(row,col) = curve[RAW(row,col)];
    1460. 

  1460.     } else if (tag == 0x400) {			/* Sensor defects */
    1461. 

  1461.       while ((len -= 8) >= 0) {
    1462. 

  1462. 	col  = get2();
    1463. 

  1463. 	row  = get2();
    1464. 

  1464. 	type = get2(); get2();
    1465. 

  1465. 	if (col >= raw_width) continue;
    1466. 

  1466. 	if (type == 131)			/* Bad column */
    1467. 

  1467. 	  for (row=0; row < raw_height; row++)
    1468. 

  1468. 	    if (FC(row-top_margin,col-left_margin) == 1) {
    1469. 

  1469. 	      for (sum=i=0; i < 4; i++)
    1470. 

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

  1471. 	      for (max=i=0; i < 4; i++) {
    1472. 

  1472. 		dev[i] = abs((val[i] << 2) - sum);
    1473. 

  1473. 		if (dev[max] < dev[i]) max = i;
    1474. 

  1474. 	      }
    1475. 

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

  1476. 	    } else {
    1477. 

  1477. 	      for (sum=0, i=8; i < 12; i++)
    1478. 

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

  1479. 	      RAW(row,col) = 0.5 + sum * 0.0732233 +
    1480. 

  1480. 		(raw(row,col-2) + raw(row,col+2)) * 0.3535534;
    1481. 

  1481. 	    }
    1482. 

  1482. 	else if (type == 129) {			/* Bad pixel */
    1483. 

  1483. 	  if (row >= raw_height) continue;
    1484. 

  1484. 	  j = (FC(row-top_margin,col-left_margin) != 1) * 4;
    1485. 

  1485. 	  for (sum=0, i=j; i < j+8; i++)
    1486. 

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

  1487. 	  RAW(row,col) = (sum + 4) >> 3;
    1488. 

  1488. 	}
    1489. 

  1489.       }
    1490. 

  1490.     } else if (tag == 0x401) {			/* All-color flat fields */
    1491. 

  1491.       phase_one_flat_field (1, 2);
    1492. 

  1492.     } else if (tag == 0x416 || tag == 0x410) {
    1493. 

  1493.       phase_one_flat_field (0, 2);
    1494. 

  1494.     } else if (tag == 0x40b) {			/* Red+blue flat field */
    1495. 

  1495.       phase_one_flat_field (0, 4);
    1496. 

  1496.     } else if (tag == 0x412) {
    1497. 

  1497.       fseek (ifp, 36, SEEK_CUR);
    1498. 

  1498.       diff = abs (get2() - ph1.tag_21a);
    1499. 

  1499.       if (mindiff > diff) {
    1500. 

  1500. 	mindiff = diff;
    1501. 

  1501. 	off_412 = ftell(ifp) - 38;
    1502. 

  1502.       }
    1503. 

  1503.     }
    1504. 

  1504.     fseek (ifp, save, SEEK_SET);
    1505. 

  1505.   }
    1506. 

  1506.   if (off_412) {
    1507. 

  1507.     fseek (ifp, off_412, SEEK_SET);
    1508. 

  1508.     for (i=0; i < 9; i++) head[i] = get4() & 0x7fff;
    1509. 

  1509.     yval[0] = (float *) calloc (head[1]*head[3] + head[2]*head[4], 6);
    1510. 

  1510.     merror (yval[0], "phase_one_correct()");
    1511. 

  1511.     yval[1] = (float  *) (yval[0] + head[1]*head[3]);
    1512. 

  1512.     xval[0] = (ushort *) (yval[1] + head[2]*head[4]);
    1513. 

  1513.     xval[1] = (ushort *) (xval[0] + head[1]*head[3]);
    1514. 

  1514.     get2();
    1515. 

  1515.     for (i=0; i < 2; i++)
    1516. 

  1516.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1517. 

  1517. 	yval[i][j] = getreal(11);
    1518. 

  1518.     for (i=0; i < 2; i++)
    1519. 

  1519.       for (j=0; j < head[i+1]*head[i+3]; j++)
    1520. 

  1520. 	xval[i][j] = get2();
    1521. 

  1521.     for (row=0; row < raw_height; row++)
    1522. 

  1522.       for (col=0; col < raw_width; col++) {
    1523. 

  1523. 	cfrac = (float) col * head[3] / raw_width;
    1524. 

  1524. 	cfrac -= cip = cfrac;
    1525. 

  1525. 	num = RAW(row,col) * 0.5;
    1526. 

  1526. 	for (i=cip; i < cip+2; i++) {
    1527. 

  1527. 	  for (k=j=0; j < head[1]; j++)
    1528. 

  1528. 	    if (num < xval[0][k = head[1]*i+j]) break;
    1529. 

  1529. 	  frac = (j == 0 || j == head[1]) ? 0 :
    1530. 

  1530. 		(xval[0][k] - num) / (xval[0][k] - xval[0][k-1]);
    1531. 

  1531. 	  mult[i-cip] = yval[0][k-1] * frac + yval[0][k] * (1-frac);
    1532. 

  1532. 	}
    1533. 

  1533. 	i = ((mult[0] * (1-cfrac) + mult[1] * cfrac) * row + num) * 2;
    1534. 

  1534. 	RAW(row,col) = LIM(i,0,65535);
    1535. 

  1535.       }
    1536. 

  1536.     free (yval[0]);
    1537. 

  1537.   }
    1538. 

  1538. }
    1539. 

  1539. 

  1540. void CLASS phase_one_load_raw()
    1541. 

  1541. {
    1542. 

  1542.   int a, b, i;
    1543. 

  1543.   ushort akey, bkey, t_mask;
    1544. 

  1544. 

  1545.   fseek (ifp, ph1.key_off, SEEK_SET);
    1546. 

  1546.   akey = get2();
    1547. 

  1547.   bkey = get2();
    1548. 

  1548.   t_mask = ph1.format == 1 ? 0x5555:0x1354;
    1549. 

  1549.   fseek (ifp, data_offset, SEEK_SET);
    1550. 

  1550.   read_shorts (raw_image, raw_width*raw_height);
    1551. 

  1551.   if (ph1.format)
    1552. 

  1552.     for (i=0; i < raw_width*raw_height; i+=2) {
    1553. 

  1553.       a = raw_image[i+0] ^ akey;
    1554. 

  1554.       b = raw_image[i+1] ^ bkey;
    1555. 

  1555.       raw_image[i+0] = (a & t_mask) | (b & ~t_mask);
    1556. 

  1556.       raw_image[i+1] = (b & t_mask) | (a & ~t_mask);
    1557. 

  1557.     }
    1558. 

  1558. }
    1559. 

  1559. 

  1560. unsigned CLASS ph1_bithuff (int nbits, ushort *huff)
    1561. 

  1561. {
    1562. 

  1562. #ifndef LIBRAW_NOTHREADS
    1563. 

  1563. #define bitbuf tls->ph1_bits.bitbuf
    1564. 

  1564. #define vbits  tls->ph1_bits.vbits    
    1565. 

  1565. #else
    1566. 

  1566.   static UINT64 bitbuf=0;
    1567. 

  1567.   static int vbits=0;
    1568. 

  1568. #endif
    1569. 

  1569.   unsigned c;
    1570. 

  1570. 

  1571.   if (nbits == -1)
    1572. 

  1572.     return bitbuf = vbits = 0;
    1573. 

  1573.   if (nbits == 0) return 0;
    1574. 

  1574.   if (vbits < nbits) {
    1575. 

  1575.     bitbuf = bitbuf << 32 | get4();
    1576. 

  1576.     vbits += 32;
    1577. 

  1577.   }
    1578. 

  1578.   c = bitbuf << (64-vbits) >> (64-nbits);
    1579. 

  1579.   if (huff) {
    1580. 

  1580.     vbits -= huff[c] >> 8;
    1581. 

  1581.     return (uchar) huff[c];
    1582. 

  1582.   }
    1583. 

  1583.   vbits -= nbits;
    1584. 

  1584.   return c;
    1585. 

  1585. #ifndef LIBRAW_NOTHREADS
    1586. 

  1586. #undef bitbuf
    1587. 

  1587. #undef vbits
    1588. 

  1588. #endif
    1589. 

  1589. }
    1590. 

  1590. #define ph1_bits(n) ph1_bithuff(n,0)
    1591. 

  1591. #define ph1_huff(h) ph1_bithuff(*h,h+1)
    1592. 

  1592. 

  1593. void CLASS phase_one_load_raw_c()
    1594. 

  1594. {
    1595. 

  1595.   static const int length[] = { 8,7,6,9,11,10,5,12,14,13 };
    1596. 

  1596.   int *offset, len[2], pred[2], row, col, i, j;
    1597. 

  1597.   ushort *pixel;
    1598. 

  1598.   short (*t_black)[2];
    1599. 

  1599. 

  1600.   pixel = (ushort *) calloc (raw_width + raw_height*4, 2);
    1601. 

  1601.   merror (pixel, "phase_one_load_raw_c()");
    1602. 

  1602.   offset = (int *) (pixel + raw_width);
    1603. 

  1603.   fseek (ifp, strip_offset, SEEK_SET);
    1604. 

  1604.   for (row=0; row < raw_height; row++)
    1605. 

  1605.     offset[row] = get4();
    1606. 

  1606.   t_black = (short (*)[2]) offset + raw_height;
    1607. 

  1607.   fseek (ifp, ph1.black_off, SEEK_SET);
    1608. 

  1608.   if (ph1.black_off)
    1609. 

  1609.       {
    1610. 

  1610.           read_shorts ((ushort *) t_black[0], raw_height*2);
    1611. 

  1611. #ifdef LIBRAW_LIBRARY_BUILD
    1612. 

  1612.           imgdata.rawdata.ph1_black = (short (*)[2])calloc(raw_height*2,sizeof(short));
    1613. 

  1613.           merror (imgdata.rawdata.ph1_black, "phase_one_load_raw_c()");
    1614. 

  1614.           memmove(imgdata.rawdata.ph1_black,(short *) t_black[0],raw_height*2*sizeof(short));
    1615. 

  1615. #endif
    1616. 

  1616.       }
    1617. 

  1617.   for (i=0; i < 256; i++)
    1618. 

  1618.     curve[i] = i*i / 3.969 + 0.5;
    1619. 

  1619.   for (row=0; row < raw_height; row++) {
    1620. 

  1620.     fseek (ifp, data_offset + offset[row], SEEK_SET);
    1621. 

  1621.     ph1_bits(-1);
    1622. 

  1622.     pred[0] = pred[1] = 0;
    1623. 

  1623.     for (col=0; col < raw_width; col++) {
    1624. 

  1624.       if (col >= (raw_width & -8))
    1625. 

  1625. 	len[0] = len[1] = 14;
    1626. 

  1626.       else if ((col & 7) == 0)
    1627. 

  1627. 	for (i=0; i < 2; i++) {
    1628. 

  1628. 	  for (j=0; j < 5 && !ph1_bits(1); j++);
    1629. 

  1629. 	  if (j--) len[i] = length[j*2 + ph1_bits(1)];
    1630. 

  1630. 	}
    1631. 

  1631.       if ((i = len[col & 1]) == 14)
    1632. 

  1632. 	pixel[col] = pred[col & 1] = ph1_bits(16);
    1633. 

  1633.       else
    1634. 

  1634. 	pixel[col] = pred[col & 1] += ph1_bits(i) + 1 - (1 << (i - 1));
    1635. 

  1635.       if (pred[col & 1] >> 16) derror();
    1636. 

  1636.       if (ph1.format == 5 && pixel[col] < 256)
    1637. 

  1637. 	pixel[col] = curve[pixel[col]];
    1638. 

  1638.     }
    1639. 

  1639.     for (col=0; col < raw_width; col++) {
    1640. 

  1640. #ifndef LIBRAW_LIBRARY_BUILD
    1641. 

  1641.       i = (pixel[col] << 2) - ph1.t_black + t_black[row][col >= ph1.split_col];
    1642. 

  1642.       if (i > 0) RAW(row,col) = i;
    1643. 

  1643. #else
    1644. 

  1644.       RAW(row,col) = pixel[col] << 2;
    1645. 

  1645. #endif
    1646. 

  1646.     }
    1647. 

  1647.   }
    1648. 

  1648.   free (pixel);
    1649. 

  1649.   maximum = 0xfffc - ph1.t_black;
    1650. 

  1650. }
    1651. 

  1651. 

  1652. void CLASS hasselblad_load_raw()
    1653. 

  1653. {
    1654. 

  1654.   struct jhead jh;
    1655. 

  1655.   int row, col, pred[2], len[2], diff, c;
    1656. 

  1656. 

  1657.   if (!ljpeg_start (&jh, 0)) return;
    1658. 

  1658.   order = 0x4949;
    1659. 

  1659.   ph1_bits(-1);
    1660. 

  1660.   for (row=0; row < raw_height; row++) {
    1661. 

  1661.     pred[0] = pred[1] = 0x8000 + load_flags;
    1662. 

  1662.     for (col=0; col < raw_width; col+=2) {
    1663. 

  1663.       FORC(2) len[c] = ph1_huff(jh.huff[0]);
    1664. 

  1664.       FORC(2) {
    1665. 

  1665. 	diff = ph1_bits(len[c]);
    1666. 

  1666. 	if ((diff & (1 << (len[c]-1))) == 0)
    1667. 

  1667. 	  diff -= (1 << len[c]) - 1;
    1668. 

  1668. 	if (diff == 65535) diff = -32768;
    1669. 

  1669. 	RAW(row,col+c) = pred[c] += diff;
    1670. 

  1670.       }
    1671. 

  1671.     }
    1672. 

  1672.   }
    1673. 

  1673.   ljpeg_end (&jh);
    1674. 

  1674.   maximum = 0xffff;
    1675. 

  1675. }
    1676. 

  1676. 

  1677. void CLASS leaf_hdr_load_raw()
    1678. 

  1678. {
    1679. 

  1679.   ushort *pixel=0;
    1680. 

  1680.   unsigned tile=0, r, c, row, col;
    1681. 

  1681. 

  1682.   if (!filters) {
    1683. 

  1683.     pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1684. 

  1684.     merror (pixel, "leaf_hdr_load_raw()");
    1685. 

  1685.   }
    1686. 

  1686.   FORC(tiff_samples)
    1687. 

  1687.     for (r=0; r < raw_height; r++) {
    1688. 

  1688.       if (r % tile_length == 0) {
    1689. 

  1689. 	fseek (ifp, data_offset + 4*tile++, SEEK_SET);
    1690. 

  1690. 	fseek (ifp, get4(), SEEK_SET);
    1691. 

  1691.       }
    1692. 

  1692.       if (filters && c != shot_select) continue;
    1693. 

  1693.       if (filters) pixel = raw_image + r*raw_width;
    1694. 

  1694.       read_shorts (pixel, raw_width);
    1695. 

  1695.       if (!filters && (row = r - top_margin) < height)
    1696. 

  1696. 	for (col=0; col < width; col++)
    1697. 

  1697. 	  image[row*width+col][c] = pixel[col+left_margin];
    1698. 

  1698.     }
    1699. 

  1699.   if (!filters) {
    1700. 

  1700.     maximum = 0xffff;
    1701. 

  1701.     raw_color = 1;
    1702. 

  1702.     free (pixel);
    1703. 

  1703.   }
    1704. 

  1704. }
    1705. 

  1705. 

  1706. void CLASS unpacked_load_raw()
    1707. 

  1707. {
    1708. 

  1708.   int row, col, bits=0;
    1709. 

  1709. 

  1710.   while (1 << ++bits < maximum);
    1711. 

  1711.   read_shorts (raw_image, raw_width*raw_height);
    1712. 

  1712.   for (row=0; row < raw_height; row++)
    1713. 

  1713.     for (col=0; col < raw_width; col++)
    1714. 

  1714.       if ((RAW(row,col) >>= load_flags) >> bits
    1715. 

  1715. 	&& (unsigned) (row-top_margin) < height
    1716. 

  1716. 	&& (unsigned) (col-left_margin) < width) derror();
    1717. 

  1717. }
    1718. 

  1718. 

  1719. void CLASS sinar_4shot_load_raw()
    1720. 

  1720. {
    1721. 

  1721.   ushort *pixel;
    1722. 

  1722.   unsigned shot, row, col, r, c;
    1723. 

  1723. 

  1724.   if ((shot = shot_select) || half_size) {
    1725. 

  1725.     if (shot) shot--;
    1726. 

  1726.     if (shot > 3) shot = 3;
    1727. 

  1727.     fseek (ifp, data_offset + shot*4, SEEK_SET);
    1728. 

  1728.     fseek (ifp, get4(), SEEK_SET);
    1729. 

  1729.     unpacked_load_raw();
    1730. 

  1730.     return;
    1731. 

  1731.   }
    1732. 

  1732. #ifndef LIBRAW_LIBRARY_BUILD
    1733. 

  1733.   free (raw_image);
    1734. 

  1734.   raw_image = 0;
    1735. 

  1735.   free (image);
    1736. 

  1736.   image = (ushort (*)[4])
    1737. 

  1737. 	calloc ((iheight=height)*(iwidth=width), sizeof *image);
    1738. 

  1738.   merror (image, "sinar_4shot_load_raw()");
    1739. 

  1739. #endif
    1740. 

  1740.   pixel = (ushort *) calloc (raw_width, sizeof *pixel);
    1741. 

  1741.   merror (pixel, "sinar_4shot_load_raw()");
    1742. 

  1742.   for (shot=0; shot < 4; shot++) {
    1743. 

  1743.     fseek (ifp, data_offset + shot*4, SEEK_SET);
    1744. 

  1744.     fseek (ifp, get4(), SEEK_SET);
    1745. 

  1745.     for (row=0; row < raw_height; row++) {
    1746. 

  1746.       read_shorts (pixel, raw_width);
    1747. 

  1747.       if ((r = row-top_margin - (shot >> 1 & 1)) >= height) continue;
    1748. 

  1748.       for (col=0; col < raw_width; col++) {
    1749. 

  1749. 	if ((c = col-left_margin - (shot & 1)) >= width) continue;
    1750. 

  1750. 	image[r*width+c][FC(row,col)] = pixel[col];
    1751. 

  1751.       }
    1752. 

  1752.     }
    1753. 

  1753.   }
    1754. 

  1754.   free (pixel);
    1755. 

  1755.   shrink = filters = 0;
    1756. 

  1756. }
    1757. 

  1757. 

  1758. void CLASS imacon_full_load_raw()
    1759. 

  1759. {
    1760. 

  1760.   int row, col;
    1761. 

  1761. 

  1762.   for (row=0; row < height; row++)
    1763. 

  1763.     for (col=0; col < width; col++)
    1764. 

  1764.       read_shorts (image[row*width+col], 3);
    1765. 

  1765. }
    1766. 

  1766. 

  1767. void CLASS packed_load_raw()
    1768. 

  1768. {
    1769. 

  1769.   int vbits=0, bwide, pwide, rbits, bite, half, irow, row, col, val, i;
    1770. 

  1770.   UINT64 bitbuf=0;
    1771. 

  1771. 

  1772.   if (raw_width * 8 >= width * tiff_bps)	/* Is raw_width in bytes? */
    1773. 

  1773.        pwide = (bwide = raw_width) * 8 / tiff_bps;
    1774. 

  1774.   else bwide = (pwide = raw_width) * tiff_bps / 8;
    1775. 

  1775.   rbits = bwide * 8 - pwide * tiff_bps;
    1776. 

  1776.   if (load_flags & 1) bwide = bwide * 16 / 15;
    1777. 

  1777.   bite = 8 + (load_flags & 24);
    1778. 

  1778.   half = (raw_height+1) >> 1;
    1779. 

  1779.   for (irow=0; irow < raw_height; irow++) {
    1780. 

  1780.     row = irow;
    1781. 

  1781.     if (load_flags & 2 &&
    1782. 

  1782. 	(row = irow % half * 2 + irow / half) == 1 &&
    1783. 

  1783. 	load_flags & 4) {
    1784. 

  1784.       if (vbits=0, tiff_compress)
    1785. 

  1785. 	fseek (ifp, data_offset - (-half*bwide & -2048), SEEK_SET);
    1786. 

  1786.       else {
    1787. 

  1787. 	fseek (ifp, 0, SEEK_END);
    1788. 

  1788. 	fseek (ifp, ftell(ifp) >> 3 << 2, SEEK_SET);
    1789. 

  1789.       }
    1790. 

  1790.     }
    1791. 

  1791.     for (col=0; col < pwide; col++) {
    1792. 

  1792.       for (vbits -= tiff_bps; vbits < 0; vbits += bite) {
    1793. 

  1793. 	bitbuf <<= bite;
    1794. 

  1794. 	for (i=0; i < bite; i+=8)
    1795. 

  1795. 	  bitbuf |= (unsigned) (fgetc(ifp) << i);
    1796. 

  1796.       }
    1797. 

  1797.       val = bitbuf << (64-tiff_bps-vbits) >> (64-tiff_bps);
    1798. 

  1798.       RAW(row,col ^ (load_flags >> 6)) = val;
    1799. 

  1799.       if (load_flags & 1 && (col % 10) == 9 &&
    1800. 

  1800. 	fgetc(ifp) && col < width+left_margin) derror();
    1801. 

  1801.     }
    1802. 

  1802.     vbits -= rbits;
    1803. 

  1803.   }
    1804. 

  1804. }
    1805. 

  1805. 

  1806. void CLASS nokia_load_raw()
    1807. 

  1807. {
    1808. 

  1808.   uchar  *data,  *dp;
    1809. 

  1809.   int rev, dwide, row, col, c;
    1810. 

  1810. 

  1811.   rev = 3 * (order == 0x4949);
    1812. 

  1812.   dwide = (raw_width * 5 +1) / 4;
    1813. 

  1813.   data = (uchar *) malloc (dwide*2);
    1814. 

  1814.   merror (data, "nokia_load_raw()");
    1815. 

  1815.   for (row=0; row < raw_height; row++) {
    1816. 

  1816.     if (fread (data+dwide, 1, dwide, ifp) < dwide) derror();
    1817. 

  1817.     FORC(dwide) data[c] = data[dwide+(c ^ rev)];
    1818. 

  1818.     for (dp=data, col=0; col < raw_width; dp+=5, col+=4)
    1819. 

  1819.       FORC4 RAW(row,col+c) = (dp[c] << 2) | (dp[4] >> (c << 1) & 3);
    1820. 

  1820.   }
    1821. 

  1821.   free (data);
    1822. 

  1822.   maximum = 0x3ff;
    1823. 

  1823. }
    1824. 

  1824. 

  1825. unsigned CLASS pana_bits (int nbits)
    1826. 

  1826. {
    1827. 

  1827. #ifndef LIBRAW_NOTHREADS
    1828. 

  1828. #define buf tls->pana_bits.buf
    1829. 

  1829. #define vbits tls->pana_bits.vbits   
    1830. 

  1830. #else
    1831. 

  1831.   static uchar buf[0x4000];
    1832. 

  1832.   static int vbits;
    1833. 

  1833. #endif
    1834. 

  1834.   int byte;
    1835. 

  1835. 

  1836.   if (!nbits) return vbits=0;
    1837. 

  1837.   if (!vbits) {
    1838. 

  1838.     fread (buf+load_flags, 1, 0x4000-load_flags, ifp);
    1839. 

  1839.     fread (buf, 1, load_flags, ifp);
    1840. 

  1840.   }
    1841. 

  1841.   vbits = (vbits - nbits) & 0x1ffff;
    1842. 

  1842.   byte = vbits >> 3 ^ 0x3ff0;
    1843. 

  1843.   return (buf[byte] | buf[byte+1] << 8) >> (vbits & 7) & ~(-1 << nbits);
    1844. 

  1844. #ifndef LIBRAW_NOTHREADS
    1845. 

  1845. #undef buf
    1846. 

  1846. #undef vbits
    1847. 

  1847. #endif
    1848. 

  1848. }
    1849. 

  1849. 

  1850. void CLASS panasonic_load_raw()
    1851. 

  1851. {
    1852. 

  1852.   int row, col, i, j, sh=0, pred[2], nonz[2];
    1853. 

  1853. 

  1854.   pana_bits(0);
    1855. 

  1855.   for (row=0; row < height; row++)
    1856. 

  1856.     for (col=0; col < raw_width; col++) {
    1857. 

  1857.       if ((i = col % 14) == 0)
    1858. 

  1858. 	pred[0] = pred[1] = nonz[0] = nonz[1] = 0;
    1859. 

  1859.       if (i % 3 == 2) sh = 4 >> (3 - pana_bits(2));
    1860. 

  1860.       if (nonz[i & 1]) {
    1861. 

  1861. 	if ((j = pana_bits(8))) {
    1862. 

  1862. 	  if ((pred[i & 1] -= 0x80 << sh) < 0 || sh == 4)
    1863. 

  1863. 	       pred[i & 1] &= ~(-1 << sh);
    1864. 

  1864. 	  pred[i & 1] += j << sh;
    1865. 

  1865. 	}
    1866. 

  1866.       } else if ((nonz[i & 1] = pana_bits(8)) || i > 11)
    1867. 

  1867. 	pred[i & 1] = nonz[i & 1] << 4 | pana_bits(4);
    1868. 

  1868.       if ((RAW(row,col) = pred[col & 1]) > 4098 && col < width) derror();
    1869. 

  1869.     }
    1870. 

  1870. }
    1871. 

  1871. 

  1872. void CLASS olympus_load_raw()
    1873. 

  1873. {
    1874. 

  1874.   ushort huff[4096];
    1875. 

  1875.   int row, col, nbits, sign, low, high, i, c, w, n, nw;
    1876. 

  1876.   int acarry[2][3], *carry, pred, diff;
    1877. 

  1877. 

  1878.   huff[n=0] = 0xc0c;
    1879. 

  1879.   for (i=12; i--; )
    1880. 

  1880.     FORC(2048 >> i) huff[++n] = (i+1) << 8 | i;
    1881. 

  1881.   fseek (ifp, 7, SEEK_CUR);
    1882. 

  1882. #ifdef LIBRAW_LIBRARY_BUILD
    1883. 

  1883.   if(!data_size)
    1884. 

  1884.       throw LIBRAW_EXCEPTION_IO_BADFILE;
    1885. 

  1885.   LibRaw_byte_buffer *buf = ifp->make_byte_buffer(data_size);
    1886. 

  1886.   LibRaw_bit_buffer bits;
    1887. 

  1887.   bits.reset();
    1888. 

  1888. #else
    1889. 

  1889.   getbits(-1);
    1890. 

  1890. #endif
    1891. 

  1891.   for (row=0; row < height; row++) {
    1892. 

  1892.     memset (acarry, 0, sizeof acarry);
    1893. 

  1893.     for (col=0; col < raw_width; col++) {
    1894. 

  1894.       carry = acarry[col & 1];
    1895. 

  1895.       i = 2 * (carry[2] < 3);
    1896. 

  1896.       for (nbits=2+i; (ushort) carry[0] >> (nbits+i); nbits++);
    1897. 

  1897. #ifdef LIBRAW_LIBRARY_BUILD
    1898. 

  1898.       low = (sign = bits._getbits(buf,3,zero_after_ff)) & 3;
    1899. 

  1899.       sign = sign << 29 >> 31;
    1900. 

  1900.       if ((high = bits._gethuff(buf,12,huff,zero_after_ff)) == 12)
    1901. 

  1901.           high = bits._getbits(buf,16-nbits,zero_after_ff) >> 1;
    1902. 

  1902.       carry[0] = (high << nbits) | bits._getbits(buf,nbits,zero_after_ff);
    1903. 

  1903. #else
    1904. 

  1904.       low = (sign = getbits(3)) & 3;
    1905. 

  1905.       sign = sign << 29 >> 31;
    1906. 

  1906.       if ((high = getbithuff(12,huff)) == 12)
    1907. 

  1907. 	high = getbits(16-nbits) >> 1;
    1908. 

  1908.       carry[0] = (high << nbits) | getbits(nbits);
    1909. 

  1909. #endif
    1910. 

  1910.       diff = (carry[0] ^ sign) + carry[1];
    1911. 

  1911.       carry[1] = (diff*3 + carry[1]) >> 5;
    1912. 

  1912.       carry[2] = carry[0] > 16 ? 0 : carry[2]+1;
    1913. 

  1913.       if (col >= width) continue;
    1914. 

  1914.       if (row < 2 && col < 2) pred = 0;
    1915. 

  1915.       else if (row < 2) pred = RAW(row,col-2);
    1916. 

  1916.       else if (col < 2) pred = RAW(row-2,col);
    1917. 

  1917.       else {
    1918. 

  1918. 	w  = RAW(row,col-2);
    1919. 

  1919. 	n  = RAW(row-2,col);
    1920. 

  1920. 	nw = RAW(row-2,col-2);
    1921. 

  1921. 	if ((w < nw && nw < n) || (n < nw && nw < w)) {
    1922. 

  1922. 	  if (ABS(w-nw) > 32 || ABS(n-nw) > 32)
    1923. 

  1923. 	    pred = w + n - nw;
    1924. 

  1924. 	  else pred = (w + n) >> 1;
    1925. 

  1925. 	} else pred = ABS(w-nw) > ABS(n-nw) ? w : n;
    1926. 

  1926.       }
    1927. 

  1927.       if ((RAW(row,col) = pred + ((diff << 2) | low)) >> 12) derror();
    1928. 

  1928.     }
    1929. 

  1929.   }
    1930. 

  1930. #ifdef LIBRAW_LIBRARY_BUILD
    1931. 

  1931.   delete buf;
    1932. 

  1932. #endif
    1933. 

  1933. }
    1934. 

  1934. 

  1935. void CLASS minolta_rd175_load_raw()
    1936. 

  1936. {
    1937. 

  1937.   uchar pixel[768];
    1938. 

  1938.   unsigned irow, box, row, col;
    1939. 

  1939. 

  1940.   for (irow=0; irow < 1481; irow++) {
    1941. 

  1941.     if (fread (pixel, 1, 768, ifp) < 768) derror();
    1942. 

  1942.     box = irow / 82;
    1943. 

  1943.     row = irow % 82 * 12 + ((box < 12) ? box | 1 : (box-12)*2);
    1944. 

  1944.     switch (irow) {
    1945. 

  1945.       case 1477: case 1479: continue;
    1946. 

  1946.       case 1476: row = 984; break;
    1947. 

  1947.       case 1480: row = 985; break;
    1948. 

  1948.       case 1478: row = 985; box = 1;
    1949. 

  1949.     }
    1950. 

  1950.     if ((box < 12) && (box & 1)) {
    1951. 

  1951.       for (col=0; col < 1533; col++, row ^= 1)
    1952. 

  1952. 	if (col != 1) RAW(row,col) = (col+1) & 2 ?
    1953. 

  1953. 		   pixel[col/2-1] + pixel[col/2+1] : pixel[col/2] << 1;
    1954. 

  1954.       RAW(row,1)    = pixel[1]   << 1;
    1955. 

  1955.       RAW(row,1533) = pixel[765] << 1;
    1956. 

  1956.     } else
    1957. 

  1957.       for (col=row & 1; col < 1534; col+=2)
    1958. 

  1958. 	RAW(row,col) = pixel[col/2] << 1;
    1959. 

  1959.   }
    1960. 

  1960.   maximum = 0xff << 1;
    1961. 

  1961. }
    1962. 

  1962. 

  1963. void CLASS quicktake_100_load_raw()
    1964. 

  1964. {
    1965. 

  1965.   uchar pixel[484][644];
    1966. 

  1966.   static const short gstep[16] =
    1967. 

  1967.   { -89,-60,-44,-32,-22,-15,-8,-2,2,8,15,22,32,44,60,89 };
    1968. 

  1968.   static const short rstep[6][4] =
    1969. 

  1969.   { {  -3,-1,1,3  }, {  -5,-1,1,5  }, {  -8,-2,2,8  },
    1970. 

  1970.     { -13,-3,3,13 }, { -19,-4,4,19 }, { -28,-6,6,28 } };
    1971. 

  1971.   static const short t_curve[256] =
    1972. 

  1972.   { 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,
    1973. 

  1973.     28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,
    1974. 

  1974.     54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,74,75,76,77,78,
    1975. 

  1975.     79,80,81,82,83,84,86,88,90,92,94,97,99,101,103,105,107,110,112,114,116,
    1976. 

  1976.     118,120,123,125,127,129,131,134,136,138,140,142,144,147,149,151,153,155,
    1977. 

  1977.     158,160,162,164,166,168,171,173,175,177,179,181,184,186,188,190,192,195,
    1978. 

  1978.     197,199,201,203,205,208,210,212,214,216,218,221,223,226,230,235,239,244,
    1979. 

  1979.     248,252,257,261,265,270,274,278,283,287,291,296,300,305,309,313,318,322,
    1980. 

  1980.     326,331,335,339,344,348,352,357,361,365,370,374,379,383,387,392,396,400,
    1981. 

  1981.     405,409,413,418,422,426,431,435,440,444,448,453,457,461,466,470,474,479,
    1982. 

  1982.     483,487,492,496,500,508,519,531,542,553,564,575,587,598,609,620,631,643,
    1983. 

  1983.     654,665,676,687,698,710,721,732,743,754,766,777,788,799,810,822,833,844,
    1984. 

  1984.     855,866,878,889,900,911,922,933,945,956,967,978,989,1001,1012,1023 };
    1985. 

  1985.   int rb, row, col, sharp, val=0;
    1986. 

  1986. 

  1987.   getbits(-1);
    1988. 

  1988.   memset (pixel, 0x80, sizeof pixel);
    1989. 

  1989.   for (row=2; row < height+2; row++) {
    1990. 

  1990.     for (col=2+(row & 1); col < width+2; col+=2) {
    1991. 

  1991.       val = ((pixel[row-1][col-1] + 2*pixel[row-1][col+1] +
    1992. 

  1992. 		pixel[row][col-2]) >> 2) + gstep[getbits(4)];
    1993. 

  1993.       pixel[row][col] = val = LIM(val,0,255);
    1994. 

  1994.       if (col < 4)
    1995. 

  1995. 	pixel[row][col-2] = pixel[row+1][~row & 1] = val;
    1996. 

  1996.       if (row == 2)
    1997. 

  1997. 	pixel[row-1][col+1] = pixel[row-1][col+3] = val;
    1998. 

  1998.     }
    1999. 

  1999.     pixel[row][col] = val;
    2000. 

  2000.   }
    2001. 

  2001.   for (rb=0; rb < 2; rb++)
    2002. 

  2002.     for (row=2+rb; row < height+2; row+=2)
    2003. 

  2003.       for (col=3-(row & 1); col < width+2; col+=2) {
    2004. 

  2004. 	if (row < 4 || col < 4) sharp = 2;
    2005. 

  2005. 	else {
    2006. 

  2006. 	  val = ABS(pixel[row-2][col] - pixel[row][col-2])
    2007. 

  2007. 	      + ABS(pixel[row-2][col] - pixel[row-2][col-2])
    2008. 

  2008. 	      + ABS(pixel[row][col-2] - pixel[row-2][col-2]);
    2009. 

  2009. 	  sharp = val <  4 ? 0 : val <  8 ? 1 : val < 16 ? 2 :
    2010. 

  2010. 		  val < 32 ? 3 : val < 48 ? 4 : 5;
    2011. 

  2011. 	}
    2012. 

  2012. 	val = ((pixel[row-2][col] + pixel[row][col-2]) >> 1)
    2013. 

  2013. 	      + rstep[sharp][getbits(2)];
    2014. 

  2014. 	pixel[row][col] = val = LIM(val,0,255);
    2015. 

  2015. 	if (row < 4) pixel[row-2][col+2] = val;
    2016. 

  2016. 	if (col < 4) pixel[row+2][col-2] = val;
    2017. 

  2017.       }
    2018. 

  2018.   for (row=2; row < height+2; row++)
    2019. 

  2019.     for (col=3-(row & 1); col < width+2; col+=2) {
    2020. 

  2020.       val = ((pixel[row][col-1] + (pixel[row][col] << 2) +
    2021. 

  2021. 	      pixel[row][col+1]) >> 1) - 0x100;
    2022. 

  2022.       pixel[row][col] = LIM(val,0,255);
    2023. 

  2023.     }
    2024. 

  2024.   for (row=0; row < height; row++)
    2025. 

  2025.     for (col=0; col < width; col++)
    2026. 

  2026.       RAW(row,col) = t_curve[pixel[row+2][col+2]];
    2027. 

  2027.   maximum = 0x3ff;
    2028. 

  2028. }
    2029. 

  2029. 

  2030. #define radc_token(tree) ((signed char) getbithuff(8,huff[tree]))
    2031. 

  2031. 

  2032. #define FORYX for (y=1; y < 3; y++) for (x=col+1; x >= col; x--)
    2033. 

  2033. 

  2034. #define PREDICTOR (c ? (buf[c][y-1][x] + buf[c][y][x+1]) / 2 \
    2035. 

  2035. : (buf[c][y-1][x+1] + 2*buf[c][y-1][x] + buf[c][y][x+1]) / 4)
    2036. 

  2036. 

  2037. #ifdef __GNUC__
    2038. 

  2038. # if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
    2039. 

  2039. # pragma GCC optimize("no-aggressive-loop-optimizations")
    2040. 

  2040. # endif
    2041. 

  2041. #endif
    2042. 

  2042. 

  2043. void CLASS kodak_radc_load_raw()
    2044. 

  2044. {
    2045. 

  2045.   static const char src[] = {
    2046. 

  2046.     1,1, 2,3, 3,4, 4,2, 5,7, 6,5, 7,6, 7,8,
    2047. 

  2047.     1,0, 2,1, 3,3, 4,4, 5,2, 6,7, 7,6, 8,5, 8,8,
    2048. 

  2048.     2,1, 2,3, 3,0, 3,2, 3,4, 4,6, 5,5, 6,7, 6,8,
    2049. 

  2049.     2,0, 2,1, 2,3, 3,2, 4,4, 5,6, 6,7, 7,5, 7,8,
    2050. 

  2050.     2,1, 2,4, 3,0, 3,2, 3,3, 4,7, 5,5, 6,6, 6,8,
    2051. 

  2051.     2,3, 3,1, 3,2, 3,4, 3,5, 3,6, 4,7, 5,0, 5,8,
    2052. 

  2052.     2,3, 2,6, 3,0, 3,1, 4,4, 4,5, 4,7, 5,2, 5,8,
    2053. 

  2053.     2,4, 2,7, 3,3, 3,6, 4,1, 4,2, 4,5, 5,0, 5,8,
    2054. 

  2054.     2,6, 3,1, 3,3, 3,5, 3,7, 3,8, 4,0, 5,2, 5,4,
    2055. 

  2055.     2,0, 2,1, 3,2, 3,3, 4,4, 4,5, 5,6, 5,7, 4,8,
    2056. 

  2056.     1,0, 2,2, 2,-2,
    2057. 

  2057.     1,-3, 1,3,
    2058. 

  2058.     2,-17, 2,-5, 2,5, 2,17,
    2059. 

  2059.     2,-7, 2,2, 2,9, 2,18,
    2060. 

  2060.     2,-18, 2,-9, 2,-2, 2,7,
    2061. 

  2061.     2,-28, 2,28, 3,-49, 3,-9, 3,9, 4,49, 5,-79, 5,79,
    2062. 

  2062.     2,-1, 2,13, 2,26, 3,39, 4,-16, 5,55, 6,-37, 6,76,
    2063. 

  2063.     2,-26, 2,-13, 2,1, 3,-39, 4,16, 5,-55, 6,-76, 6,37
    2064. 

  2064.   };
    2065. 

  2065.   ushort huff[19][256];
    2066. 

  2066.   int row, col, tree, nreps, rep, step, i, c, s, r, x, y, val;
    2067. 

  2067.   short last[3] = { 16,16,16 }, mul[3], buf[3][3][386];
    2068. 

  2068.   static const ushort pt[] =
    2069. 

  2069.     { 0,0, 1280,1344, 2320,3616, 3328,8000, 4095,16383, 65535,16383 };
    2070. 

  2070. 

  2071.   for (i=2; i < 12; i+=2)
    2072. 

  2072.     for (c=pt[i-2]; c <= pt[i]; c++)
    2073. 

  2073.       curve[c] = (float)
    2074. 

  2074. 	(c-pt[i-2]) / (pt[i]-pt[i-2]) * (pt[i+1]-pt[i-1]) + pt[i-1] + 0.5;
    2075. 

  2075.   for (s=i=0; i < sizeof src; i+=2)
    2076. 

  2076.     FORC(256 >> src[i])
    2077. 

  2077.       huff[0][s++] = src[i] << 8 | (uchar) src[i+1];
    2078. 

  2078.   s = kodak_cbpp == 243 ? 2 : 3;
    2079. 

  2079.   FORC(256) huff[18][c] = (8-s) << 8 | c >> s << s | 1 << (s-1);
    2080. 

  2080.   getbits(-1);
    2081. 

  2081.   for (i=0; i < sizeof(buf)/sizeof(short); i++)
    2082. 

  2082.     buf[0][0][i] = 2048;
    2083. 

  2083.   for (row=0; row < height; row+=4) {
    2084. 

  2084.     FORC3 mul[c] = getbits(6);
    2085. 

  2085.     FORC3 {
    2086. 

  2086.       val = ((0x1000000/last[c] + 0x7ff) >> 12) * mul[c];
    2087. 

  2087.       s = val > 65564 ? 10:12;
    2088. 

  2088.       x = ~(-1 << (s-1));
    2089. 

  2089.       val <<= 12-s;
    2090. 

  2090.       for (i=0; i < sizeof(buf[0])/sizeof(short); i++)
    2091. 

  2091. 	buf[c][0][i] = (buf[c][0][i] * val + x) >> s;
    2092. 

  2092.       last[c] = mul[c];
    2093. 

  2093.       for (r=0; r <= !c; r++) {
    2094. 

  2094. 	buf[c][1][width/2] = buf[c][2][width/2] = mul[c] << 7;
    2095. 

  2095. 	for (tree=1, col=width/2; col > 0; ) {
    2096. 

  2096. 	  if ((tree = radc_token(tree))) {
    2097. 

  2097. 	    col -= 2;
    2098. 

  2098. 	    if (tree == 8)
    2099. 

  2099. 	      FORYX buf[c][y][x] = (uchar) radc_token(18) * mul[c];
    2100. 

  2100. 	    else
    2101. 

  2101. 	      FORYX buf[c][y][x] = radc_token(tree+10) * 16 + PREDICTOR;
    2102. 

  2102. 	  } else
    2103. 

  2103. 	    do {
    2104. 

  2104. 	      nreps = (col > 2) ? radc_token(9) + 1 : 1;
    2105. 

  2105. 	      for (rep=0; rep < 8 && rep < nreps && col > 0; rep++) {
    2106. 

  2106. 		col -= 2;
    2107. 

  2107. 		FORYX buf[c][y][x] = PREDICTOR;
    2108. 

  2108. 		if (rep & 1) {
    2109. 

  2109. 		  step = radc_token(10) << 4;
    2110. 

  2110. 		  FORYX buf[c][y][x] += step;
    2111. 

  2111. 		}
    2112. 

  2112. 	      }
    2113. 

  2113. 	    } while (nreps == 9);
    2114. 

  2114. 	}
    2115. 

  2115. 	for (y=0; y < 2; y++)
    2116. 

  2116. 	  for (x=0; x < width/2; x++) {
    2117. 

  2117. 	    val = (buf[c][y+1][x] << 4) / mul[c];
    2118. 

  2118. 	    if (val < 0) val = 0;
    2119. 

  2119. 	    if (c) RAW(row+y*2+c-1,x*2+2-c) = val;
    2120. 

  2120. 	    else   RAW(row+r*2+y,x*2+y) = val;
    2121. 

  2121. 	  }
    2122. 

  2122. 	memcpy (buf[c][0]+!c, buf[c][2], sizeof buf[c][0]-2*!c);
    2123. 

  2123.       }
    2124. 

  2124.     }
    2125. 

  2125.     for (y=row; y < row+4; y++)
    2126. 

  2126.       for (x=0; x < width; x++)
    2127. 

  2127. 	if ((x+y) & 1) {
    2128. 

  2128. 	  r = x ? x-1 : x+1;
    2129. 

  2129. 	  s = x+1 < width ? x+1 : x-1;
    2130. 

  2130. 	  val = (RAW(y,x)-2048)*2 + (RAW(y,r)+RAW(y,s))/2;
    2131. 

  2131. 	  if (val < 0) val = 0;
    2132. 

  2132. 	  RAW(y,x) = val;
    2133. 

  2133. 	}
    2134. 

  2134.   }
    2135. 

  2135.   for (i=0; i < height*width; i++)
    2136. 

  2136.     raw_image[i] = curve[raw_image[i]];
    2137. 

  2137.   maximum = 0x3fff;
    2138. 

  2138. }
    2139. 

  2139. 

  2140. #undef FORYX
    2141. 

  2141. #undef PREDICTOR
    2142. 

  2142. 

  2143. #ifdef NO_JPEG
    2144. 

  2144. void CLASS kodak_jpeg_load_raw() {}
    2145. 

  2145. void CLASS lossy_dng_load_raw() {}
    2146. 

  2146. #else
    2147. 

  2147. 

  2148. #ifdef LIBRAW_LIBRARY_BUILD
    2149. 

  2149. void CLASS kodak_jpeg_load_raw() {}
    2150. 

  2150. #else
    2151. 

  2151. 

  2152. METHODDEF(boolean)
    2153. 

  2153. fill_input_buffer (j_decompress_ptr cinfo)
    2154. 

  2154. {
    2155. 

  2155. #ifndef LIBRAW_NOTHREADS
    2156. 

  2156. #define jpeg_buffer tls->jpeg_buffer
    2157. 

  2157. #else
    2158. 

  2158.   static uchar jpeg_buffer[4096];
    2159. 

  2159. #endif
    2160. 

  2160.   size_t nbytes;
    2161. 

  2161. 

  2162.   nbytes = fread (jpeg_buffer, 1, 4096, ifp);
    2163. 

  2163.   swab (jpeg_buffer, jpeg_buffer, nbytes);
    2164. 

  2164.   cinfo->src->next_input_byte = jpeg_buffer;
    2165. 

  2165.   cinfo->src->bytes_in_buffer = nbytes;
    2166. 

  2166.   return TRUE;
    2167. 

  2167. #ifndef LIBRAW_NOTHREADS
    2168. 

  2168. #undef jpeg_buffer
    2169. 

  2169. #endif
    2170. 

  2170. }
    2171. 

  2171. 

  2172. void CLASS kodak_jpeg_load_raw()
    2173. 

  2173. {
    2174. 

  2174.   struct jpeg_decompress_struct cinfo;
    2175. 

  2175.   struct jpeg_error_mgr jerr;
    2176. 

  2176.   JSAMPARRAY buf;
    2177. 

  2177.   JSAMPLE (*pixel)[3];
    2178. 

  2178.   int row, col;
    2179. 

  2179. 

  2180.   cinfo.err = jpeg_std_error (&jerr);
    2181. 

  2181.   jpeg_create_decompress (&cinfo);
    2182. 

  2182.   jpeg_stdio_src (&cinfo, ifp);
    2183. 

  2183.   cinfo.src->fill_input_buffer = fill_input_buffer;
    2184. 

  2184.   jpeg_read_header (&cinfo, TRUE);
    2185. 

  2185.   jpeg_start_decompress (&cinfo);
    2186. 

  2186.   if ((cinfo.output_width      != width  ) ||
    2187. 

  2187.       (cinfo.output_height*2   != height ) ||
    2188. 

  2188.       (cinfo.output_components != 3      )) {
    2189. 

  2189. #ifdef DCRAW_VERBOSE
    2190. 

  2190.     fprintf (stderr,_("%s: incorrect JPEG dimensions\n"), ifname);
    2191. 

  2191. #endif
    2192. 

  2192.     jpeg_destroy_decompress (&cinfo);
    2193. 

  2193. #ifdef LIBRAW_LIBRARY_BUILD
    2194. 

  2194.     throw LIBRAW_EXCEPTION_DECODE_JPEG;
    2195. 

  2195. #else
    2196. 

  2196.     longjmp (failure, 3);
    2197. 

  2197. #endif
    2198. 

  2198.   }
    2199. 

  2199.   buf = (*cinfo.mem->alloc_sarray)
    2200. 

  2200. 		((j_common_ptr) &cinfo, JPOOL_IMAGE, width*3, 1);
    2201. 

  2201. 

  2202.   while (cinfo.output_scanline < cinfo.output_height) {
    2203. 

  2203.     row = cinfo.output_scanline * 2;
    2204. 

  2204.     jpeg_read_scanlines (&cinfo, buf, 1);
    2205. 

  2205.     pixel = (JSAMPLE (*)[3]) buf[0];
    2206. 

  2206.     for (col=0; col < width; col+=2) {
    2207. 

  2207.       RAW(row+0,col+0) = pixel[col+0][1] << 1;
    2208. 

  2208.       RAW(row+1,col+1) = pixel[col+1][1] << 1;
    2209. 

  2209.       RAW(row+0,col+1) = pixel[col][0] + pixel[col+1][0];
    2210. 

  2210.       RAW(row+1,col+0) = pixel[col][2] + pixel[col+1][2];
    2211. 

  2211.     }
    2212. 

  2212.   }
    2213. 

  2213.   jpeg_finish_decompress (&cinfo);
    2214. 

  2214.   jpeg_destroy_decompress (&cinfo);
    2215. 

  2215.   maximum = 0xff << 1;
    2216. 

  2216. }
    2217. 

  2217. #endif
    2218. 

  2218. 

  2219. void CLASS lossy_dng_load_raw()
    2220. 

  2220. {
    2221. 

  2221.   struct jpeg_decompress_struct cinfo;
    2222. 

  2222.   struct jpeg_error_mgr jerr;
    2223. 

  2223.   JSAMPARRAY buf;
    2224. 

  2224.   JSAMPLE (*pixel)[3];
    2225. 

  2225.   unsigned sorder=order, ntags, opcode, deg, i, j, c;
    2226. 

  2226.   unsigned save=data_offset-4, trow=0, tcol=0, row, col;
    2227. 

  2227.   ushort t_curve[3][256];
    2228. 

  2228.   double coeff[9], tot;
    2229. 

  2229. 

  2230.   fseek (ifp, meta_offset, SEEK_SET);
    2231. 

  2231.   order = 0x4d4d;
    2232. 

  2232.   ntags = get4();
    2233. 

  2233.   while (ntags--) {
    2234. 

  2234.     opcode = get4(); get4(); get4();
    2235. 

  2235.     if (opcode != 8)
    2236. 

  2236.     { fseek (ifp, get4(), SEEK_CUR); continue; }
    2237. 

  2237.     fseek (ifp, 20, SEEK_CUR);
    2238. 

  2238.     if ((c = get4()) > 2) break;
    2239. 

  2239.     fseek (ifp, 12, SEEK_CUR);
    2240. 

  2240.     if ((deg = get4()) > 8) break;
    2241. 

  2241.     for (i=0; i <= deg && i < 9; i++)
    2242. 

  2242.       coeff[i] = getreal(12);
    2243. 

  2243.     for (i=0; i < 256; i++) {
    2244. 

  2244.       for (tot=j=0; j <= deg; j++)
    2245. 

  2245. 	tot += coeff[j] * pow(i/255.0, (int)j);
    2246. 

  2246.       t_curve[c][i] = tot*0xffff;
    2247. 

  2247.     }
    2248. 

  2248.   }
    2249. 

  2249.   order = sorder;
    2250. 

  2250.   cinfo.err = jpeg_std_error (&jerr);
    2251. 

  2251.   jpeg_create_decompress (&cinfo);
    2252. 

  2252.   while (trow < raw_height) {
    2253. 

  2253.     fseek (ifp, save+=4, SEEK_SET);
    2254. 

  2254.     if (tile_length < INT_MAX)
    2255. 

  2255.       fseek (ifp, get4(), SEEK_SET);
    2256. 

  2256. #ifdef LIBRAW_LIBRARY_BUILD
    2257. 

  2257.     if(libraw_internal_data.internal_data.input->jpeg_src(&cinfo) == -1)
    2258. 

  2258.       {
    2259. 

  2259.         jpeg_destroy_decompress(&cinfo);
    2260. 

  2260.         throw LIBRAW_EXCEPTION_DECODE_JPEG;
    2261. 

  2261.       }
    2262. 

  2262. #else
    2263. 

  2263.     jpeg_stdio_src (&cinfo, ifp);
    2264. 

  2264. #endif
    2265. 

  2265.     jpeg_read_header (&cinfo, TRUE);
    2266. 

  2266.     jpeg_start_decompress (&cinfo);
    2267. 

  2267.     buf = (*cinfo.mem->alloc_sarray)
    2268. 

  2268. 	((j_common_ptr) &cinfo, JPOOL_IMAGE, cinfo.output_width*3, 1);
    2269. 

  2269.     while (cinfo.output_scanline < cinfo.output_height &&
    2270. 

  2270. 	(row = trow + cinfo.output_scanline) < height) {
    2271. 

  2271.       jpeg_read_scanlines (&cinfo, buf, 1);
    2272. 

  2272.       pixel = (JSAMPLE (*)[3]) buf[0];
    2273. 

  2273.       for (col=0; col < cinfo.output_width && tcol+col < width; col++) {
    2274. 

  2274. 	FORC3 image[row*width+tcol+col][c] = t_curve[c][pixel[col][c]];
    2275. 

  2275.       }
    2276. 

  2276.     }
    2277. 

  2277.     jpeg_abort_decompress (&cinfo);
    2278. 

  2278.     if ((tcol += tile_width) >= raw_width)
    2279. 

  2279.       trow += tile_length + (tcol = 0);
    2280. 

  2280.   }
    2281. 

  2281.   jpeg_destroy_decompress (&cinfo);
    2282. 

  2282.   maximum = 0xffff;
    2283. 

  2283. }
    2284. 

  2284. #endif
    2285. 

  2285. 

  2286. void CLASS kodak_dc120_load_raw()
    2287. 

  2287. {
    2288. 

  2288.   static const int mul[4] = { 162, 192, 187,  92 };
    2289. 

  2289.   static const int add[4] = {   0, 636, 424, 212 };
    2290. 

  2290.   uchar pixel[848];
    2291. 

  2291.   int row, shift, col;
    2292. 

  2292. 

  2293.   for (row=0; row < height; row++) {
    2294. 

  2294.     if (fread (pixel, 1, 848, ifp) < 848) derror();
    2295. 

  2295.     shift = row * mul[row & 3] + add[row & 3];
    2296. 

  2296.     for (col=0; col < width; col++)
    2297. 

  2297.       RAW(row,col) = (ushort) pixel[(col + shift) % 848];
    2298. 

  2298.   }
    2299. 

  2299.   maximum = 0xff;
    2300. 

  2300. }
    2301. 

  2301. 

  2302. void CLASS eight_bit_load_raw()
    2303. 

  2303. {
    2304. 

  2304.   uchar *pixel;
    2305. 

  2305.   unsigned row, col;
    2306. 

  2306. 

  2307.   pixel = (uchar *) calloc (raw_width, sizeof *pixel);
    2308. 

  2308.   merror (pixel, "eight_bit_load_raw()");
    2309. 

  2309.   for (row=0; row < raw_height; row++) {
    2310. 

  2310.     if (fread (pixel, 1, raw_width, ifp) < raw_width) derror();
    2311. 

  2311.     for (col=0; col < raw_width; col++)
    2312. 

  2312.       RAW(row,col) = curve[pixel[col]];
    2313. 

  2313.   }
    2314. 

  2314.   free (pixel);
    2315. 

  2315.   maximum = curve[0xff];
    2316. 

  2316. }
    2317. 

  2317. 

  2318. void CLASS kodak_yrgb_load_raw()
    2319. 

  2319. {
    2320. 

  2320.   uchar *pixel;
    2321. 

  2321.   int row, col, y, cb, cr, rgb[3], c;
    2322. 

  2322. 

  2323.   pixel = (uchar *) calloc (raw_width, 3*sizeof *pixel);
    2324. 

  2324.   merror (pixel, "kodak_yrgb_load_raw()");
    2325. 

  2325.   for (row=0; row < height; row++) {
    2326. 

  2326.     if (~row & 1)
    2327. 

  2327.       if (fread (pixel, raw_width, 3, ifp) < 3) derror();
    2328. 

  2328.     for (col=0; col < raw_width; col++) {
    2329. 

  2329.       y  = pixel[width*2*(row & 1) + col];
    2330. 

  2330.       cb = pixel[width + (col & -2)]   - 128;
    2331. 

  2331.       cr = pixel[width + (col & -2)+1] - 128;
    2332. 

  2332.       rgb[1] = y-((cb + cr + 2) >> 2);
    2333. 

  2333.       rgb[2] = rgb[1] + cb;
    2334. 

  2334.       rgb[0] = rgb[1] + cr;
    2335. 

  2335.       FORC3 image[row*width+col][c] = curve[LIM(rgb[c],0,255)];
    2336. 

  2336.     }
    2337. 

  2337.   }
    2338. 

  2338.   free (pixel);
    2339. 

  2339.   maximum = curve[0xff];
    2340. 

  2340. }
    2341. 

  2341. 

  2342. void CLASS kodak_262_load_raw()
    2343. 

  2343. {
    2344. 

  2344.   static const uchar kodak_tree[2][26] =
    2345. 

  2345.   { { 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 },
    2346. 

  2346.     { 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 } };
    2347. 

  2347.   ushort *huff[2];
    2348. 

  2348.   uchar *pixel;
    2349. 

  2349.   int *strip, ns, c, row, col, chess, pi=0, pi1, pi2, pred, val;
    2350. 

  2350. 

  2351.   FORC(2) huff[c] = make_decoder (kodak_tree[c]);
    2352. 

  2352.   ns = (raw_height+63) >> 5;
    2353. 

  2353.   pixel = (uchar *) malloc (raw_width*32 + ns*4);
    2354. 

  2354.   merror (pixel, "kodak_262_load_raw()");
    2355. 

  2355.   strip = (int *) (pixel + raw_width*32);
    2356. 

  2356.   order = 0x4d4d;
    2357. 

  2357.   FORC(ns) strip[c] = get4();
    2358. 

  2358.   for (row=0; row < raw_height; row++) {
    2359. 

  2359.     if ((row & 31) == 0) {
    2360. 

  2360.       fseek (ifp, strip[row >> 5], SEEK_SET);
    2361. 

  2361.       getbits(-1);
    2362. 

  2362.       pi = 0;
    2363. 

  2363.     }
    2364. 

  2364.     for (col=0; col < raw_width; col++) {
    2365. 

  2365.       chess = (row + col) & 1;
    2366. 

  2366.       pi1 = chess ? pi-2           : pi-raw_width-1;
    2367. 

  2367.       pi2 = chess ? pi-2*raw_width : pi-raw_width+1;
    2368. 

  2368.       if (col <= chess) pi1 = -1;
    2369. 

  2369.       if (pi1 < 0) pi1 = pi2;
    2370. 

  2370.       if (pi2 < 0) pi2 = pi1;
    2371. 

  2371.       if (pi1 < 0 && col > 1) pi1 = pi2 = pi-2;
    2372. 

  2372.       pred = (pi1 < 0) ? 0 : (pixel[pi1] + pixel[pi2]) >> 1;
    2373. 

  2373.       pixel[pi] = val = pred + ljpeg_diff (huff[chess]);
    2374. 

  2374.       if (val >> 8) derror();
    2375. 

  2375.       val = curve[pixel[pi++]];
    2376. 

  2376.       RAW(row,col) = val;
    2377. 

  2377.     }
    2378. 

  2378.   }
    2379. 

  2379.   free (pixel);
    2380. 

  2380.   FORC(2) free (huff[c]);
    2381. 

  2381. }
    2382. 

  2382. 

  2383. int CLASS kodak_65000_decode (short *out, int bsize)
    2384. 

  2384. {
    2385. 

  2385.   uchar c, blen[768];
    2386. 

  2386.   ushort raw[6];
    2387. 

  2387.   INT64 bitbuf=0;
    2388. 

  2388.   int save, bits=0, i, j, len, diff;
    2389. 

  2389. 

  2390.   save = ftell(ifp);
    2391. 

  2391.   bsize = (bsize + 3) & -4;
    2392. 

  2392.   for (i=0; i < bsize; i+=2) {
    2393. 

  2393.     c = fgetc(ifp);
    2394. 

  2394.     if ((blen[i  ] = c & 15) > 12 ||
    2395. 

  2395. 	(blen[i+1] = c >> 4) > 12 ) {
    2396. 

  2396.       fseek (ifp, save, SEEK_SET);
    2397. 

  2397.       for (i=0; i < bsize; i+=8) {
    2398. 

  2398. 	read_shorts (raw, 6);
    2399. 

  2399. 	out[i  ] = raw[0] >> 12 << 8 | raw[2] >> 12 << 4 | raw[4] >> 12;
    2400. 

  2400. 	out[i+1] = raw[1] >> 12 << 8 | raw[3] >> 12 << 4 | raw[5] >> 12;
    2401. 

  2401. 	for (j=0; j < 6; j++)
    2402. 

  2402. 	  out[i+2+j] = raw[j] & 0xfff;
    2403. 

  2403.       }
    2404. 

  2404.       return 1;
    2405. 

  2405.     }
    2406. 

  2406.   }
    2407. 

  2407.   if ((bsize & 7) == 4) {
    2408. 

  2408.     bitbuf  = fgetc(ifp) << 8;
    2409. 

  2409.     bitbuf += fgetc(ifp);
    2410. 

  2410.     bits = 16;
    2411. 

  2411.   }
    2412. 

  2412.   for (i=0; i < bsize; i++) {
    2413. 

  2413.     len = blen[i];
    2414. 

  2414.     if (bits < len) {
    2415. 

  2415.       for (j=0; j < 32; j+=8)
    2416. 

  2416. 	bitbuf += (INT64) fgetc(ifp) << (bits+(j^8));
    2417. 

  2417.       bits += 32;
    2418. 

  2418.     }
    2419. 

  2419.     diff = bitbuf & (0xffff >> (16-len));
    2420. 

  2420.     bitbuf >>= len;
    2421. 

  2421.     bits -= len;
    2422. 

  2422.     if ((diff & (1 << (len-1))) == 0)
    2423. 

  2423.       diff -= (1 << len) - 1;
    2424. 

  2424.     out[i] = diff;
    2425. 

  2425.   }
    2426. 

  2426.   return 0;
    2427. 

  2427. }
    2428. 

  2428. 

  2429. void CLASS kodak_65000_load_raw()
    2430. 

  2430. {
    2431. 

  2431.   short buf[256];
    2432. 

  2432.   int row, col, len, pred[2], ret, i;
    2433. 

  2433. 

  2434.   for (row=0; row < height; row++)
    2435. 

  2435.     for (col=0; col < width; col+=256) {
    2436. 

  2436.       pred[0] = pred[1] = 0;
    2437. 

  2437.       len = MIN (256, width-col);
    2438. 

  2438.       ret = kodak_65000_decode (buf, len);
    2439. 

  2439.       for (i=0; i < len; i++)
    2440. 

  2440. 	if ((RAW(row,col+i) =	curve[ret ? buf[i] :
    2441. 

  2441. 		(pred[i & 1] += buf[i])]) >> 12) derror();
    2442. 

  2442.     }
    2443. 

  2443. }
    2444. 

  2444. 

  2445. void CLASS kodak_ycbcr_load_raw()
    2446. 

  2446. {
    2447. 

  2447.   short buf[384], *bp;
    2448. 

  2448.   int row, col, len, c, i, j, k, y[2][2], cb, cr, rgb[3];
    2449. 

  2449.   ushort *ip;
    2450. 

  2450. 

  2451.   for (row=0; row < height; row+=2)
    2452. 

  2452.     for (col=0; col < width; col+=128) {
    2453. 

  2453.       len = MIN (128, width-col);
    2454. 

  2454.       kodak_65000_decode (buf, len*3);
    2455. 

  2455.       y[0][1] = y[1][1] = cb = cr = 0;
    2456. 

  2456.       for (bp=buf, i=0; i < len; i+=2, bp+=2) {
    2457. 

  2457. 	cb += bp[4];
    2458. 

  2458. 	cr += bp[5];
    2459. 

  2459. 	rgb[1] = -((cb + cr + 2) >> 2);
    2460. 

  2460. 	rgb[2] = rgb[1] + cb;
    2461. 

  2461. 	rgb[0] = rgb[1] + cr;
    2462. 

  2462. 	for (j=0; j < 2; j++)
    2463. 

  2463. 	  for (k=0; k < 2; k++) {
    2464. 

  2464. 	    if ((y[j][k] = y[j][k^1] + *bp++) >> 10) derror();
    2465. 

  2465. 	    ip = image[(row+j)*width + col+i+k];
    2466. 

  2466. 	    FORC3 ip[c] = curve[LIM(y[j][k]+rgb[c], 0, 0xfff)];
    2467. 

  2467. 	  }
    2468. 

  2468.       }
    2469. 

  2469.     }
    2470. 

  2470. }
    2471. 

  2471. 

  2472. void CLASS kodak_rgb_load_raw()
    2473. 

  2473. {
    2474. 

  2474.   short buf[768], *bp;
    2475. 

  2475.   int row, col, len, c, i, rgb[3];
    2476. 

  2476.   ushort *ip=image[0];
    2477. 

  2477. 

  2478. #ifndef LIBRAW_LIBRARY_BUILD
    2479. 

  2479.   if (raw_image) free (raw_image);
    2480. 

  2480.   raw_image = 0;
    2481. 

  2481. #endif
    2482. 

  2482.   for (row=0; row < height; row++)
    2483. 

  2483.     for (col=0; col < width; col+=256) {
    2484. 

  2484.       len = MIN (256, width-col);
    2485. 

  2485.       kodak_65000_decode (buf, len*3);
    2486. 

  2486.       memset (rgb, 0, sizeof rgb);
    2487. 

  2487.       for (bp=buf, i=0; i < len; i++, ip+=4)
    2488. 

  2488. 	FORC3 if ((ip[c] = rgb[c] += *bp++) >> 12) derror();
    2489. 

  2489.     }
    2490. 

  2490. }
    2491. 

  2491. 

  2492. void CLASS kodak_thumb_load_raw()
    2493. 

  2493. {
    2494. 

  2494.   int row, col;
    2495. 

  2495.   colors = thumb_misc >> 5;
    2496. 

  2496.   for (row=0; row < height; row++)
    2497. 

  2497.     for (col=0; col < width; col++)
    2498. 

  2498.       read_shorts (image[row*width+col], colors);
    2499. 

  2499.   maximum = (1 << (thumb_misc & 31)) - 1;
    2500. 

  2500. }
    2501. 

  2501. 

  2502. void CLASS sony_decrypt (unsigned *data, int len, int start, int key)
    2503. 

  2503. {
    2504. 

  2504. #ifndef LIBRAW_NOTHREADS
    2505. 

  2505. #define pad tls->sony_decrypt.pad
    2506. 

  2506. #define p   tls->sony_decrypt.p
    2507. 

  2507. #else
    2508. 

  2508.   static unsigned pad[128], p;
    2509. 

  2509. #endif
    2510. 

  2510.   if (start) {
    2511. 

  2511.     for (p=0; p < 4; p++)
    2512. 

  2512.       pad[p] = key = key * 48828125 + 1;
    2513. 

  2513.     pad[3] = pad[3] << 1 | (pad[0]^pad[2]) >> 31;
    2514. 

  2514.     for (p=4; p < 127; p++)
    2515. 

  2515.       pad[p] = (pad[p-4]^pad[p-2]) << 1 | (pad[p-3]^pad[p-1]) >> 31;
    2516. 

  2516.     for (p=0; p < 127; p++)
    2517. 

  2517.       pad[p] = htonl(pad[p]);
    2518. 

  2518.   }
    2519. 

  2519. #if 1 // Avoid gcc 4.8 bug
    2520. 

  2520.   while (len--)
    2521. 

  2521.     {
    2522. 

  2522.       *data++ ^= pad[p & 127] = pad[(p+1) & 127] ^ pad[(p+65) & 127];
    2523. 

  2523.       p++;     
    2524. 

  2524.     }
    2525. 

  2525. #else
    2526. 

  2526.   while (len--)
    2527. 

  2527.     *data++ ^= pad[p++ & 127] = pad[(p+1) & 127] ^ pad[(p+65) & 127];
    2528. 

  2528. #endif
    2529. 

  2529. #ifndef LIBRAW_NOTHREADS
    2530. 

  2530. #undef pad
    2531. 

  2531. #undef p
    2532. 

  2532. #endif
    2533. 

  2533. }
    2534. 

  2534. 

  2535. void CLASS sony_load_raw()
    2536. 

  2536. {
    2537. 

  2537.   uchar head[40];
    2538. 

  2538.   ushort *pixel;
    2539. 

  2539.   unsigned i, key, row, col;
    2540. 

  2540. 

  2541.   fseek (ifp, 200896, SEEK_SET);
    2542. 

  2542.   fseek (ifp, (unsigned) fgetc(ifp)*4 - 1, SEEK_CUR);
    2543. 

  2543.   order = 0x4d4d;
    2544. 

  2544.   key = get4();
    2545. 

  2545.   fseek (ifp, 164600, SEEK_SET);
    2546. 

  2546.   fread (head, 1, 40, ifp);
    2547. 

  2547.   sony_decrypt ((unsigned int *) head, 10, 1, key);
    2548. 

  2548.   for (i=26; i-- > 22; )
    2549. 

  2549.     key = key << 8 | head[i];
    2550. 

  2550.   fseek (ifp, data_offset, SEEK_SET);
    2551. 

  2551.   for (row=0; row < raw_height; row++) {
    2552. 

  2552.     pixel = raw_image + row*raw_width;
    2553. 

  2553.     if (fread (pixel, 2, raw_width, ifp) < raw_width) derror();
    2554. 

  2554.     sony_decrypt ((unsigned int *) pixel, raw_width/2, !row, key);
    2555. 

  2555.     for (col=0; col < raw_width; col++)
    2556. 

  2556.       if ((pixel[col] = ntohs(pixel[col])) >> 14) derror();
    2557. 

  2557.   }
    2558. 

  2558.   maximum = 0x3ff0;
    2559. 

  2559. }
    2560. 

  2560. 

  2561. void CLASS sony_arw_load_raw()
    2562. 

  2562. {
    2563. 

  2563.   ushort huff[32768];
    2564. 

  2564.   static const ushort tab[18] =
    2565. 

  2565.   { 0xf11,0xf10,0xe0f,0xd0e,0xc0d,0xb0c,0xa0b,0x90a,0x809,
    2566. 

  2566.     0x708,0x607,0x506,0x405,0x304,0x303,0x300,0x202,0x201 };
    2567. 

  2567.   int i, c, n, col, row, len, diff, sum=0;
    2568. 

  2568. 

  2569.   for (n=i=0; i < 18; i++)
    2570. 

  2570.     FORC(32768 >> (tab[i] >> 8)) huff[n++] = tab[i];
    2571. 

  2571. #ifdef LIBRAW_LIBRARY_BUILD
    2572. 

  2572.   LibRaw_byte_buffer *buf=NULL;
    2573. 

  2573.   if(data_size)
    2574. 

  2574.       buf = ifp->make_byte_buffer(data_size);
    2575. 

  2575.   else
    2576. 

  2576.       getbits(-1);
    2577. 

  2577.       
    2578. 

  2578.   LibRaw_bit_buffer bits;
    2579. 

  2579.   bits.reset();
    2580. 

  2580. #else
    2581. 

  2581.   getbits(-1);
    2582. 

  2582. #endif
    2583. 

  2583.   for (col = raw_width; col--; )
    2584. 

  2584.     for (row=0; row < raw_height+1; row+=2) {
    2585. 

  2585.       if (row == raw_height) row = 1;
    2586. 

  2586. #ifdef LIBRAW_LIBRARY_BUILD
    2587. 

  2587.       if(data_size)
    2588. 

  2588.           {
    2589. 

  2589.               len = bits._gethuff(buf,15,huff,zero_after_ff);
    2590. 

  2590.               diff = bits._getbits(buf,len,zero_after_ff);
    2591. 

  2591.           }
    2592. 

  2592.       else
    2593. 

  2593.           {
    2594. 

  2594.               len = getbithuff(15,huff);
    2595. 

  2595.               diff = getbits(len);
    2596. 

  2596.           }
    2597. 

  2597. #else
    2598. 

  2598.       len = getbithuff(15,huff);
    2599. 

  2599.       diff = getbits(len);
    2600. 

  2600. #endif
    2601. 

  2601.       if ((diff & (1 << (len-1))) == 0)
    2602. 

  2602. 	diff -= (1 << len) - 1;
    2603. 

  2603.       if ((sum += diff) >> 12) derror();
    2604. 

  2604.       if (row < height) RAW(row,col) = sum;
    2605. 

  2605.     }
    2606. 

  2606. #ifdef LIBRAW_LIBRARY_BUILD
    2607. 

  2607.   if(buf) delete buf;
    2608. 

  2608. #endif
    2609. 

  2609. }
    2610. 

  2610. 

  2611. void CLASS sony_arw2_load_raw()
    2612. 

  2612. {
    2613. 

  2613.   uchar *data, *dp;
    2614. 

  2614.   ushort pix[16];
    2615. 

  2615.   int row, col, val, max, min, imax, imin, sh, bit, i;
    2616. 

  2616. 

  2617.   data = (uchar *) malloc (raw_width);
    2618. 

  2618.   merror (data, "sony_arw2_load_raw()");
    2619. 

  2619.   for (row=0; row < height; row++) {
    2620. 

  2620.     fread (data, 1, raw_width, ifp);
    2621. 

  2621.     for (dp=data, col=0; col < raw_width-30; dp+=16) {
    2622. 

  2622.       max = 0x7ff & (val = sget4(dp));
    2623. 

  2623.       min = 0x7ff & val >> 11;
    2624. 

  2624.       imax = 0x0f & val >> 22;
    2625. 

  2625.       imin = 0x0f & val >> 26;
    2626. 

  2626.       for (sh=0; sh < 4 && 0x80 << sh <= max-min; sh++);
    2627. 

  2627.       for (bit=30, i=0; i < 16; i++)
    2628. 

  2628. 	if      (i == imax) pix[i] = max;
    2629. 

  2629. 	else if (i == imin) pix[i] = min;
    2630. 

  2630. 	else {
    2631. 

  2631. 	  pix[i] = ((sget2(dp+(bit >> 3)) >> (bit & 7) & 0x7f) << sh) + min;
    2632. 

  2632. 	  if (pix[i] > 0x7ff) pix[i] = 0x7ff;
    2633. 

  2633. 	  bit += 7;
    2634. 

  2634. 	}
    2635. 

  2635. #ifdef LIBRAW_LIBRARY_BUILD
    2636. 

  2636.       if(imgdata.params.sony_arw2_hack)
    2637. 

  2637.           {
    2638. 

  2638.               for (i=0; i < 16; i++, col+=2)
    2639. 

  2639.                   RAW(row,col) = curve[pix[i] << 1];
    2640. 

  2640.           }
    2641. 

  2641.       else
    2642. 

  2642.           {
    2643. 

  2643.               for (i=0; i < 16; i++, col+=2)
    2644. 

  2644.                   RAW(row,col) = curve[pix[i] << 1] >> 2;
    2645. 

  2645.           }
    2646. 

  2646. #else
    2647. 

  2647.       for (i=0; i < 16; i++, col+=2)
    2648. 

  2648. 	RAW(row,col) = curve[pix[i] << 1] >> 2;
    2649. 

  2649. #endif
    2650. 

  2650.       col -= col & 1 ? 1:31;
    2651. 

  2651.     }
    2652. 

  2652.   }
    2653. 

  2653.   free (data);
    2654. 

  2654. #ifdef LIBRAW_LIBRARY_BUILD
    2655. 

  2655.   if(imgdata.params.sony_arw2_hack)
    2656. 

  2656.   {
    2657. 

  2657. 	black <<= 2;
    2658. 

  2658. 	maximum <<=2;
    2659. 

  2659.   }
    2660. 

  2660. #endif
    2661. 

  2661. }
    2662. 

  2662. 

  2663. #define HOLE(row) ((holes >> (((row) - raw_height) & 7)) & 1)
    2664. 

  2664. 

  2665. /* Kudos to Rich Taylor for figuring out SMaL's compression algorithm. */
    2666. 

  2666. void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
    2667. 

  2667. {
    2668. 

  2668.   uchar hist[3][13] = {
    2669. 

  2669.     { 7, 7, 0, 0, 63, 55, 47, 39, 31, 23, 15, 7, 0 },
    2670. 

  2670.     { 7, 7, 0, 0, 63, 55, 47, 39, 31, 23, 15, 7, 0 },
    2671. 

  2671.     { 3, 3, 0, 0, 63,     47,     31,     15,    0 } };
    2672. 

  2672.   int low, high=0xff, carry=0, nbits=8;
    2673. 

  2673.   int pix, s, count, bin, next, i, sym[3];
    2674. 

  2674.   uchar diff, pred[]={0,0};
    2675. 

  2675.   ushort data=0, range=0;
    2676. 

  2676. 

  2677.   fseek (ifp, seg[0][1]+1, SEEK_SET);
    2678. 

  2678.   getbits(-1);
    2679. 

  2679.   for (pix=seg[0][0]; pix < seg[1][0]; pix++) {
    2680. 

  2680.     for (s=0; s < 3; s++) {
    2681. 

  2681.       data = data << nbits | getbits(nbits);
    2682. 

  2682.       if (carry < 0)
    2683. 

  2683. 	carry = (nbits += carry+1) < 1 ? nbits-1 : 0;
    2684. 

  2684.       while (--nbits >= 0)
    2685. 

  2685. 	if ((data >> nbits & 0xff) == 0xff) break;
    2686. 

  2686.       if (nbits > 0)
    2687. 

  2687. 	  data = ((data & ((1 << (nbits-1)) - 1)) << 1) |
    2688. 

  2688. 	((data + (((data & (1 << (nbits-1)))) << 1)) & (-1 << nbits));
    2689. 

  2689.       if (nbits >= 0) {
    2690. 

  2690. 	data += getbits(1);
    2691. 

  2691. 	carry = nbits - 8;
    2692. 

  2692.       }
    2693. 

  2693.       count = ((((data-range+1) & 0xffff) << 2) - 1) / (high >> 4);
    2694. 

  2694.       for (bin=0; hist[s][bin+5] > count; bin++);
    2695. 

  2695. 		low = hist[s][bin+5] * (high >> 4) >> 2;
    2696. 

  2696.       if (bin) high = hist[s][bin+4] * (high >> 4) >> 2;
    2697. 

  2697.       high -= low;
    2698. 

  2698.       for (nbits=0; high << nbits < 128; nbits++);
    2699. 

  2699.       range = (range+low) << nbits;
    2700. 

  2700.       high <<= nbits;
    2701. 

  2701.       next = hist[s][1];
    2702. 

  2702.       if (++hist[s][2] > hist[s][3]) {
    2703. 

  2703. 	next = (next+1) & hist[s][0];
    2704. 

  2704. 	hist[s][3] = (hist[s][next+4] - hist[s][next+5]) >> 2;
    2705. 

  2705. 	hist[s][2] = 1;
    2706. 

  2706.       }
    2707. 

  2707.       if (hist[s][hist[s][1]+4] - hist[s][hist[s][1]+5] > 1) {
    2708. 

  2708. 	if (bin < hist[s][1])
    2709. 

  2709. 	  for (i=bin; i < hist[s][1]; i++) hist[s][i+5]--;
    2710. 

  2710. 	else if (next <= bin)
    2711. 

  2711. 	  for (i=hist[s][1]; i < bin; i++) hist[s][i+5]++;
    2712. 

  2712.       }
    2713. 

  2713.       hist[s][1] = next;
    2714. 

  2714.       sym[s] = bin;
    2715. 

  2715.     }
    2716. 

  2716.     diff = sym[2] << 5 | sym[1] << 2 | (sym[0] & 3);
    2717. 

  2717.     if (sym[0] & 4)
    2718. 

  2718.       diff = diff ? -diff : 0x80;
    2719. 

  2719.     if (ftell(ifp) + 12 >= seg[1][1])
    2720. 

  2720.       diff = 0;
    2721. 

  2721.     raw_image[pix] = pred[pix & 1] += diff;
    2722. 

  2722.     if (!(pix & 1) && HOLE(pix / raw_width)) pix += 2;
    2723. 

  2723.   }
    2724. 

  2724.   maximum = 0xff;
    2725. 

  2725. }
    2726. 

  2726. 

  2727. void CLASS smal_v6_load_raw()
    2728. 

  2728. {
    2729. 

  2729.   unsigned seg[2][2];
    2730. 

  2730. 

  2731.   fseek (ifp, 16, SEEK_SET);
    2732. 

  2732.   seg[0][0] = 0;
    2733. 

  2733.   seg[0][1] = get2();
    2734. 

  2734.   seg[1][0] = raw_width * raw_height;
    2735. 

  2735.   seg[1][1] = INT_MAX;
    2736. 

  2736.   smal_decode_segment (seg, 0);
    2737. 

  2737. }
    2738. 

  2738. 

  2739. int CLASS median4 (int *p)
    2740. 

  2740. {
    2741. 

  2741.   int min, max, sum, i;
    2742. 

  2742. 

  2743.   min = max = sum = p[0];
    2744. 

  2744.   for (i=1; i < 4; i++) {
    2745. 

  2745.     sum += p[i];
    2746. 

  2746.     if (min > p[i]) min = p[i];
    2747. 

  2747.     if (max < p[i]) max = p[i];
    2748. 

  2748.   }
    2749. 

  2749.   return (sum - min - max) >> 1;
    2750. 

  2750. }
    2751. 

  2751. 

  2752. void CLASS fill_holes (int holes)
    2753. 

  2753. {
    2754. 

  2754.   int row, col, val[4];
    2755. 

  2755. 

  2756.   for (row=2; row < height-2; row++) {
    2757. 

  2757.     if (!HOLE(row)) continue;
    2758. 

  2758.     for (col=1; col < width-1; col+=4) {
    2759. 

  2759.       val[0] = RAW(row-1,col-1);
    2760. 

  2760.       val[1] = RAW(row-1,col+1);
    2761. 

  2761.       val[2] = RAW(row+1,col-1);
    2762. 

  2762.       val[3] = RAW(row+1,col+1);
    2763. 

  2763.       RAW(row,col) = median4(val);
    2764. 

  2764.     }
    2765. 

  2765.     for (col=2; col < width-2; col+=4)
    2766. 

  2766.       if (HOLE(row-2) || HOLE(row+2))
    2767. 

  2767. 	RAW(row,col) = (RAW(row,col-2) + RAW(row,col+2)) >> 1;
    2768. 

  2768.       else {
    2769. 

  2769. 	val[0] = RAW(row,col-2);
    2770. 

  2770. 	val[1] = RAW(row,col+2);
    2771. 

  2771. 	val[2] = RAW(row-2,col);
    2772. 

  2772. 	val[3] = RAW(row+2,col);
    2773. 

  2773. 	RAW(row,col) = median4(val);
    2774. 

  2774.       }
    2775. 

  2775.   }
    2776. 

  2776. }
    2777. 

  2777. 

  2778. void CLASS smal_v9_load_raw()
    2779. 

  2779. {
    2780. 

  2780.   unsigned seg[256][2], offset, nseg, holes, i;
    2781. 

  2781. 

  2782.   fseek (ifp, 67, SEEK_SET);
    2783. 

  2783.   offset = get4();
    2784. 

  2784.   nseg = fgetc(ifp);
    2785. 

  2785.   fseek (ifp, offset, SEEK_SET);
    2786. 

  2786.   for (i=0; i < nseg*2; i++)
    2787. 

  2787.     seg[0][i] = get4() + data_offset*(i & 1);
    2788. 

  2788.   fseek (ifp, 78, SEEK_SET);
    2789. 

  2789.   holes = fgetc(ifp);
    2790. 

  2790.   fseek (ifp, 88, SEEK_SET);
    2791. 

  2791.   seg[nseg][0] = raw_height * raw_width;
    2792. 

  2792.   seg[nseg][1] = get4() + data_offset;
    2793. 

  2793.   for (i=0; i < nseg; i++)
    2794. 

  2794.     smal_decode_segment (seg+i, holes);
    2795. 

  2795.   if (holes) fill_holes (holes);
    2796. 

  2796. }
    2797. 

  2797. 

  2798. void CLASS redcine_load_raw()
    2799. 

  2799. {
    2800. 

  2800. #ifndef NO_JASPER
    2801. 

  2801.   int c, row, col;
    2802. 

  2802.   jas_stream_t *in;
    2803. 

  2803.   jas_image_t *jimg;
    2804. 

  2804.   jas_matrix_t *jmat;
    2805. 

  2805.   jas_seqent_t *data;
    2806. 

  2806.   ushort *img, *pix;
    2807. 

  2807. 

  2808.   jas_init();
    2809. 

  2809. #ifndef LIBRAW_LIBRARY_BUILD
    2810. 

  2810.   in = jas_stream_fopen (ifname, "rb");
    2811. 

  2811. #else
    2812. 

  2812.   in = (jas_stream_t*)ifp->make_jas_stream();
    2813. 

  2813.   if(!in)
    2814. 

  2814.           throw LIBRAW_EXCEPTION_DECODE_JPEG2000;
    2815. 

  2815. #endif
    2816. 

  2816.   jas_stream_seek (in, data_offset+20, SEEK_SET);
    2817. 

  2817.   jimg = jas_image_decode (in, -1, 0);
    2818. 

  2818. #ifndef LIBRAW_LIBRARY_BUILD
    2819. 

  2819.   if (!jimg) longjmp (failure, 3);
    2820. 

  2820. #else
    2821. 

  2821.   if(!jimg)
    2822. 

  2822.       {
    2823. 

  2823.           jas_stream_close (in);
    2824. 

  2824.           throw LIBRAW_EXCEPTION_DECODE_JPEG2000;
    2825. 

  2825.       }
    2826. 

  2826. #endif
    2827. 

  2827.   jmat = jas_matrix_create (height/2, width/2);
    2828. 

  2828.   merror (jmat, "redcine_load_raw()");
    2829. 

  2829.   img = (ushort *) calloc ((height+2)*(width+2), 2);
    2830. 

  2830.   merror (img, "redcine_load_raw()");
    2831. 

  2831.   FORC4 {
    2832. 

  2832.     jas_image_readcmpt (jimg, c, 0, 0, width/2, height/2, jmat);
    2833. 

  2833.     data = jas_matrix_getref (jmat, 0, 0);
    2834. 

  2834.     for (row = c >> 1; row < height; row+=2)
    2835. 

  2835.       for (col = c & 1; col < width; col+=2)
    2836. 

  2836. 	img[(row+1)*(width+2)+col+1] = data[(row/2)*(width/2)+col/2];
    2837. 

  2837.   }
    2838. 

  2838.   for (col=1; col <= width; col++) {
    2839. 

  2839.     img[col] = img[2*(width+2)+col];
    2840. 

  2840.     img[(height+1)*(width+2)+col] = img[(height-1)*(width+2)+col];
    2841. 

  2841.   }
    2842. 

  2842.   for (row=0; row < height+2; row++) {
    2843. 

  2843.     img[row*(width+2)] = img[row*(width+2)+2];
    2844. 

  2844.     img[(row+1)*(width+2)-1] = img[(row+1)*(width+2)-3];
    2845. 

  2845.   }
    2846. 

  2846.   for (row=1; row <= height; row++) {
    2847. 

  2847.     pix = img + row*(width+2) + (col = 1 + (FC(row,1) & 1));
    2848. 

  2848.     for (   ; col <= width; col+=2, pix+=2) {
    2849. 

  2849.       c = (((pix[0] - 0x800) << 3) +
    2850. 

  2850. 	pix[-(width+2)] + pix[width+2] + pix[-1] + pix[1]) >> 2;
    2851. 

  2851.       pix[0] = LIM(c,0,4095);
    2852. 

  2852.     }
    2853. 

  2853.   }
    2854. 

  2854.   for (row=0; row < height; row++)
    2855. 

  2855.     for (col=0; col < width; col++)
    2856. 

  2856.       RAW(row,col) = curve[img[(row+1)*(width+2)+col+1]];
    2857. 

  2857.   free (img);
    2858. 

  2858.   jas_matrix_destroy (jmat);
    2859. 

  2859.   jas_image_destroy (jimg);
    2860. 

  2860.   jas_stream_close (in);
    2861. 

  2861. #endif
    2862. 

  2862. }
    2863. 

  2863. void CLASS crop_masked_pixels()
    2864. 

  2864. {
    2865. 

  2865.   int row, col;
    2866. 

  2866.   unsigned 
    2867. 

  2867. #ifndef LIBRAW_LIBRARY_BUILD
    2868. 

  2868.     r, raw_pitch = raw_width*2,
    2869. 

  2869. #endif
    2870. 

  2870.     c, m, mblack[8], zero, val;
    2871. 

  2871. 

  2872. #ifndef LIBRAW_LIBRARY_BUILD
    2873. 

  2873.   if (load_raw == &CLASS phase_one_load_raw ||
    2874. 

  2874.       load_raw == &CLASS phase_one_load_raw_c)
    2875. 

  2875.     phase_one_correct();
    2876. 

  2876.   if (fuji_width) {
    2877. 

  2877.     for (row=0; row < raw_height-top_margin*2; row++) {
    2878. 

  2878.       for (col=0; col < fuji_width << !fuji_layout; col++) {
    2879. 

  2879. 	if (fuji_layout) {
    2880. 

  2880. 	  r = fuji_width - 1 - col + (row >> 1);
    2881. 

  2881. 	  c = col + ((row+1) >> 1);
    2882. 

  2882. 	} else {
    2883. 

  2883. 	  r = fuji_width - 1 + row - (col >> 1);
    2884. 

  2884. 	  c = row + ((col+1) >> 1);
    2885. 

  2885. 	}
    2886. 

  2886. 	if (r < height && c < width)
    2887. 

  2887. 	  BAYER(r,c) = RAW(row+top_margin,col+left_margin);
    2888. 

  2888.       }
    2889. 

  2889.     }
    2890. 

  2890.   } else {
    2891. 

  2891.     for (row=0; row < height; row++)
    2892. 

  2892.       for (col=0; col < width; col++)
    2893. 

  2893. 	BAYER2(row,col) = RAW(row+top_margin,col+left_margin);
    2894. 

  2894.   }
    2895. 

  2895. #endif
    2896. 

  2896.   if (mask[0][3]) goto mask_set;
    2897. 

  2897.   if (load_raw == &CLASS canon_load_raw ||
    2898. 

  2898.       load_raw == &CLASS lossless_jpeg_load_raw) {
    2899. 

  2899.     mask[0][1] = mask[1][1] = 2;
    2900. 

  2900.     mask[0][3] = -2;
    2901. 

  2901.     goto sides;
    2902. 

  2902.   }
    2903. 

  2903.   if (load_raw == &CLASS canon_600_load_raw ||
    2904. 

  2904.       load_raw == &CLASS sony_load_raw ||
    2905. 

  2905.      (load_raw == &CLASS eight_bit_load_raw && strncmp(model,"DC2",3)) ||
    2906. 

  2906.       load_raw == &CLASS kodak_262_load_raw ||
    2907. 

  2907.      (load_raw == &CLASS packed_load_raw && (load_flags & 32))) {
    2908. 

  2908. sides:
    2909. 

  2909.     mask[0][0] = mask[1][0] = top_margin;
    2910. 

  2910.     mask[0][2] = mask[1][2] = top_margin+height;
    2911. 

  2911.     mask[0][3] += left_margin;
    2912. 

  2912.     mask[1][1] += left_margin+width;
    2913. 

  2913.     mask[1][3] += raw_width;
    2914. 

  2914.   }
    2915. 

  2915.   if (load_raw == &CLASS nokia_load_raw) {
    2916. 

  2916.     mask[0][2] = top_margin;
    2917. 

  2917.     mask[0][3] = width;
    2918. 

  2918.   }
    2919. 

  2919. mask_set:
    2920. 

  2920.   memset (mblack, 0, sizeof mblack);
    2921. 

  2921.   for (zero=m=0; m < 8; m++)
    2922. 

  2922.     for (row=mask[m][0]; row < mask[m][2]; row++)
    2923. 

  2923.       for (col=mask[m][1]; col < mask[m][3]; col++) {
    2924. 

  2924. 	c = FC(row-top_margin,col-left_margin);
    2925. 

  2925. 	mblack[c] += val = raw_image[(row)*raw_pitch/2+(col)];
    2926. 

  2926. 	mblack[4+c]++;
    2927. 

  2927. 	zero += !val;
    2928. 

  2928.       }
    2929. 

  2929.   if (load_raw == &CLASS canon_600_load_raw && width < raw_width) {
    2930. 

  2930.     black = (mblack[0]+mblack[1]+mblack[2]+mblack[3]) /
    2931. 

  2931. 	    (mblack[4]+mblack[5]+mblack[6]+mblack[7]) - 4;
    2932. 

  2932. #ifndef LIBRAW_LIBRARY_BUILD
    2933. 

  2933.     canon_600_correct();
    2934. 

  2934. #endif
    2935. 

  2935.   } else if (zero < mblack[4] && mblack[5] && mblack[6] && mblack[7])
    2936. 

  2936.     FORC4 cblack[c] = mblack[c] / mblack[4+c];
    2937. 

  2937. }
    2938. 

  2938. 

  2939. void CLASS remove_zeroes()
    2940. 

  2940. {
    2941. 

  2941.   unsigned row, col, tot, n, r, c;
    2942. 

  2942. 

  2943. #ifdef LIBRAW_LIBRARY_BUILD
    2944. 

  2944.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,0,2);
    2945. 

  2945. #endif
    2946. 

  2946. 

  2947.   for (row=0; row < height; row++)
    2948. 

  2948.     for (col=0; col < width; col++)
    2949. 

  2949.       if (BAYER(row,col) == 0) {
    2950. 

  2950. 	tot = n = 0;
    2951. 

  2951. 	for (r = row-2; r <= row+2; r++)
    2952. 

  2952. 	  for (c = col-2; c <= col+2; c++)
    2953. 

  2953. 	    if (r < height && c < width &&
    2954. 

  2954. 		FC(r,c) == FC(row,col) && BAYER(r,c))
    2955. 

  2955. 	      tot += (n++,BAYER(r,c));
    2956. 

  2956. 	if (n) BAYER(row,col) = tot/n;
    2957. 

  2957.       }
    2958. 

  2958. #ifdef LIBRAW_LIBRARY_BUILD
    2959. 

  2959.   RUN_CALLBACK(LIBRAW_PROGRESS_REMOVE_ZEROES,1,2);
    2960. 

  2960. #endif
    2961. 

  2961. }
    2962. 

  2962. void CLASS gamma_curve (double pwr, double ts, int mode, int imax)
    2963. 

  2963. {
    2964. 

  2964.   int i;
    2965. 

  2965.   double g[6], bnd[2]={0,0}, r;
    2966. 

  2966. 

  2967.   g[0] = pwr;
    2968. 

  2968.   g[1] = ts;
    2969. 

  2969.   g[2] = g[3] = g[4] = 0;
    2970. 

  2970.   bnd[g[1] >= 1] = 1;
    2971. 

  2971.   if (g[1] && (g[1]-1)*(g[0]-1) <= 0) {
    2972. 

  2972.     for (i=0; i < 48; i++) {
    2973. 

  2973.       g[2] = (bnd[0] + bnd[1])/2;
    2974. 

  2974.       if (g[0]) bnd[(pow(g[2]/g[1],-g[0]) - 1)/g[0] - 1/g[2] > -1] = g[2];
    2975. 

  2975.       else	bnd[g[2]/exp(1-1/g[2]) < g[1]] = g[2];
    2976. 

  2976.     }
    2977. 

  2977.     g[3] = g[2] / g[1];
    2978. 

  2978.     if (g[0]) g[4] = g[2] * (1/g[0] - 1);
    2979. 

  2979.   }
    2980. 

  2980.   if (g[0]) g[5] = 1 / (g[1]*SQR(g[3])/2 - g[4]*(1 - g[3]) +
    2981. 

  2981. 		(1 - pow(g[3],1+g[0]))*(1 + g[4])/(1 + g[0])) - 1;
    2982. 

  2982.   else      g[5] = 1 / (g[1]*SQR(g[3])/2 + 1
    2983. 

  2983. 		- g[2] - g[3] -	g[2]*g[3]*(log(g[3]) - 1)) - 1;
    2984. 

  2984.   if (!mode--) {
    2985. 

  2985.     memcpy (gamm, g, sizeof gamm);
    2986. 

  2986.     return;
    2987. 

  2987.   }
    2988. 

  2988.   for (i=0; i < 0x10000; i++) {
    2989. 

  2989.     curve[i] = 0xffff;
    2990. 

  2990.     if ((r = (double) i / imax) < 1)
    2991. 

  2991.       curve[i] = 0x10000 * ( mode
    2992. 

  2992. 	? (r < g[3] ? r*g[1] : (g[0] ? pow( r,g[0])*(1+g[4])-g[4]    : log(r)*g[2]+1))
    2993. 

  2993. 	: (r < g[2] ? r/g[1] : (g[0] ? pow((r+g[4])/(1+g[4]),1/g[0]) : exp((r-1)/g[2]))));
    2994. 

  2994.   }
    2995. 

  2995. }
    2996. 

  2996. 

  2997. void CLASS pseudoinverse (double (*in)[3], double (*out)[3], int size)
    2998. 

  2998. {
    2999. 

  2999.   double work[3][6], num;
    3000. 

  3000.   int i, j, k;
    3001. 

  3001. 

  3002.   for (i=0; i < 3; i++) {
    3003. 

  3003.     for (j=0; j < 6; j++)
    3004. 

  3004.       work[i][j] = j == i+3;
    3005. 

  3005.     for (j=0; j < 3; j++)
    3006. 

  3006.       for (k=0; k < size; k++)
    3007. 

  3007. 	work[i][j] += in[k][i] * in[k][j];
    3008. 

  3008.   }
    3009. 

  3009.   for (i=0; i < 3; i++) {
    3010. 

  3010.     num = work[i][i];
    3011. 

  3011.     for (j=0; j < 6; j++)
    3012. 

  3012.       work[i][j] /= num;
    3013. 

  3013.     for (k=0; k < 3; k++) {
    3014. 

  3014.       if (k==i) continue;
    3015. 

  3015.       num = work[k][i];
    3016. 

  3016.       for (j=0; j < 6; j++)
    3017. 

  3017. 	work[k][j] -= work[i][j] * num;
    3018. 

  3018.     }
    3019. 

  3019.   }
    3020. 

  3020.   for (i=0; i < size; i++)
    3021. 

  3021.     for (j=0; j < 3; j++)
    3022. 

  3022.       for (out[i][j]=k=0; k < 3; k++)
    3023. 

  3023. 	out[i][j] += work[j][k+3] * in[i][k];
    3024. 

  3024. }
    3025. 

  3025. 

  3026. void CLASS cam_xyz_coeff (double cam_xyz[4][3])
    3027. 

  3027. {
    3028. 

  3028.   double cam_rgb[4][3], inverse[4][3], num;
    3029. 

  3029.   int i, j, k;
    3030. 

  3030. 

  3031.   for (i=0; i < colors; i++)		/* Multiply out XYZ colorspace */
    3032. 

  3032.     for (j=0; j < 3; j++)
    3033. 

  3033.       for (cam_rgb[i][j] = k=0; k < 3; k++)
    3034. 

  3034. 	cam_rgb[i][j] += cam_xyz[i][k] * xyz_rgb[k][j];
    3035. 

  3035. 

  3036.   for (i=0; i < colors; i++) {		/* Normalize cam_rgb so that */
    3037. 

  3037.     for (num=j=0; j < 3; j++)		/* cam_rgb * (1,1,1) is (1,1,1,1) */
    3038. 

  3038.       num += cam_rgb[i][j];
    3039. 

  3039.     for (j=0; j < 3; j++)
    3040. 

  3040.       cam_rgb[i][j] /= num;
    3041. 

  3041.     pre_mul[i] = 1 / num;
    3042. 

  3042.   }
    3043. 

  3043.   pseudoinverse (cam_rgb, inverse, colors);
    3044. 

  3044.   for (raw_color = i=0; i < 3; i++)
    3045. 

  3045.     for (j=0; j < colors; j++)
    3046. 

  3046.       rgb_cam[i][j] = inverse[j][i];
    3047. 

  3047. }
    3048. 

  3048. 

  3049. #ifdef COLORCHECK
    3050. 

  3050. void CLASS colorcheck()
    3051. 

  3051. {
    3052. 

  3052. #define NSQ 24
    3053. 

  3053. // Coordinates of the GretagMacbeth ColorChecker squares
    3054. 

  3054. // width, height, 1st_column, 1st_row
    3055. 

  3055.   int cut[NSQ][4];			// you must set these
    3056. 

  3056. // ColorChecker Chart under 6500-kelvin illumination
    3057. 

  3057.   static const double gmb_xyY[NSQ][3] = {
    3058. 

  3058.     { 0.400, 0.350, 10.1 },		// Dark Skin
    3059. 

  3059.     { 0.377, 0.345, 35.8 },		// Light Skin
    3060. 

  3060.     { 0.247, 0.251, 19.3 },		// Blue Sky
    3061. 

  3061.     { 0.337, 0.422, 13.3 },		// Foliage
    3062. 

  3062.     { 0.265, 0.240, 24.3 },		// Blue Flower
    3063. 

  3063.     { 0.261, 0.343, 43.1 },		// Bluish Green
    3064. 

  3064.     { 0.506, 0.407, 30.1 },		// Orange
    3065. 

  3065.     { 0.211, 0.175, 12.0 },		// Purplish Blue
    3066. 

  3066.     { 0.453, 0.306, 19.8 },		// Moderate Red
    3067. 

  3067.     { 0.285, 0.202, 6.6 },		// Purple
    3068. 

  3068.     { 0.380, 0.489, 44.3 },		// Yellow Green
    3069. 

  3069.     { 0.473, 0.438, 43.1 },		// Orange Yellow
    3070. 

  3070.     { 0.187, 0.129, 6.1 },		// Blue
    3071. 

  3071.     { 0.305, 0.478, 23.4 },		// Green
    3072. 

  3072.     { 0.539, 0.313, 12.0 },		// Red
    3073. 

  3073.     { 0.448, 0.470, 59.1 },		// Yellow
    3074. 

  3074.     { 0.364, 0.233, 19.8 },		// Magenta
    3075. 

  3075.     { 0.196, 0.252, 19.8 },		// Cyan
    3076. 

  3076.     { 0.310, 0.316, 90.0 },		// White
    3077. 

  3077.     { 0.310, 0.316, 59.1 },		// Neutral 8
    3078. 

  3078.     { 0.310, 0.316, 36.2 },		// Neutral 6.5
    3079. 

  3079.     { 0.310, 0.316, 19.8 },		// Neutral 5
    3080. 

  3080.     { 0.310, 0.316, 9.0 },		// Neutral 3.5
    3081. 

  3081.     { 0.310, 0.316, 3.1 } };		// Black
    3082. 

  3082.   double gmb_cam[NSQ][4], gmb_xyz[NSQ][3];
    3083. 

  3083.   double inverse[NSQ][3], cam_xyz[4][3], num;
    3084. 

  3084.   int c, i, j, k, sq, row, col, count[4];
    3085. 

  3085. 

  3086.   memset (gmb_cam, 0, sizeof gmb_cam);
    3087. 

  3087.   for (sq=0; sq < NSQ; sq++) {
    3088. 

  3088.     FORCC count[c] = 0;
    3089. 

  3089.     for   (row=cut[sq][3]; row < cut[sq][3]+cut[sq][1]; row++)
    3090. 

  3090.       for (col=cut[sq][2]; col < cut[sq][2]+cut[sq][0]; col++) {
    3091. 

  3091. 	c = FC(row,col);
    3092. 

  3092. 	if (c >= colors) c -= 2;
    3093. 

  3093. 	gmb_cam[sq][c] += BAYER(row,col);
    3094. 

  3094. 	count[c]++;
    3095. 

  3095.       }
    3096. 

  3096.     FORCC gmb_cam[sq][c] = gmb_cam[sq][c]/count[c] - black;
    3097. 

  3097.     gmb_xyz[sq][0] = gmb_xyY[sq][2] * gmb_xyY[sq][0] / gmb_xyY[sq][1];
    3098. 

  3098.     gmb_xyz[sq][1] = gmb_xyY[sq][2];
    3099. 

  3099.     gmb_xyz[sq][2] = gmb_xyY[sq][2] *
    3100. 

  3100. 		(1 - gmb_xyY[sq][0] - gmb_xyY[sq][1]) / gmb_xyY[sq][1];
    3101. 

  3101.   }
    3102. 

  3102.   pseudoinverse (gmb_xyz, inverse, NSQ);
    3103. 

  3103.   for (i=0; i < colors; i++)
    3104. 

  3104.     for (j=0; j < 3; j++)
    3105. 

  3105.       for (cam_xyz[i][j] = k=0; k < NSQ; k++)
    3106. 

  3106. 	cam_xyz[i][j] += gmb_cam[k][i] * inverse[k][j];
    3107. 

  3107.   cam_xyz_coeff (cam_xyz);
    3108. 

  3108.   if (verbose) {
    3109. 

  3109.     printf ("    { \"%s %s\", %d,\n\t{", make, model, black);
    3110. 

  3110.     num = 10000 / (cam_xyz[1][0] + cam_xyz[1][1] + cam_xyz[1][2]);
    3111. 

  3111.     FORCC for (j=0; j < 3; j++)
    3112. 

  3112.       printf ("%c%d", (c | j) ? ',':' ', (int) (cam_xyz[c][j] * num + 0.5));
    3113. 

  3113.     puts (" } },");
    3114. 

  3114.   }
    3115. 

  3115. #undef NSQ
    3116. 

  3116. }
    3117. 

  3117. #endif
    3118. 

  3118. 

  3119. void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
    3120. 

  3120. {
    3121. 

  3121.   int i;
    3122. 

  3122.   for (i=0; i < sc; i++)
    3123. 

  3123.     temp[i] = 2*base[st*i] + base[st*(sc-i)] + base[st*(i+sc)];
    3124. 

  3124.   for (; i+sc < size; i++)
    3125. 

  3125.     temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(i+sc)];
    3126. 

  3126.   for (; i < size; i++)
    3127. 

  3127.     temp[i] = 2*base[st*i] + base[st*(i-sc)] + base[st*(2*size-2-(i+sc))];
    3128. 

  3128. }
    3129. 

  3129. 

  3130. #if !defined(LIBRAW_USE_OPENMP)
    3131. 

  3131. void CLASS wavelet_denoise()
    3132. 

  3132. {
    3133. 

  3133.   float *fimg=0, *temp, thold, mul[2], avg, diff;
    3134. 

  3134.   int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
    3135. 

  3135.   ushort *window[4];
    3136. 

  3136.   static const float noise[] =
    3137. 

  3137.   { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
    3138. 

  3138. 

  3139. #ifdef DCRAW_VERBOSE
    3140. 

  3140.   if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
    3141. 

  3141. #endif
    3142. 

  3142. 

  3143.   while (maximum << scale < 0x10000) scale++;
    3144. 

  3144.   maximum <<= --scale;
    3145. 

  3145.   black <<= scale;
    3146. 

  3146.   FORC4 cblack[c] <<= scale;
    3147. 

  3147.   if ((size = iheight*iwidth) < 0x15550000)
    3148. 

  3148.     fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
    3149. 

  3149.   merror (fimg, "wavelet_denoise()");
    3150. 

  3150.   temp = fimg + size*3;
    3151. 

  3151.   if ((nc = colors) == 3 && filters) nc++;
    3152. 

  3152.   FORC(nc) {			/* denoise R,G1,B,G3 individually */
    3153. 

  3153.     for (i=0; i < size; i++)
    3154. 

  3154.       fimg[i] = 256 * sqrt((double)(image[i][c] << scale));
    3155. 

  3155.     for (hpass=lev=0; lev < 5; lev++) {
    3156. 

  3156.       lpass = size*((lev & 1)+1);
    3157. 

  3157.       for (row=0; row < iheight; row++) {
    3158. 

  3158. 	hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
    3159. 

  3159. 	for (col=0; col < iwidth; col++)
    3160. 

  3160. 	  fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
    3161. 

  3161.       }
    3162. 

  3162.       for (col=0; col < iwidth; col++) {
    3163. 

  3163. 	hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
    3164. 

  3164. 	for (row=0; row < iheight; row++)
    3165. 

  3165. 	  fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
    3166. 

  3166.       }
    3167. 

  3167.       thold = threshold * noise[lev];
    3168. 

  3168.       for (i=0; i < size; i++) {
    3169. 

  3169. 	fimg[hpass+i] -= fimg[lpass+i];
    3170. 

  3170. 	if	(fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
    3171. 

  3171. 	else if (fimg[hpass+i] >  thold) fimg[hpass+i] -= thold;
    3172. 

  3172. 	else	 fimg[hpass+i] = 0;
    3173. 

  3173. 	if (hpass) fimg[i] += fimg[hpass+i];
    3174. 

  3174.       }
    3175. 

  3175.       hpass = lpass;
    3176. 

  3176.     }
    3177. 

  3177.     for (i=0; i < size; i++)
    3178. 

  3178.       image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
    3179. 

  3179.   }
    3180. 

  3180.   if (filters && colors == 3) {  /* pull G1 and G3 closer together */
    3181. 

  3181.     for (row=0; row < 2; row++) {
    3182. 

  3182.       mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
    3183. 

  3183.       blk[row] = cblack[FC(row,0) | 1];
    3184. 

  3184.     }
    3185. 

  3185.     for (i=0; i < 4; i++)
    3186. 

  3186.       window[i] = (ushort *) fimg + width*i;
    3187. 

  3187.     for (wlast=-1, row=1; row < height-1; row++) {
    3188. 

  3188.       while (wlast < row+1) {
    3189. 

  3189. 	for (wlast++, i=0; i < 4; i++)
    3190. 

  3190. 	  window[(i+3) & 3] = window[i];
    3191. 

  3191. 	for (col = FC(wlast,1) & 1; col < width; col+=2)
    3192. 

  3192. 	  window[2][col] = BAYER(wlast,col);
    3193. 

  3193.       }
    3194. 

  3194.       thold = threshold/512;
    3195. 

  3195.       for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
    3196. 

  3196. 	avg = ( window[0][col-1] + window[0][col+1] +
    3197. 

  3197. 		window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
    3198. 

  3198. 	      * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
    3199. 

  3199. 	avg = avg < 0 ? 0 : sqrt(avg);
    3200. 

  3200. 	diff = sqrt((double)BAYER(row,col)) - avg;
    3201. 

  3201. 	if      (diff < -thold) diff += thold;
    3202. 

  3202. 	else if (diff >  thold) diff -= thold;
    3203. 

  3203. 	else diff = 0;
    3204. 

  3204. 	BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
    3205. 

  3205.       }
    3206. 

  3206.     }
    3207. 

  3207.   }
    3208. 

  3208.   free (fimg);
    3209. 

  3209. }
    3210. 

  3210. #else /* LIBRAW_USE_OPENMP */
    3211. 

  3211. void CLASS wavelet_denoise()
    3212. 

  3212. {
    3213. 

  3213.   float *fimg=0, *temp, thold, mul[2], avg, diff;
    3214. 

  3214.    int scale=1, size, lev, hpass, lpass, row, col, nc, c, i, wlast, blk[2];
    3215. 

  3215.   ushort *window[4];
    3216. 

  3216.   static const float noise[] =
    3217. 

  3217.   { 0.8002,0.2735,0.1202,0.0585,0.0291,0.0152,0.0080,0.0044 };
    3218. 

  3218. 

  3219. #ifdef DCRAW_VERBOSE
    3220. 

  3220.   if (verbose) fprintf (stderr,_("Wavelet denoising...\n"));
    3221. 

  3221. #endif
    3222. 

  3222. 

  3223.   while (maximum << scale < 0x10000) scale++;
    3224. 

  3224.   maximum <<= --scale;
    3225. 

  3225.   black <<= scale;
    3226. 

  3226.   FORC4 cblack[c] <<= scale;
    3227. 

  3227.   if ((size = iheight*iwidth) < 0x15550000)
    3228. 

  3228.     fimg = (float *) malloc ((size*3 + iheight + iwidth) * sizeof *fimg);
    3229. 

  3229.   merror (fimg, "wavelet_denoise()");
    3230. 

  3230.   temp = fimg + size*3;
    3231. 

  3231.   if ((nc = colors) == 3 && filters) nc++;
    3232. 

  3232. #ifdef LIBRAW_LIBRARY_BUILD
    3233. 

  3233. #pragma omp parallel default(shared) private(i,col,row,thold,lev,lpass,hpass,temp,c) firstprivate(scale,size) 
    3234. 

  3234. #endif
    3235. 

  3235.   {
    3236. 

  3236.       temp = (float*)malloc( (iheight + iwidth) * sizeof *fimg);
    3237. 

  3237.     FORC(nc) {			/* denoise R,G1,B,G3 individually */
    3238. 

  3238. #ifdef LIBRAW_LIBRARY_BUILD
    3239. 

  3239. #pragma omp for
    3240. 

  3240. #endif
    3241. 

  3241.       for (i=0; i < size; i++)
    3242. 

  3242.         fimg[i] = 256 * sqrt((double)(image[i][c] << scale));
    3243. 

  3243.       for (hpass=lev=0; lev < 5; lev++) {
    3244. 

  3244. 	lpass = size*((lev & 1)+1);
    3245. 

  3245. #ifdef LIBRAW_LIBRARY_BUILD
    3246. 

  3246. #pragma omp for
    3247. 

  3247. #endif
    3248. 

  3248. 	for (row=0; row < iheight; row++) {
    3249. 

  3249. 	  hat_transform (temp, fimg+hpass+row*iwidth, 1, iwidth, 1 << lev);
    3250. 

  3250. 	  for (col=0; col < iwidth; col++)
    3251. 

  3251. 	    fimg[lpass + row*iwidth + col] = temp[col] * 0.25;
    3252. 

  3252. 	}
    3253. 

  3253. #ifdef LIBRAW_LIBRARY_BUILD
    3254. 

  3254. #pragma omp for
    3255. 

  3255. #endif
    3256. 

  3256. 	for (col=0; col < iwidth; col++) {
    3257. 

  3257. 	  hat_transform (temp, fimg+lpass+col, iwidth, iheight, 1 << lev);
    3258. 

  3258. 	  for (row=0; row < iheight; row++)
    3259. 

  3259. 	    fimg[lpass + row*iwidth + col] = temp[row] * 0.25;
    3260. 

  3260. 	}
    3261. 

  3261. 	thold = threshold * noise[lev];
    3262. 

  3262. #ifdef LIBRAW_LIBRARY_BUILD
    3263. 

  3263. #pragma omp for
    3264. 

  3264. #endif
    3265. 

  3265. 	for (i=0; i < size; i++) {
    3266. 

  3266. 	  fimg[hpass+i] -= fimg[lpass+i];
    3267. 

  3267. 	  if	(fimg[hpass+i] < -thold) fimg[hpass+i] += thold;
    3268. 

  3268. 	  else if (fimg[hpass+i] >  thold) fimg[hpass+i] -= thold;
    3269. 

  3269. 	  else	 fimg[hpass+i] = 0;
    3270. 

  3270. 	  if (hpass) fimg[i] += fimg[hpass+i];
    3271. 

  3271. 	}
    3272. 

  3272. 	hpass = lpass;
    3273. 

  3273.       }
    3274. 

  3274. #ifdef LIBRAW_LIBRARY_BUILD
    3275. 

  3275. #pragma omp for
    3276. 

  3276. #endif
    3277. 

  3277.       for (i=0; i < size; i++)
    3278. 

  3278. 	image[i][c] = CLIP(SQR(fimg[i]+fimg[lpass+i])/0x10000);
    3279. 

  3279.     }
    3280. 

  3280.     free(temp);
    3281. 

  3281.   } /* end omp parallel */
    3282. 

  3282. /* the following loops are hard to parallize, no idea yes,
    3283. 

  3283.  * problem is wlast which is carrying dependency
    3284. 

  3284.  * second part should be easyer, but did not yet get it right.
    3285. 

  3285.  */
    3286. 

  3286.   if (filters && colors == 3) {  /* pull G1 and G3 closer together */
    3287. 

  3287.    for (row=0; row < 2; row++){
    3288. 

  3288.       mul[row] = 0.125 * pre_mul[FC(row+1,0) | 1] / pre_mul[FC(row,0) | 1];
    3289. 

  3289.       blk[row] = cblack[FC(row,0) | 1];
    3290. 

  3290.    }
    3291. 

  3291.     for (i=0; i < 4; i++)
    3292. 

  3292.       window[i] = (ushort *) fimg + width*i;
    3293. 

  3293.     for (wlast=-1, row=1; row < height-1; row++) {
    3294. 

  3294.       while (wlast < row+1) {
    3295. 

  3295. 	for (wlast++, i=0; i < 4; i++)
    3296. 

  3296. 	  window[(i+3) & 3] = window[i];
    3297. 

  3297. 	for (col = FC(wlast,1) & 1; col < width; col+=2)
    3298. 

  3298. 	  window[2][col] = BAYER(wlast,col);
    3299. 

  3299.       }
    3300. 

  3300.       thold = threshold/512;
    3301. 

  3301.       for (col = (FC(row,0) & 1)+1; col < width-1; col+=2) {
    3302. 

  3302. 	avg = ( window[0][col-1] + window[0][col+1] +
    3303. 

  3303. 		window[2][col-1] + window[2][col+1] - blk[~row & 1]*4 )
    3304. 

  3304. 	      * mul[row & 1] + (window[1][col] + blk[row & 1]) * 0.5;
    3305. 

  3305. 	avg = avg < 0 ? 0 : sqrt(avg);
    3306. 

  3306. 	diff = sqrt((double)BAYER(row,col)) - avg;
    3307. 

  3307. 	if      (diff < -thold) diff += thold;
    3308. 

  3308. 	else if (diff >  thold) diff -= thold;
    3309. 

  3309. 	else diff = 0;
    3310. 

  3310. 	BAYER(row,col) = CLIP(SQR(avg+diff) + 0.5);
    3311. 

  3311.       }
    3312. 

  3312.     }
    3313. 

  3313.   }
    3314. 

  3314.   free (fimg);
    3315. 

  3315. }
    3316. 

  3316. 

  3317. #endif
    3318. 

  3318. 

  3319. // green equilibration
    3320. 

  3320. void CLASS green_matching()
    3321. 

  3321. {
    3322. 

  3322.   int i,j;
    3323. 

  3323.   double m1,m2,c1,c2;
    3324. 

  3324.   int o1_1,o1_2,o1_3,o1_4;
    3325. 

  3325.   int o2_1,o2_2,o2_3,o2_4;
    3326. 

  3326.   ushort (*img)[4];
    3327. 

  3327.   const int margin = 3;
    3328. 

  3328.   int oj = 2, oi = 2;
    3329. 

  3329.   float f;
    3330. 

  3330.   const float thr = 0.01f;
    3331. 

  3331.   if(half_size || shrink) return;
    3332. 

  3332.   if(FC(oj, oi) != 3) oj++;
    3333. 

  3333.   if(FC(oj, oi) != 3) oi++;
    3334. 

  3334.   if(FC(oj, oi) != 3) oj--;
    3335. 

  3335. 

  3336.   img = (ushort (*)[4]) calloc (height*width, sizeof *image);
    3337. 

  3337.   merror (img, "green_matching()");
    3338. 

  3338.   memcpy(img,image,height*width*sizeof *image);
    3339. 

  3339. 

  3340.   for(j=oj;j<height-margin;j+=2)
    3341. 

  3341.     for(i=oi;i<width-margin;i+=2){
    3342. 

  3342.       o1_1=img[(j-1)*width+i-1][1];
    3343. 

  3343.       o1_2=img[(j-1)*width+i+1][1];
    3344. 

  3344.       o1_3=img[(j+1)*width+i-1][1];
    3345. 

  3345.       o1_4=img[(j+1)*width+i+1][1];
    3346. 

  3346.       o2_1=img[(j-2)*width+i][3];
    3347. 

  3347.       o2_2=img[(j+2)*width+i][3];
    3348. 

  3348.       o2_3=img[j*width+i-2][3];
    3349. 

  3349.       o2_4=img[j*width+i+2][3];
    3350. 

  3350. 

  3351.       m1=(o1_1+o1_2+o1_3+o1_4)/4.0;
    3352. 

  3352.       m2=(o2_1+o2_2+o2_3+o2_4)/4.0;
    3353. 

  3353. 

  3354.       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;
    3355. 

  3355.       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;
    3356. 

  3356.       if((img[j*width+i][3]<maximum*0.95)&&(c1<maximum*thr)&&(c2<maximum*thr))
    3357. 

  3357.       {
    3358. 

  3358.         f = image[j*width+i][3]*m1/m2;
    3359. 

  3359.         image[j*width+i][3]=f>0xffff?0xffff:f;
    3360. 

  3360.       }
    3361. 

  3361.     }
    3362. 

  3362.   free(img);
    3363. 

  3363. }
    3364. 

  3364. 

  3365. void CLASS scale_colors()
    3366. 

  3366. {
    3367. 

  3367.   unsigned bottom, right, size, row, col, ur, uc, i, x, y, c, sum[8];
    3368. 

  3368.   int val, dark, sat;
    3369. 

  3369.   double dsum[8], dmin, dmax;
    3370. 

  3370.   float scale_mul[4], fr, fc;
    3371. 

  3371.   ushort *img=0, *pix;
    3372. 

  3372. 

  3373. #ifdef LIBRAW_LIBRARY_BUILD
    3374. 

  3374.   RUN_CALLBACK(LIBRAW_PROGRESS_SCALE_COLORS,0,2);
    3375. 

  3375. #endif
    3376. 

  3376. 

  3377.   if (user_mul[0])
    3378. 

  3378.     memcpy (pre_mul, user_mul, sizeof pre_mul);
    3379. 

  3379.   if (use_auto_wb || (use_camera_wb && cam_mul[0] == -1)) {
    3380. 

  3380.     memset (dsum, 0, sizeof dsum);
    3381. 

  3381.     bottom = MIN (greybox[1]+greybox[3], height);
    3382. 

  3382.     right  = MIN (greybox[0]+greybox[2], width);
    3383. 

  3383.     for (row=greybox[1]; row < bottom; row += 8)
    3384. 

  3384.       for (col=greybox[0]; col < right; col += 8) {
    3385. 

  3385. 	memset (sum, 0, sizeof sum);
    3386. 

  3386. 	for (y=row; y < row+8 && y < bottom; y++)
    3387. 

  3387. 	  for (x=col; x < col+8 && x < right; x++)
    3388. 

  3388. 	    FORC4 {
    3389. 

  3389. 	      if (filters) {
    3390. 

  3390. 		c = fcol(y,x);
    3391. 

  3391. 		val = BAYER2(y,x);
    3392. 

  3392. 	      } else
    3393. 

  3393. 		val = image[y*width+x][c];
    3394. 

  3394. 	      if (val > maximum-25) goto skip_block;
    3395. 

  3395. 	      if ((val -= cblack[c]) < 0) val = 0;
    3396. 

  3396. 	      sum[c] += val;
    3397. 

  3397. 	      sum[c+4]++;
    3398. 

  3398. 	      if (filters) break;
    3399. 

  3399. 	    }
    3400. 

  3400. 	FORC(8) dsum[c] += sum[c];
    3401. 

  3401. skip_block: ;
    3402. 

  3402.       }
    3403. 

  3403.     FORC4 if (dsum[c]) pre_mul[c] = dsum[c+4] / dsum[c];
    3404. 

  3404.   }
    3405. 

  3405.   if (use_camera_wb && cam_mul[0] != -1) {
    3406. 

  3406.     memset (sum, 0, sizeof sum);
    3407. 

  3407.     for (row=0; row < 8; row++)
    3408. 

  3408.       for (col=0; col < 8; col++) {
    3409. 

  3409. 	c = FC(row,col);
    3410. 

  3410. 	if ((val = white[row][col] - cblack[c]) > 0)
    3411. 

  3411. 	  sum[c] += val;
    3412. 

  3412. 	sum[c+4]++;
    3413. 

  3413.       }
    3414. 

  3414.     if (sum[0] && sum[1] && sum[2] && sum[3])
    3415. 

  3415.       FORC4 pre_mul[c] = (float) sum[c+4] / sum[c];
    3416. 

  3416.     else if (cam_mul[0] && cam_mul[2])
    3417. 

  3417.       memcpy (pre_mul, cam_mul, sizeof pre_mul);
    3418. 

  3418.     else
    3419. 

  3419.       {
    3420. 

  3420. #ifdef LIBRAW_LIBRARY_BUILD
    3421. 

  3421.             imgdata.process_warnings |= LIBRAW_WARN_BAD_CAMERA_WB;
    3422. 

  3422. #endif
    3423. 

  3423. #ifdef DCRAW_VERBOSE
    3424. 

  3424.             fprintf (stderr,_("%s: Cannot use camera white balance.\n"), ifname);
    3425. 

  3425. #endif
    3426. 

  3426.       }
    3427. 

  3427.   }
    3428. 

  3428.   if (pre_mul[3] == 0) pre_mul[3] = colors < 4 ? pre_mul[1] : 1;
    3429. 

  3429.   dark = black;
    3430. 

  3430.   sat = maximum;
    3431. 

  3431.   if (threshold) wavelet_denoise();
    3432. 

  3432.   maximum -= black;
    3433. 

  3433.   for (dmin=DBL_MAX, dmax=c=0; c < 4; c++) {
    3434. 

  3434.     if (dmin > pre_mul[c])
    3435. 

  3435. 	dmin = pre_mul[c];
    3436. 

  3436.     if (dmax < pre_mul[c])
    3437. 

  3437. 	dmax = pre_mul[c];
    3438. 

  3438.   }
    3439. 

  3439.   if (!highlight) dmax = dmin;
    3440. 

  3440.   FORC4 scale_mul[c] = (pre_mul[c] /= dmax) * 65535.0 / maximum;
    3441. 

  3441. #ifdef DCRAW_VERBOSE
    3442. 

  3442.   if (verbose) {
    3443. 

  3443.     fprintf (stderr,
    3444. 

  3444.       _("Scaling with darkness %d, saturation %d, and\nmultipliers"), dark, sat);
    3445. 

  3445.     FORC4 fprintf (stderr, " %f", pre_mul[c]);
    3446. 

  3446.     fputc ('\n', stderr);
    3447. 

  3447.   }
    3448. 

  3448. #endif
    3449. 

  3449.   size = iheight*iwidth;
    3450. 

  3450. #ifdef LIBRAW_LIBRARY_BUILD
    3451. 

  3451.   scale_colors_loop(scale_mul);
    3452. 

  3452. #else
    3453. 

  3453.   for (i=0; i < size*4; i++) {
    3454. 

  3454.     val = image[0][i];
    3455. 

  3455.     if (!val) continue;
    3456. 

  3456.     val -= cblack[i & 3];
    3457. 

  3457.     val *= scale_mul[i & 3];
    3458. 

  3458.     image[0][i] = CLIP(val);
    3459. 

  3459.   }
    3460. 

  3460. #endif
    3461. 

  3461.   if ((aber[0] != 1 || aber[2] != 1) && colors == 3) {
    3462. 

  3462. #ifdef DCRAW_VERBOSE
    3463. 

  3463.     if (verbose)
    3464. 

  3464.       fprintf (stderr,_("Correcting chromatic aberration...\n"));
    3465. 

  3465. #endif
    3466. 

  3466.     for (c=0; c < 4; c+=2) {
    3467. 

  3467.       if (aber[c] == 1) continue;
    3468. 

  3468.       img = (ushort *) malloc (size * sizeof *img);
    3469. 

  3469.       merror (img, "scale_colors()");
    3470. 

  3470.       for (i=0; i < size; i++)
    3471. 

  3471. 	img[i] = image[i][c];
    3472. 

  3472.       for (row=0; row < iheight; row++) {
    3473. 

  3473. 	ur = fr = (row - iheight*0.5) * aber[c] + iheight*0.5;
    3474. 

  3474. 	if (ur > iheight-2) continue;
    3475. 

  3475. 	fr -= ur;
    3476. 

  3476. 	for (col=0; col < iwidth; col++) {
    3477. 

  3477. 	  uc = fc = (col - iwidth*0.5) * aber[c] + iwidth*0.5;
    3478. 

  3478. 	  if (uc > iwidth-2) continue;
    3479. 

  3479. 	  fc -= uc;
    3480. 

  3480. 	  pix = img + ur*iwidth + uc;
    3481. 

  3481. 	  image[row*iwidth+col][c] =
    3482. 

  3482. 	    (pix[     0]*(1-fc) + pix[       1]*fc) * (1-fr) +
    3483. 

  3483. 	    (pix[iwidth]*(1-fc) + pix[iwidth+1]*fc) * fr;
    3484. 

  3484. 	}
    3485. 

  3485.       }
    3486. 

  3486.       free(img);
    3487. 

  3487.     }
    3488. 

  3488.   }
    3489. 

  3489. #ifdef LIBRAW_LIBRARY_BUILD
    3490. 

  3490.   RUN_CALLBACK(LIBRAW_PROGRESS_SCALE_COLORS,1,2);
    3491. 

  3491. #endif
    3492. 

  3492. }
    3493. 

  3493. 

  3494. void CLASS pre_interpolate()
    3495. 

  3495. {
    3496. 

  3496.   ushort (*img)[4];
    3497. 

  3497.   int row, col, c;
    3498. 

  3498. #ifdef LIBRAW_LIBRARY_BUILD
    3499. 

  3499.   RUN_CALLBACK(LIBRAW_PROGRESS_PRE_INTERPOLATE,0,2);
    3500. 

  3500. #endif
    3501. 

  3501.   if (shrink) {
    3502. 

  3502.     if (half_size) {
    3503. 

  3503.       height = iheight;
    3504. 

  3504.       width  = iwidth;
    3505. 

  3505.     } else {
    3506. 

  3506.       img = (ushort (*)[4]) calloc (height*width, sizeof *img);
    3507. 

  3507.       merror (img, "pre_interpolate()");
    3508. 

  3508.       for (row=0; row < height; row++)
    3509. 

  3509. 	for (col=0; col < width; col++) {
    3510. 

  3510. 	  c = fcol(row,col);
    3511. 

  3511. 	  img[row*width+col][c] = image[(row >> 1)*iwidth+(col >> 1)][c];
    3512. 

  3512. 	}
    3513. 

  3513.       free (image);
    3514. 

  3514.       image = img;
    3515. 

  3515.       shrink = 0;
    3516. 

  3516.     }
    3517. 

  3517.   }
    3518. 

  3518.   if (filters > 1000 && colors == 3) {
    3519. 

  3519.     if (four_color_rgb && colors++)
    3520. 

  3520.       mix_green = !half_size;
    3521. 

  3521.     else {
    3522. 

  3522.       for (row = FC(1,0) >> 1; row < height; row+=2)
    3523. 

  3523. 	for (col = FC(row,1) & 1; col < width; col+=2)
    3524. 

  3524. 	  image[row*width+col][1] = image[row*width+col][3];
    3525. 

  3525.       filters &= ~((filters & 0x55555555) << 1);
    3526. 

  3526.     }
    3527. 

  3527.   }
    3528. 

  3528.   if (half_size) filters = 0;
    3529. 

  3529. #ifdef LIBRAW_LIBRARY_BUILD
    3530. 

  3530.   RUN_CALLBACK(LIBRAW_PROGRESS_PRE_INTERPOLATE,1,2);
    3531. 

  3531. #endif
    3532. 

  3532. }
    3533. 

  3533. 

  3534. void CLASS border_interpolate (int border)
    3535. 

  3535. {
    3536. 

  3536.   unsigned row, col, y, x, f, c, sum[8];
    3537. 

  3537. 

  3538.   for (row=0; row < height; row++)
    3539. 

  3539.     for (col=0; col < width; col++) {
    3540. 

  3540.       if (col==border && row >= border && row < height-border)
    3541. 

  3541. 	col = width-border;
    3542. 

  3542.       memset (sum, 0, sizeof sum);
    3543. 

  3543.       for (y=row-1; y != row+2; y++)
    3544. 

  3544. 	for (x=col-1; x != col+2; x++)
    3545. 

  3545. 	  if (y < height && x < width) {
    3546. 

  3546. 	    f = fcol(y,x);
    3547. 

  3547. 	    sum[f] += image[y*width+x][f];
    3548. 

  3548. 	    sum[f+4]++;
    3549. 

  3549. 	  }
    3550. 

  3550.       f = fcol(row,col);
    3551. 

  3551.       FORCC if (c != f && sum[c+4])
    3552. 

  3552. 	image[row*width+col][c] = sum[c] / sum[c+4];
    3553. 

  3553.     }
    3554. 

  3554. }
    3555. 

  3555. 

  3556. void CLASS lin_interpolate_loop(int code[16][16][32],int size)
    3557. 

  3557. {
    3558. 

  3558.   int row;
    3559. 

  3559.   for (row=1; row < height-1; row++)
    3560. 

  3560.     {
    3561. 

  3561.       int col,*ip;
    3562. 

  3562.       ushort *pix;
    3563. 

  3563.       for (col=1; col < width-1; col++) {
    3564. 

  3564.         int i;
    3565. 

  3565.         int sum[4];
    3566. 

  3566.         pix = image[row*width+col];
    3567. 

  3567.         ip = code[row % size][col % size];
    3568. 

  3568.         memset (sum, 0, sizeof sum);
    3569. 

  3569.         for (i=*ip++; i--; ip+=3)
    3570. 

  3570.           sum[ip[2]] += pix[ip[0]] << ip[1];
    3571. 

  3571.         for (i=colors; --i; ip+=2)
    3572. 

  3572.           pix[ip[0]] = sum[ip[0]] * ip[1] >> 8;
    3573. 

  3573.       }
    3574. 

  3574.     }
    3575. 

  3575. }
    3576. 

  3576. 

  3577. void CLASS lin_interpolate()
    3578. 

  3578. {
    3579. 

  3579.   int code[16][16][32], size=16, *ip, sum[4];
    3580. 

  3580.   int f, c, x, y, row, col, shift, color;
    3581. 

  3581. 

  3582. 

  3583. #ifdef DCRAW_VERBOSE
    3584. 

  3584.   if (verbose) fprintf (stderr,_("Bilinear interpolation...\n"));
    3585. 

  3585. #endif
    3586. 

  3586. #ifdef LIBRAW_LIBRARY_BUILD
    3587. 

  3587.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,0,3);
    3588. 

  3588. #endif
    3589. 

  3589. 

  3590.   if (filters == 2) size = 6;
    3591. 

  3591.   border_interpolate(1);
    3592. 

  3592.   for (row=0; row < size; row++)
    3593. 

  3593.     for (col=0; col < size; col++) {
    3594. 

  3594.       ip = code[row][col]+1;
    3595. 

  3595.       f = fcol(row,col);
    3596. 

  3596.       memset (sum, 0, sizeof sum);
    3597. 

  3597.       for (y=-1; y <= 1; y++)
    3598. 

  3598. 	for (x=-1; x <= 1; x++) {
    3599. 

  3599. 	  shift = (y==0) + (x==0);
    3600. 

  3600. 	  color = fcol(row+y,col+x);
    3601. 

  3601. 	  if (color == f) continue;
    3602. 

  3602. 	  *ip++ = (width*y + x)*4 + color;
    3603. 

  3603. 	  *ip++ = shift;
    3604. 

  3604. 	  *ip++ = color;
    3605. 

  3605. 	  sum[color] += 1 << shift;
    3606. 

  3606. 	}
    3607. 

  3607.       code[row][col][0] = (ip - code[row][col]) / 3;
    3608. 

  3608.       FORCC
    3609. 

  3609. 	if (c != f) {
    3610. 

  3610. 	  *ip++ = c;
    3611. 

  3611. 	  *ip++ = 256 / sum[c];
    3612. 

  3612. 	}
    3613. 

  3613.     }
    3614. 

  3614. #ifdef LIBRAW_LIBRARY_BUILD
    3615. 

  3615.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,1,3);
    3616. 

  3616. #endif
    3617. 

  3617.   lin_interpolate_loop(code,size);
    3618. 

  3618. #ifdef LIBRAW_LIBRARY_BUILD
    3619. 

  3619.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,2,3);
    3620. 

  3620. #endif
    3621. 

  3621. }
    3622. 

  3622. 

  3623. /*
    3624. 

  3624.    This algorithm is officially called:
    3625. 

    3626. 

  3626.    "Interpolation using a Threshold-based variable number of gradients"
    3627. 

    3628. 

  3628.    described in http://scien.stanford.edu/pages/labsite/1999/psych221/projects/99/tingchen/algodep/vargra.html
    3629. 

    3630. 

  3630.    I've extended the basic idea to work with non-Bayer filter arrays.
    3631. 

  3631.    Gradients are numbered clockwise from NW=0 to W=7.
    3632. 

  3632.  */
    3633. 

  3633. void CLASS vng_interpolate()
    3634. 

  3634. {
    3635. 

  3635.   static const signed char *cp, terms[] = {
    3636. 

  3636.     -2,-2,+0,-1,0,0x01, -2,-2,+0,+0,1,0x01, -2,-1,-1,+0,0,0x01,
    3637. 

  3637.     -2,-1,+0,-1,0,0x02, -2,-1,+0,+0,0,0x03, -2,-1,+0,+1,1,0x01,
    3638. 

  3638.     -2,+0,+0,-1,0,0x06, -2,+0,+0,+0,1,0x02, -2,+0,+0,+1,0,0x03,
    3639. 

  3639.     -2,+1,-1,+0,0,0x04, -2,+1,+0,-1,1,0x04, -2,+1,+0,+0,0,0x06,
    3640. 

  3640.     -2,+1,+0,+1,0,0x02, -2,+2,+0,+0,1,0x04, -2,+2,+0,+1,0,0x04,
    3641. 

  3641.     -1,-2,-1,+0,0,0x80, -1,-2,+0,-1,0,0x01, -1,-2,+1,-1,0,0x01,
    3642. 

  3642.     -1,-2,+1,+0,1,0x01, -1,-1,-1,+1,0,0x88, -1,-1,+1,-2,0,0x40,
    3643. 

  3643.     -1,-1,+1,-1,0,0x22, -1,-1,+1,+0,0,0x33, -1,-1,+1,+1,1,0x11,
    3644. 

  3644.     -1,+0,-1,+2,0,0x08, -1,+0,+0,-1,0,0x44, -1,+0,+0,+1,0,0x11,
    3645. 

  3645.     -1,+0,+1,-2,1,0x40, -1,+0,+1,-1,0,0x66, -1,+0,+1,+0,1,0x22,
    3646. 

  3646.     -1,+0,+1,+1,0,0x33, -1,+0,+1,+2,1,0x10, -1,+1,+1,-1,1,0x44,
    3647. 

  3647.     -1,+1,+1,+0,0,0x66, -1,+1,+1,+1,0,0x22, -1,+1,+1,+2,0,0x10,
    3648. 

  3648.     -1,+2,+0,+1,0,0x04, -1,+2,+1,+0,1,0x04, -1,+2,+1,+1,0,0x04,
    3649. 

  3649.     +0,-2,+0,+0,1,0x80, +0,-1,+0,+1,1,0x88, +0,-1,+1,-2,0,0x40,
    3650. 

  3650.     +0,-1,+1,+0,0,0x11, +0,-1,+2,-2,0,0x40, +0,-1,+2,-1,0,0x20,
    3651. 

  3651.     +0,-1,+2,+0,0,0x30, +0,-1,+2,+1,1,0x10, +0,+0,+0,+2,1,0x08,
    3652. 

  3652.     +0,+0,+2,-2,1,0x40, +0,+0,+2,-1,0,0x60, +0,+0,+2,+0,1,0x20,
    3653. 

  3653.     +0,+0,+2,+1,0,0x30, +0,+0,+2,+2,1,0x10, +0,+1,+1,+0,0,0x44,
    3654. 

  3654.     +0,+1,+1,+2,0,0x10, +0,+1,+2,-1,1,0x40, +0,+1,+2,+0,0,0x60,
    3655. 

  3655.     +0,+1,+2,+1,0,0x20, +0,+1,+2,+2,0,0x10, +1,-2,+1,+0,0,0x80,
    3656. 

  3656.     +1,-1,+1,+1,0,0x88, +1,+0,+1,+2,0,0x08, +1,+0,+2,-1,0,0x40,
    3657. 

  3657.     +1,+0,+2,+1,0,0x10
    3658. 

  3658.   }, chood[] = { -1,-1, -1,0, -1,+1, 0,+1, +1,+1, +1,0, +1,-1, 0,-1 };
    3659. 

  3659.   ushort (*brow[5])[4], *pix;
    3660. 

  3660.   int prow=8, pcol=2, *ip, *code[16][16], gval[8], gmin, gmax, sum[4];
    3661. 

  3661.   int row, col, x, y, x1, x2, y1, y2, t, weight, grads, color, diag;
    3662. 

  3662.   int g, diff, thold, num, c;
    3663. 

  3663. 

  3664.   lin_interpolate();
    3665. 

  3665. #ifdef DCRAW_VERBOSE
    3666. 

  3666.   if (verbose) fprintf (stderr,_("VNG interpolation...\n"));
    3667. 

  3667. #endif
    3668. 

  3668. 

  3669.   if (filters == 1) prow = pcol = 16;
    3670. 

  3670.   if (filters == 2) prow = pcol =  6;
    3671. 

  3671.   ip = (int *) calloc (prow*pcol, 1280);
    3672. 

  3672.   merror (ip, "vng_interpolate()");
    3673. 

  3673.   for (row=0; row < prow; row++)		/* Precalculate for VNG */
    3674. 

  3674.     for (col=0; col < pcol; col++) {
    3675. 

  3675.       code[row][col] = ip;
    3676. 

  3676.       for (cp=terms, t=0; t < 64; t++) {
    3677. 

  3677. 	y1 = *cp++;  x1 = *cp++;
    3678. 

  3678. 	y2 = *cp++;  x2 = *cp++;
    3679. 

  3679. 	weight = *cp++;
    3680. 

  3680. 	grads = *cp++;
    3681. 

  3681. 	color = fcol(row+y1,col+x1);
    3682. 

  3682. 	if (fcol(row+y2,col+x2) != color) continue;
    3683. 

  3683. 	diag = (fcol(row,col+1) == color && fcol(row+1,col) == color) ? 2:1;
    3684. 

  3684. 	if (abs(y1-y2) == diag && abs(x1-x2) == diag) continue;
    3685. 

  3685. 	*ip++ = (y1*width + x1)*4 + color;
    3686. 

  3686. 	*ip++ = (y2*width + x2)*4 + color;
    3687. 

  3687. 	*ip++ = weight;
    3688. 

  3688. 	for (g=0; g < 8; g++)
    3689. 

  3689. 	  if (grads & 1<<g) *ip++ = g;
    3690. 

  3690. 	*ip++ = -1;
    3691. 

  3691.       }
    3692. 

  3692.       *ip++ = INT_MAX;
    3693. 

  3693.       for (cp=chood, g=0; g < 8; g++) {
    3694. 

  3694. 	y = *cp++;  x = *cp++;
    3695. 

  3695. 	*ip++ = (y*width + x) * 4;
    3696. 

  3696. 	color = fcol(row,col);
    3697. 

  3697. 	if (fcol(row+y,col+x) != color && fcol(row+y*2,col+x*2) == color)
    3698. 

  3698. 	  *ip++ = (y*width + x) * 8 + color;
    3699. 

  3699. 	else
    3700. 

  3700. 	  *ip++ = 0;
    3701. 

  3701.       }
    3702. 

  3702.     }
    3703. 

  3703.   brow[4] = (ushort (*)[4]) calloc (width*3, sizeof **brow);
    3704. 

  3704.   merror (brow[4], "vng_interpolate()");
    3705. 

  3705.   for (row=0; row < 3; row++)
    3706. 

  3706.     brow[row] = brow[4] + row*width;
    3707. 

  3707.   for (row=2; row < height-2; row++) {		/* Do VNG interpolation */
    3708. 

  3708. #ifdef LIBRAW_LIBRARY_BUILD
    3709. 

  3709.       if(!((row-2)%256))RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,(row-2)/256+1,((height-3)/256)+1);
    3710. 

  3710. #endif
    3711. 

  3711.     for (col=2; col < width-2; col++) {
    3712. 

  3712.       pix = image[row*width+col];
    3713. 

  3713.       ip = code[row % prow][col % pcol];
    3714. 

  3714.       memset (gval, 0, sizeof gval);
    3715. 

  3715.       while ((g = ip[0]) != INT_MAX) {		/* Calculate gradients */
    3716. 

  3716. 	diff = ABS(pix[g] - pix[ip[1]]) << ip[2];
    3717. 

  3717. 	gval[ip[3]] += diff;
    3718. 

  3718. 	ip += 5;
    3719. 

  3719. 	if ((g = ip[-1]) == -1) continue;
    3720. 

  3720. 	gval[g] += diff;
    3721. 

  3721. 	while ((g = *ip++) != -1)
    3722. 

  3722. 	  gval[g] += diff;
    3723. 

  3723.       }
    3724. 

  3724.       ip++;
    3725. 

  3725.       gmin = gmax = gval[0];			/* Choose a threshold */
    3726. 

  3726.       for (g=1; g < 8; g++) {
    3727. 

  3727. 	if (gmin > gval[g]) gmin = gval[g];
    3728. 

  3728. 	if (gmax < gval[g]) gmax = gval[g];
    3729. 

  3729.       }
    3730. 

  3730.       if (gmax == 0) {
    3731. 

  3731. 	memcpy (brow[2][col], pix, sizeof *image);
    3732. 

  3732. 	continue;
    3733. 

  3733.       }
    3734. 

  3734.       thold = gmin + (gmax >> 1);
    3735. 

  3735.       memset (sum, 0, sizeof sum);
    3736. 

  3736.       color = fcol(row,col);
    3737. 

  3737.       for (num=g=0; g < 8; g++,ip+=2) {		/* Average the neighbors */
    3738. 

  3738. 	if (gval[g] <= thold) {
    3739. 

  3739. 	  FORCC
    3740. 

  3740. 	    if (c == color && ip[1])
    3741. 

  3741. 	      sum[c] += (pix[c] + pix[ip[1]]) >> 1;
    3742. 

  3742. 	    else
    3743. 

  3743. 	      sum[c] += pix[ip[0] + c];
    3744. 

  3744. 	  num++;
    3745. 

  3745. 	}
    3746. 

  3746.       }
    3747. 

  3747.       FORCC {					/* Save to buffer */
    3748. 

  3748. 	t = pix[color];
    3749. 

  3749. 	if (c != color)
    3750. 

  3750. 	  t += (sum[c] - sum[color]) / num;
    3751. 

  3751. 	brow[2][col][c] = CLIP(t);
    3752. 

  3752.       }
    3753. 

  3753.     }
    3754. 

  3754.     if (row > 3)				/* Write buffer to image */
    3755. 

  3755.       memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image);
    3756. 

  3756.     for (g=0; g < 4; g++)
    3757. 

  3757.       brow[(g-1) & 3] = brow[g];
    3758. 

  3758.   }
    3759. 

  3759.   memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image);
    3760. 

  3760.   memcpy (image[(row-1)*width+2], brow[1]+2, (width-4)*sizeof *image);
    3761. 

  3761.   free (brow[4]);
    3762. 

  3762.   free (code[0][0]);
    3763. 

  3763. }
    3764. 

  3764. 

  3765. /*
    3766. 

  3766.    Patterned Pixel Grouping Interpolation by Alain Desbiolles
    3767. 

  3767. */
    3768. 

  3768. void CLASS ppg_interpolate()
    3769. 

  3769. {
    3770. 

  3770.   int dir[5] = { 1, width, -1, -width, 1 };
    3771. 

  3771.   int row, col, diff[2], guess[2], c, d, i;
    3772. 

  3772.   ushort (*pix)[4];
    3773. 

  3773. 

  3774.   border_interpolate(3);
    3775. 

  3775. #ifdef DCRAW_VERBOSE
    3776. 

  3776.   if (verbose) fprintf (stderr,_("PPG interpolation...\n"));
    3777. 

  3777. #endif
    3778. 

  3778. 

  3779. /*  Fill in the green layer with gradients and pattern recognition: */
    3780. 

  3780. #ifdef LIBRAW_LIBRARY_BUILD
    3781. 

  3781.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,0,3);
    3782. 

  3782. #ifdef LIBRAW_USE_OPENMP
    3783. 

  3783. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    3784. 

  3784. #endif
    3785. 

  3785. #endif
    3786. 

  3786.   for (row=3; row < height-3; row++)
    3787. 

  3787.     for (col=3+(FC(row,3) & 1), c=FC(row,col); col < width-3; col+=2) {
    3788. 

  3788.       pix = image + row*width+col;
    3789. 

  3789.       for (i=0; (d=dir[i]) > 0; i++) {
    3790. 

  3790. 	guess[i] = (pix[-d][1] + pix[0][c] + pix[d][1]) * 2
    3791. 

  3791. 		      - pix[-2*d][c] - pix[2*d][c];
    3792. 

  3792. 	diff[i] = ( ABS(pix[-2*d][c] - pix[ 0][c]) +
    3793. 

  3793. 		    ABS(pix[ 2*d][c] - pix[ 0][c]) +
    3794. 

  3794. 		    ABS(pix[  -d][1] - pix[ d][1]) ) * 3 +
    3795. 

  3795. 		  ( ABS(pix[ 3*d][1] - pix[ d][1]) +
    3796. 

  3796. 		    ABS(pix[-3*d][1] - pix[-d][1]) ) * 2;
    3797. 

  3797.       }
    3798. 

  3798.       d = dir[i = diff[0] > diff[1]];
    3799. 

  3799.       pix[0][1] = ULIM(guess[i] >> 2, pix[d][1], pix[-d][1]);
    3800. 

  3800.     }
    3801. 

  3801. /*  Calculate red and blue for each green pixel:		*/
    3802. 

  3802. #ifdef LIBRAW_LIBRARY_BUILD
    3803. 

  3803.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,1,3);
    3804. 

  3804. #ifdef LIBRAW_USE_OPENMP
    3805. 

  3805. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    3806. 

  3806. #endif
    3807. 

  3807. #endif
    3808. 

  3808.   for (row=1; row < height-1; row++)
    3809. 

  3809.     for (col=1+(FC(row,2) & 1), c=FC(row,col+1); col < width-1; col+=2) {
    3810. 

  3810.       pix = image + row*width+col;
    3811. 

  3811.       for (i=0; (d=dir[i]) > 0; c=2-c, i++)
    3812. 

  3812. 	pix[0][c] = CLIP((pix[-d][c] + pix[d][c] + 2*pix[0][1]
    3813. 

  3813. 			- pix[-d][1] - pix[d][1]) >> 1);
    3814. 

  3814.     }
    3815. 

  3815. /*  Calculate blue for red pixels and vice versa:		*/
    3816. 

  3816. #ifdef LIBRAW_LIBRARY_BUILD
    3817. 

  3817.   RUN_CALLBACK(LIBRAW_PROGRESS_INTERPOLATE,2,3);
    3818. 

  3818. #ifdef LIBRAW_USE_OPENMP
    3819. 

  3819. #pragma omp parallel for default(shared) private(guess, diff, row, col, d, c, i, pix) schedule(static)
    3820. 

  3820. #endif
    3821. 

  3821. #endif
    3822. 

  3822.   for (row=1; row < height-1; row++)
    3823. 

  3823.     for (col=1+(FC(row,1) & 1), c=2-FC(row,col); col < width-1; col+=2) {
    3824. 

  3824.       pix = image + row*width+col;
    3825. 

  3825.       for (i=0; (d=dir[i]+dir[i+1]) > 0; i++) {
    3826. 

  3826. 	diff[i] = ABS(pix[-d][c] - pix[d][c]) +
    3827. 

  3827. 		  ABS(pix[-d][1] - pix[0][1]) +
    3828. 

  3828. 		  ABS(pix[ d][1] - pix[0][1]);
    3829. 

  3829. 	guess[i] = pix[-d][c] + pix[d][c] + 2*pix[0][1]
    3830. 

  3830. 		 - pix[-d][1] - pix[d][1];
    3831. 

  3831.       }
    3832. 

  3832.       if (diff[0] != diff[1])
    3833. 

  3833. 	pix[0][c] = CLIP(guess[diff[0] > diff[1]] >> 1);
    3834. 

  3834.       else
    3835. 

  3835. 	pix[0][c] = CLIP((guess[0]+guess[1]) >> 2);
    3836. 

  3836.     }
    3837. 

  3837. }
    3838. 

  3838. 

  3839. #ifdef LIBRAW_LIBRARY_BUILD
    3840. 

  3840. /*
    3841. 

  3841.    Adaptive Homogeneity-Directed interpolation is based on
    3842. 

  3842.    the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
    3843. 

  3843.  */
    3844. 

  3844. #define TS 256		/* Tile Size */
    3845. 

  3845. static float dcraw_cbrt[0x10000] = {-1.0f};
    3846. 

  3846. 

  3847. static inline float calc_64cbrt(float f)
    3848. 

  3848. {
    3849. 

  3849.   unsigned u;
    3850. 

  3850.   static float lower = dcraw_cbrt[0];
    3851. 

  3851.   static float upper = dcraw_cbrt[0xffff];
    3852. 

  3852. 

  3853.   if (f <= 0) {
    3854. 

  3854.     return lower;
    3855. 

  3855.   }
    3856. 

  3856. 

  3857.   u = (unsigned) f;
    3858. 

  3858.   if (u >= 0xffff) {
    3859. 

  3859.     return upper;
    3860. 

  3860.   }
    3861. 

  3861.   return dcraw_cbrt[u];
    3862. 

  3862. }
    3863. 

  3863. void CLASS ahd_interpolate_green_h_and_v(int top, int left, ushort (*out_rgb)[TS][TS][3])
    3864. 

  3864. {
    3865. 

  3865.   int row, col;
    3866. 

  3866.   int c, val;
    3867. 

  3867.   ushort (*pix)[4];
    3868. 

  3868.   const int rowlimit = MIN(top+TS, height-2);
    3869. 

  3869.   const int collimit = MIN(left+TS, width-2);
    3870. 

  3870. 

  3871.   for (row = top; row < rowlimit; row++) {
    3872. 

  3872.     col = left + (FC(row,left) & 1);
    3873. 

  3873.     for (c = FC(row,col); col < collimit; col+=2) {
    3874. 

  3874.       pix = image + row*width+col;
    3875. 

  3875.       val = ((pix[-1][1] + pix[0][c] + pix[1][1]) * 2
    3876. 

  3876.             - pix[-2][c] - pix[2][c]) >> 2;
    3877. 

  3877.       out_rgb[0][row-top][col-left][1] = ULIM(val,pix[-1][1],pix[1][1]);
    3878. 

  3878.       val = ((pix[-width][1] + pix[0][c] + pix[width][1]) * 2
    3879. 

  3879.             - pix[-2*width][c] - pix[2*width][c]) >> 2;
    3880. 

  3880.       out_rgb[1][row-top][col-left][1] = ULIM(val,pix[-width][1],pix[width][1]);
    3881. 

  3881.     }
    3882. 

  3882.   }
    3883. 

  3883. }
    3884. 

  3884. 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])
    3885. 

  3885. {
    3886. 

  3886.   unsigned row, col;
    3887. 

  3887.   int c, val;
    3888. 

  3888.   ushort (*pix)[4];
    3889. 

  3889.   ushort (*rix)[3];
    3890. 

  3890.   short (*lix)[3];
    3891. 

  3891.   float xyz[3];
    3892. 

  3892.   const unsigned num_pix_per_row = 4*width;
    3893. 

  3893.   const unsigned rowlimit = MIN(top+TS-1, height-3);
    3894. 

  3894.   const unsigned collimit = MIN(left+TS-1, width-3);
    3895. 

  3895.   ushort *pix_above;
    3896. 

  3896.   ushort *pix_below;
    3897. 

  3897.   int t1, t2;
    3898. 

  3898. 

  3899.   for (row = top+1; row < rowlimit; row++) {
    3900. 

  3900.     pix = image + row*width + left;
    3901. 

  3901.     rix = &inout_rgb[row-top][0];
    3902. 

  3902.     lix = &out_lab[row-top][0];
    3903. 

  3903. 

  3904.     for (col = left+1; col < collimit; col++) {
    3905. 

  3905.       pix++;
    3906. 

  3906.       pix_above = &pix[0][0] - num_pix_per_row;
    3907. 

  3907.       pix_below = &pix[0][0] + num_pix_per_row;
    3908. 

  3908.       rix++;
    3909. 

  3909.       lix++;
    3910. 

  3910. 

  3911.       c = 2 - FC(row, col);
    3912. 

  3912. 

  3913.       if (c == 1) {
    3914. 

  3914.         c = FC(row+1,col);
    3915. 

  3915. 	t1 = 2-c;
    3916. 

  3916.         val = pix[0][1] + (( pix[-1][t1] + pix[1][t1]
    3917. 

  3917.               - rix[-1][1] - rix[1][1] ) >> 1);
    3918. 

  3918.         rix[0][t1] = CLIP(val);
    3919. 

  3919.         val = pix[0][1] + (( pix_above[c] + pix_below[c]
    3920. 

  3920.               - rix[-TS][1] - rix[TS][1] ) >> 1);
    3921. 

  3921.       } else {
    3922. 

  3922. 	t1 = -4+c; /* -4+c: pixel of color c to the left */
    3923. 

  3923. 	t2 = 4+c; /* 4+c: pixel of color c to the right */
    3924. 

  3924.         val = rix[0][1] + (( pix_above[t1] + pix_above[t2]
    3925. 

  3925.               + pix_below[t1] + pix_below[t2]
    3926. 

  3926.               - rix[-TS-1][1] - rix[-TS+1][1]
    3927. 

  3927.               - rix[+TS-1][1] - rix[+TS+1][1] + 1) >> 2);
    3928. 

  3928.       }
    3929. 

  3929.       rix[0][c] = CLIP(val);
    3930. 

  3930.       c = FC(row,col);
    3931. 

  3931.       rix[0][c] = pix[0][c];
    3932. 

  3932.       xyz[0] = xyz[1] = xyz[2] = 0.5;
    3933. 

  3933.       FORC3 {
    3934. 

  3934. 	/*
    3935. 

  3935. 	 * Technically this ought to be FORCC, but the rest of
    3936. 

  3936. 	 * ahd_interpolate() assumes 3 colors so let's help the compiler.
    3937. 

  3937. 	 */
    3938. 

  3938.         xyz[0] += xyz_cam[0][c] * rix[0][c];
    3939. 

  3939.         xyz[1] += xyz_cam[1][c] * rix[0][c];
    3940. 

  3940.         xyz[2] += xyz_cam[2][c] * rix[0][c];
    3941. 

  3941.       }
    3942. 

  3942.       FORC3 {
    3943. 

  3943. 	xyz[c] = calc_64cbrt(xyz[c]);
    3944. 

  3944.       }
    3945. 

  3945.       lix[0][0] = (116 * xyz[1] - 16);
    3946. 

  3946.       lix[0][1] = 500 * (xyz[0] - xyz[1]);
    3947. 

  3947.       lix[0][2] = 200 * (xyz[1] - xyz[2]);
    3948. 

  3948.     }
    3949. 

  3949.   }
    3950. 

  3950. }
    3951. 

  3951. 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])
    3952. 

  3952. {
    3953. 

  3953.   int direction;
    3954. 

  3954.   for (direction = 0; direction < 2; direction++) {
    3955. 

  3955.     ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(top, left, inout_rgb[direction], out_lab[direction], xyz_cam);
    3956. 

  3956.   }
    3957. 

  3957. }
    3958. 

  3958. void CLASS ahd_interpolate_build_homogeneity_map(int top, int left, short (*lab)[TS][TS][3], char (*out_homogeneity_map)[TS][2])
    3959. 

  3959. {
    3960. 

  3960.   int row, col;
    3961. 

  3961.   int tr, tc;
    3962. 

  3962.   int direction;
    3963. 

  3963.   int i;
    3964. 

  3964.   short (*lix)[3];
    3965. 

  3965.   short (*lixs[2])[3];
    3966. 

  3966.   short *adjacent_lix;
    3967. 

  3967.   unsigned ldiff[2][4], abdiff[2][4], leps, abeps;
    3968. 

  3968.   static const int dir[4] = { -1, 1, -TS, TS };
    3969. 

  3969.   const int rowlimit = MIN(top+TS-2, height-4);
    3970. 

  3970.   const int collimit = MIN(left+TS-2, width-4);
    3971. 

  3971.   int homogeneity;
    3972. 

  3972.   char (*homogeneity_map_p)[2];
    3973. 

  3973. 

  3974.   memset (out_homogeneity_map, 0, 2*TS*TS);
    3975. 

  3975. 

  3976.   for (row=top+2; row < rowlimit; row++) {
    3977. 

  3977.     tr = row-top;
    3978. 

  3978.     homogeneity_map_p = &out_homogeneity_map[tr][1];
    3979. 

  3979.     for (direction=0; direction < 2; direction++) {
    3980. 

  3980.       lixs[direction] = &lab[direction][tr][1];
    3981. 

  3981.     }
    3982. 

  3982. 

  3983.     for (col=left+2; col < collimit; col++) {
    3984. 

  3984.       tc = col-left;
    3985. 

  3985.       homogeneity_map_p++;
    3986. 

  3986. 

  3987.       for (direction=0; direction < 2; direction++) {
    3988. 

  3988.         lix = ++lixs[direction];
    3989. 

  3989.         for (i=0; i < 4; i++) {
    3990. 

  3990. 	  adjacent_lix = lix[dir[i]];
    3991. 

  3991.           ldiff[direction][i] = ABS(lix[0][0]-adjacent_lix[0]);
    3992. 

  3992.           abdiff[direction][i] = SQR(lix[0][1]-adjacent_lix[1])
    3993. 

  3993.             + SQR(lix[0][2]-adjacent_lix[2]);
    3994. 

  3994.         }
    3995. 

  3995.       }
    3996. 

  3996.       leps = MIN(MAX(ldiff[0][0],ldiff[0][1]),
    3997. 

  3997.           MAX(ldiff[1][2],ldiff[1][3]));
    3998. 

  3998.       abeps = MIN(MAX(abdiff[0][0],abdiff[0][1]),
    3999. 

  3999.           MAX(abdiff[1][2],abdiff[1][3]));
    4000. 

  4000.       for (direction=0; direction < 2; direction++) {
    4001. 

  4001. 	homogeneity = 0;
    4002. 

  4002.         for (i=0; i < 4; i++) {
    4003. 

  4003.           if (ldiff[direction][i] <= leps && abdiff[direction][i] <= abeps) {
    4004. 

  4004. 	    homogeneity++;
    4005. 

  4005. 	  }
    4006. 

  4006. 	}
    4007. 

  4007. 	homogeneity_map_p[0][direction] = homogeneity;
    4008. 

  4008.       }
    4009. 

  4009.     }
    4010. 

  4010.   }
    4011. 

  4011. }
    4012. 

  4012. void CLASS ahd_interpolate_combine_homogeneous_pixels(int top, int left, ushort (*rgb)[TS][TS][3], char (*homogeneity_map)[TS][2])
    4013. 

  4013. {
    4014. 

  4014.   int row, col;
    4015. 

  4015.   int tr, tc;
    4016. 

  4016.   int i, j;
    4017. 

  4017.   int direction;
    4018. 

  4018.   int hm[2];
    4019. 

  4019.   int c;
    4020. 

  4020.   const int rowlimit = MIN(top+TS-3, height-5);
    4021. 

  4021.   const int collimit = MIN(left+TS-3, width-5);
    4022. 

  4022. 

  4023.   ushort (*pix)[4];
    4024. 

  4024.   ushort (*rix[2])[3];
    4025. 

  4025. 

  4026.   for (row=top+3; row < rowlimit; row++) {
    4027. 

  4027.     tr = row-top;
    4028. 

  4028.     pix = &image[row*width+left+2];
    4029. 

  4029.     for (direction = 0; direction < 2; direction++) {
    4030. 

  4030.       rix[direction] = &rgb[direction][tr][2];
    4031. 

  4031.     }
    4032. 

  4032. 

  4033.     for (col=left+3; col < collimit; col++) {
    4034. 

  4034.       tc = col-left;
    4035. 

  4035.       pix++;
    4036. 

  4036.       for (direction = 0; direction < 2; direction++) {
    4037. 

  4037.         rix[direction]++;
    4038. 

  4038.       }
    4039. 

  4039. 

  4040.       for (direction=0; direction < 2; direction++) {
    4041. 

  4041.         hm[direction] = 0;
    4042. 

  4042.         for (i=tr-1; i <= tr+1; i++) {
    4043. 

  4043.           for (j=tc-1; j <= tc+1; j++) {
    4044. 

  4044.             hm[direction] += homogeneity_map[i][j][direction];
    4045. 

  4045.           }
    4046. 

  4046.         }
    4047. 

  4047.       }
    4048. 

  4048.       if (hm[0] != hm[1]) {
    4049. 

  4049.         memcpy(pix[0], rix[hm[1] > hm[0]][0], 3 * sizeof(ushort));
    4050. 

  4050.       } else {
    4051. 

  4051.         FORC3 {
    4052. 

  4052.           pix[0][c] = (rix[0][0][c] + rix[1][0][c]) >> 1;
    4053. 

  4053.         }
    4054. 

  4054.       }
    4055. 

  4055.     }
    4056. 

  4056.   }
    4057. 

  4057. }
    4058. 

  4058. void CLASS ahd_interpolate()
    4059. 

  4059. {
    4060. 

  4060.   int i, j, k, top, left;
    4061. 

  4061.   float xyz_cam[3][4],r;
    4062. 

  4062.   char *buffer;
    4063. 

  4063.   ushort (*rgb)[TS][TS][3];
    4064. 

  4064.   short (*lab)[TS][TS][3];
    4065. 

  4065.   char (*homo)[TS][2];
    4066. 

  4066.   int terminate_flag = 0;
    4067. 

  4067. 

  4068.   if(dcraw_cbrt[0]<-0.1){
    4069. 

  4069.       for (i=0x10000-1; i >=0; i--) {
    4070. 

  4070.           r = i / 65535.0;
    4071. 

  4071.           dcraw_cbrt[i] = 64.0*(r > 0.008856 ? pow((double)r,1/3.0) : 7.787*r + 16/116.0);
    4072. 

  4072.       }
    4073. 

  4073.   }
    4074. 

  4074. 

  4075. #ifdef DCRAW_VERBOSE
    4076. 

  4076.   if (verbose) fprintf (stderr,_("AHD interpolation...\n"));
    4077. 

  4077. #endif
    4078. 

  4078. 

  4079.   for (i=0; i < 3; i++) {
    4080. 

  4080.     for (j=0; j < colors; j++) {
    4081. 

  4081.       xyz_cam[i][j] = 0;
    4082. 

  4082.       for (k=0; k < 3; k++) {
    4083. 

  4083.         xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
    4084. 

  4084.       }
    4085. 

  4085.     }
    4086. 

  4086.   }
    4087. 

  4087. 

  4088.   border_interpolate(5);
    4089. 

  4089. 

  4090. #ifdef LIBRAW_LIBRARY_BUILD
    4091. 

  4091. #ifdef LIBRAW_USE_OPENMP
    4092. 

  4092. #pragma omp parallel private(buffer,rgb,lab,homo,top,left,i,j,k) shared(xyz_cam,terminate_flag)
    4093. 

  4093. #endif
    4094. 

  4094. #endif
    4095. 

  4095.   {
    4096. 

  4096.     buffer = (char *) malloc (26*TS*TS);		/* 1664 kB */
    4097. 

  4097.     merror (buffer, "ahd_interpolate()");
    4098. 

  4098.     rgb  = (ushort(*)[TS][TS][3]) buffer;
    4099. 

  4099.     lab  = (short (*)[TS][TS][3])(buffer + 12*TS*TS);
    4100. 

  4100.     homo = (char  (*)[TS][2])    (buffer + 24*TS*TS);
    4101. 

  4101. 

  4102. #ifdef LIBRAW_LIBRARY_BUILD
    4103. 

  4103. #ifdef LIBRAW_USE_OPENMP
    4104. 

  4104. #pragma omp for schedule(dynamic)
    4105. 

  4105. #endif
    4106. 

  4106. #endif
    4107. 

  4107.     for (top=2; top < height-5; top += TS-6){
    4108. 

  4108. #ifdef LIBRAW_LIBRARY_BUILD
    4109. 

  4109. #ifdef LIBRAW_USE_OPENMP
    4110. 

  4110.         if(0== omp_get_thread_num())
    4111. 

  4111. #endif
    4112. 

  4112.            if(callbacks.progress_cb) {                                     
    4113. 

  4113.                int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,LIBRAW_PROGRESS_INTERPOLATE,top-2,height-7);
    4114. 

  4114.                if(rr)
    4115. 

  4115.                    terminate_flag = 1;
    4116. 

  4116.            }
    4117. 

  4117. #endif
    4118. 

  4118.         for (left=2; !terminate_flag && (left < width-5); left += TS-6) {
    4119. 

  4119.             ahd_interpolate_green_h_and_v(top, left, rgb);
    4120. 

  4120.             ahd_interpolate_r_and_b_and_convert_to_cielab(top, left, rgb, lab, xyz_cam);
    4121. 

  4121.             ahd_interpolate_build_homogeneity_map(top, left, lab, homo);
    4122. 

  4122.             ahd_interpolate_combine_homogeneous_pixels(top, left, rgb, homo);
    4123. 

  4123.       }
    4124. 

  4124.     }
    4125. 

  4125.     free (buffer);
    4126. 

  4126.   }
    4127. 

  4127. #ifdef LIBRAW_LIBRARY_BUILD 
    4128. 

  4128.   if(terminate_flag)
    4129. 

  4129.       throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
    4130. 

  4130. #endif
    4131. 

  4131. }
    4132. 

  4132. 

  4133. 

  4134. 

  4135. #undef TS
    4136. 

  4136. 

  4137. #else
    4138. 

  4138. /*
    4139. 

  4139.    Adaptive Homogeneity-Directed interpolation is based on
    4140. 

  4140.    the work of Keigo Hirakawa, Thomas Parks, and Paul Lee.
    4141. 

  4141.  */
    4142. 

  4142. #define TS 256		/* Tile Size */
    4143. 

  4143. 

  4144. void CLASS ahd_interpolate()
    4145. 

  4145. {
    4146. 

  4146.   int i, j, k, top, left, row, col, tr, tc, c, d, val, hm[2];
    4147. 

  4147.   ushort (*pix)[4], (*rix)[3];
    4148. 

  4148.   static const int dir[4] = { -1, 1, -TS, TS };
    4149. 

  4149.   unsigned ldiff[2][4], abdiff[2][4], leps, abeps;
    4150. 

  4150.   float r, cbrt[0x10000], xyz[3], xyz_cam[3][4];
    4151. 

  4151.   ushort (*rgb)[TS][TS][3];
    4152. 

  4152.    short (*lab)[TS][TS][3], (*lix)[3];
    4153. 

  4153.    char (*homo)[TS][TS], *buffer;
    4154. 

  4154. 

  4155. #ifdef DCRAW_VERBOSE
    4156. 

  4156.   if (verbose) fprintf (stderr,_("AHD interpolation...\n"));
    4157. 

  4157. #endif
    4158. 

  4158. 

  4159.   for (i=0; i < 0x10000; i++) {
    4160. 

  4160.     r = i / 65535.0;
    4161. 

  4161.     cbrt[i] = r > 0.008856 ? pow((double)r,(double)(1/3.0)) : 7.787*r + 16/116.0;
    4162. 

  4162.   }
    4163. 

  4163.   for (i=0; i < 3; i++)
    4164. 

  4164.     for (j=0; j < colors; j++)
    4165. 

  4165.       for (xyz_cam[i][j] = k=0; k < 3; k++)
    4166. 

  4166. 	xyz_cam[i][j] += xyz_rgb[i][k] * rgb_cam[k][j] / d65_white[i];
    4167. 

  4167. 

  4168.   border_interpolate(5);
    4169. 

  4169.   buffer = (char *) malloc (26*TS*TS);		/* 1664 kB */
    4170. 

  4170.   merror (buffer, "ahd_interpolate()");
    4171. 

  4171.   rgb  = (ushort(*)[TS][TS][3]) buffer;
    4172. 

  4172.   lab  = (short (*)[TS][TS][3])(buffer + 12*TS*TS);
    4173. 

  4173.   homo = (char  (*)[TS][TS])   (buffer + 24*TS*TS);
    4174. 

  4174. 

  4175.   for (top=2; top < height-5; top += TS-6)
    4176. 

  4176.     for (left=2; left < width-5; left += TS-6) {
    4177. 

  4177. 

  4178. /*  Interpolate green horizontally and vertically:		*/
    4179. 

  4179.       for (row = top; row < top+TS && row < height-2; row++) {
    4180. 

  4180. 	col = left + (FC(row,left) & 1);
    4181. 

  4181. 	for (c = FC(row,col); col < left+TS && col < width-2; col+=2) {
    4182. 

  4182. 	  pix = image + row*width+col;
    4183. 

  4183. 	  val = ((pix[-1][1] + pix[0][c] + pix[1][1]) * 2
    4184. 

  4184. 		- pix[-2][c] - pix[2][c]) >> 2;
    4185. 

  4185. 	  rgb[0][row-top][col-left][1] = ULIM(val,pix[-1][1],pix[1][1]);
    4186. 

  4186. 	  val = ((pix[-width][1] + pix[0][c] + pix[width][1]) * 2
    4187. 

  4187. 		- pix[-2*width][c] - pix[2*width][c]) >> 2;
    4188. 

  4188. 	  rgb[1][row-top][col-left][1] = ULIM(val,pix[-width][1],pix[width][1]);
    4189. 

  4189. 	}
    4190. 

  4190.       }
    4191. 

  4191. /*  Interpolate red and blue, and convert to CIELab:		*/
    4192. 

  4192.       for (d=0; d < 2; d++)
    4193. 

  4193. 	for (row=top+1; row < top+TS-1 && row < height-3; row++)
    4194. 

  4194. 	  for (col=left+1; col < left+TS-1 && col < width-3; col++) {
    4195. 

  4195. 	    pix = image + row*width+col;
    4196. 

  4196. 	    rix = &rgb[d][row-top][col-left];
    4197. 

  4197. 	    lix = &lab[d][row-top][col-left];
    4198. 

  4198. 	    if ((c = 2 - FC(row,col)) == 1) {
    4199. 

  4199. 	      c = FC(row+1,col);
    4200. 

  4200. 	      val = pix[0][1] + (( pix[-1][2-c] + pix[1][2-c]
    4201. 

  4201. 				 - rix[-1][1] - rix[1][1] ) >> 1);
    4202. 

  4202. 	      rix[0][2-c] = CLIP(val);
    4203. 

  4203. 	      val = pix[0][1] + (( pix[-width][c] + pix[width][c]
    4204. 

  4204. 				 - rix[-TS][1] - rix[TS][1] ) >> 1);
    4205. 

  4205. 	    } else
    4206. 

  4206. 	      val = rix[0][1] + (( pix[-width-1][c] + pix[-width+1][c]
    4207. 

  4207. 				 + pix[+width-1][c] + pix[+width+1][c]
    4208. 

  4208. 				 - rix[-TS-1][1] - rix[-TS+1][1]
    4209. 

  4209. 				 - rix[+TS-1][1] - rix[+TS+1][1] + 1) >> 2);
    4210. 

  4210. 	    rix[0][c] = CLIP(val);
    4211. 

  4211. 	    c = FC(row,col);
    4212. 

  4212. 	    rix[0][c] = pix[0][c];
    4213. 

  4213. 	    xyz[0] = xyz[1] = xyz[2] = 0.5;
    4214. 

  4214. 	    FORCC {
    4215. 

  4215. 	      xyz[0] += xyz_cam[0][c] * rix[0][c];
    4216. 

  4216. 	      xyz[1] += xyz_cam[1][c] * rix[0][c];
    4217. 

  4217. 	      xyz[2] += xyz_cam[2][c] * rix[0][c];
    4218. 

  4218. 	    }
    4219. 

  4219. 	    xyz[0] = cbrt[CLIP((int) xyz[0])];
    4220. 

  4220. 	    xyz[1] = cbrt[CLIP((int) xyz[1])];
    4221. 

  4221. 	    xyz[2] = cbrt[CLIP((int) xyz[2])];
    4222. 

  4222. 	    lix[0][0] = 64 * (116 * xyz[1] - 16);
    4223. 

  4223. 	    lix[0][1] = 64 * 500 * (xyz[0] - xyz[1]);
    4224. 

  4224. 	    lix[0][2] = 64 * 200 * (xyz[1] - xyz[2]);
    4225. 

  4225. 	  }
    4226. 

  4226. /*  Build homogeneity maps from the CIELab images:		*/
    4227. 

  4227.       memset (homo, 0, 2*TS*TS);
    4228. 

  4228.       for (row=top+2; row < top+TS-2 && row < height-4; row++) {
    4229. 

  4229. 	tr = row-top;
    4230. 

  4230. 	for (col=left+2; col < left+TS-2 && col < width-4; col++) {
    4231. 

  4231. 	  tc = col-left;
    4232. 

  4232. 	  for (d=0; d < 2; d++) {
    4233. 

  4233. 	    lix = &lab[d][tr][tc];
    4234. 

  4234. 	    for (i=0; i < 4; i++) {
    4235. 

  4235. 	       ldiff[d][i] = ABS(lix[0][0]-lix[dir[i]][0]);
    4236. 

  4236. 	      abdiff[d][i] = SQR(lix[0][1]-lix[dir[i]][1])
    4237. 

  4237. 			   + SQR(lix[0][2]-lix[dir[i]][2]);
    4238. 

  4238. 	    }
    4239. 

  4239. 	  }
    4240. 

  4240. 	  leps = MIN(MAX(ldiff[0][0],ldiff[0][1]),
    4241. 

  4241. 		     MAX(ldiff[1][2],ldiff[1][3]));
    4242. 

  4242. 	  abeps = MIN(MAX(abdiff[0][0],abdiff[0][1]),
    4243. 

  4243. 		      MAX(abdiff[1][2],abdiff[1][3]));
    4244. 

  4244. 	  for (d=0; d < 2; d++)
    4245. 

  4245. 	    for (i=0; i < 4; i++)
    4246. 

  4246. 	      if (ldiff[d][i] <= leps && abdiff[d][i] <= abeps)
    4247. 

  4247. 		homo[d][tr][tc]++;
    4248. 

  4248. 	}
    4249. 

  4249.       }
    4250. 

  4250. /*  Combine the most homogenous pixels for the final result:	*/
    4251. 

  4251.       for (row=top+3; row < top+TS-3 && row < height-5; row++) {
    4252. 

  4252. 	tr = row-top;
    4253. 

  4253. 	for (col=left+3; col < left+TS-3 && col < width-5; col++) {
    4254. 

  4254. 	  tc = col-left;
    4255. 

  4255. 	  for (d=0; d < 2; d++)
    4256. 

  4256. 	    for (hm[d]=0, i=tr-1; i <= tr+1; i++)
    4257. 

  4257. 	      for (j=tc-1; j <= tc+1; j++)
    4258. 

  4258. 		hm[d] += homo[d][i][j];
    4259. 

  4259. 	  if (hm[0] != hm[1])
    4260. 

  4260. 	    FORC3 image[row*width+col][c] = rgb[hm[1] > hm[0]][tr][tc][c];
    4261. 

  4261. 	  else
    4262. 

  4262. 	    FORC3 image[row*width+col][c] =
    4263. 

  4263. 		(rgb[0][tr][tc][c] + rgb[1][tr][tc][c]) >> 1;
    4264. 

  4264. 	}
    4265. 

  4265.       }
    4266. 

  4266.     }
    4267. 

  4267.   free (buffer);
    4268. 

  4268. }
    4269. 

  4269. #undef TS
    4270. 

  4270. #endif
    4271. 

  4271. 

  4272. void CLASS median_filter()
    4273. 

  4273. {
    4274. 

  4274.   ushort (*pix)[4];
    4275. 

  4275.   int pass, c, i, j, k, med[9];
    4276. 

  4276.   static const uchar opt[] =	/* Optimal 9-element median search */
    4277. 

  4277.   { 1,2, 4,5, 7,8, 0,1, 3,4, 6,7, 1,2, 4,5, 7,8,
    4278. 

  4278.     0,3, 5,8, 4,7, 3,6, 1,4, 2,5, 4,7, 4,2, 6,4, 4,2 };
    4279. 

  4279. 

  4280.   for (pass=1; pass <= med_passes; pass++) {
    4281. 

  4281. #ifdef LIBRAW_LIBRARY_BUILD
    4282. 

  4282.       RUN_CALLBACK(LIBRAW_PROGRESS_MEDIAN_FILTER,pass-1,med_passes);
    4283. 

  4283. #endif
    4284. 

  4284. #ifdef DCRAW_VERBOSE
    4285. 

  4285.     if (verbose)
    4286. 

  4286.       fprintf (stderr,_("Median filter pass %d...\n"), pass);
    4287. 

  4287. #endif
    4288. 

  4288.     for (c=0; c < 3; c+=2) {
    4289. 

  4289.       for (pix = image; pix < image+width*height; pix++)
    4290. 

  4290. 	pix[0][3] = pix[0][c];
    4291. 

  4291.       for (pix = image+width; pix < image+width*(height-1); pix++) {
    4292. 

  4292. 	if ((pix-image+1) % width < 2) continue;
    4293. 

  4293. 	for (k=0, i = -width; i <= width; i += width)
    4294. 

  4294. 	  for (j = i-1; j <= i+1; j++)
    4295. 

  4295. 	    med[k++] = pix[j][3] - pix[j][1];
    4296. 

  4296. 	for (i=0; i < sizeof opt; i+=2)
    4297. 

  4297. 	  if     (med[opt[i]] > med[opt[i+1]])
    4298. 

  4298. 	    SWAP (med[opt[i]] , med[opt[i+1]]);
    4299. 

  4299. 	pix[0][c] = CLIP(med[4] + pix[0][1]);
    4300. 

  4300.       }
    4301. 

  4301.     }
    4302. 

  4302.   }
    4303. 

  4303. }
    4304. 

  4304. 

  4305. void CLASS blend_highlights()
    4306. 

  4306. {
    4307. 

  4307.   int clip=INT_MAX, row, col, c, i, j;
    4308. 

  4308.   static const float trans[2][4][4] =
    4309. 

  4309.   { { { 1,1,1 }, { 1.7320508,-1.7320508,0 }, { -1,-1,2 } },
    4310. 

  4310.     { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
    4311. 

  4311.   static const float itrans[2][4][4] =
    4312. 

  4312.   { { { 1,0.8660254,-0.5 }, { 1,-0.8660254,-0.5 }, { 1,0,1 } },
    4313. 

  4313.     { { 1,1,1,1 }, { 1,-1,1,-1 }, { 1,1,-1,-1 }, { 1,-1,-1,1 } } };
    4314. 

  4314.   float cam[2][4], lab[2][4], sum[2], chratio;
    4315. 

  4315. 

  4316.   if ((unsigned) (colors-3) > 1) return;
    4317. 

  4317. #ifdef DCRAW_VERBOSE
    4318. 

  4318.   if (verbose) fprintf (stderr,_("Blending highlights...\n"));
    4319. 

  4319. #endif
    4320. 

  4320. #ifdef LIBRAW_LIBRARY_BUILD
    4321. 

  4321.   RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,0,2);
    4322. 

  4322. #endif
    4323. 

  4323.   FORCC if (clip > (i = 65535*pre_mul[c])) clip = i;
    4324. 

  4324.   for (row=0; row < height; row++)
    4325. 

  4325.     for (col=0; col < width; col++) {
    4326. 

  4326.       FORCC if (image[row*width+col][c] > clip) break;
    4327. 

  4327.       if (c == colors) continue;
    4328. 

  4328.       FORCC {
    4329. 

  4329. 	cam[0][c] = image[row*width+col][c];
    4330. 

  4330. 	cam[1][c] = MIN(cam[0][c],clip);
    4331. 

  4331.       }
    4332. 

  4332.       for (i=0; i < 2; i++) {
    4333. 

  4333. 	FORCC for (lab[i][c]=j=0; j < colors; j++)
    4334. 

  4334. 	  lab[i][c] += trans[colors-3][c][j] * cam[i][j];
    4335. 

  4335. 	for (sum[i]=0,c=1; c < colors; c++)
    4336. 

  4336. 	  sum[i] += SQR(lab[i][c]);
    4337. 

  4337.       }
    4338. 

  4338.       chratio = sqrt(sum[1]/sum[0]);
    4339. 

  4339.       for (c=1; c < colors; c++)
    4340. 

  4340. 	lab[0][c] *= chratio;
    4341. 

  4341.       FORCC for (cam[0][c]=j=0; j < colors; j++)
    4342. 

  4342. 	cam[0][c] += itrans[colors-3][c][j] * lab[0][j];
    4343. 

  4343.       FORCC image[row*width+col][c] = cam[0][c] / colors;
    4344. 

  4344.     }
    4345. 

  4345. #ifdef LIBRAW_LIBRARY_BUILD
    4346. 

  4346.   RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,1,2);
    4347. 

  4347. #endif
    4348. 

  4348. }
    4349. 

  4349. 

  4350. #define SCALE (4 >> shrink)
    4351. 

  4351. void CLASS recover_highlights()
    4352. 

  4352. {
    4353. 

  4353.   float *map, sum, wgt, grow;
    4354. 

  4354.   int hsat[4], count, spread, change, val, i;
    4355. 

  4355.   unsigned high, wide, mrow, mcol, row, col, kc, c, d, y, x;
    4356. 

  4356.   ushort *pixel;
    4357. 

  4357.   static const signed char dir[8][2] =
    4358. 

  4358.     { {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1} };
    4359. 

  4359. 

  4360. #ifdef DCRAW_VERBOSE
    4361. 

  4361.   if (verbose) fprintf (stderr,_("Rebuilding highlights...\n"));
    4362. 

  4362. #endif
    4363. 

  4363. 

  4364.   grow = pow (2.0, 4-highlight);
    4365. 

  4365.   FORCC hsat[c] = 32000 * pre_mul[c];
    4366. 

  4366.   for (kc=0, c=1; c < colors; c++)
    4367. 

  4367.     if (pre_mul[kc] < pre_mul[c]) kc = c;
    4368. 

  4368.   high = height / SCALE;
    4369. 

  4369.   wide =  width / SCALE;
    4370. 

  4370.   map = (float *) calloc (high*wide, sizeof *map);
    4371. 

  4371.   merror (map, "recover_highlights()");
    4372. 

  4372.   FORCC if (c != kc) {
    4373. 

  4373. #ifdef LIBRAW_LIBRARY_BUILD
    4374. 

  4374.       RUN_CALLBACK(LIBRAW_PROGRESS_HIGHLIGHTS,c-1,colors-1);
    4375. 

  4375. #endif
    4376. 

  4376.     memset (map, 0, high*wide*sizeof *map);
    4377. 

  4377.     for (mrow=0; mrow < high; mrow++)
    4378. 

  4378.       for (mcol=0; mcol < wide; mcol++) {
    4379. 

  4379. 	sum = wgt = count = 0;
    4380. 

  4380. 	for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
    4381. 

  4381. 	  for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
    4382. 

  4382. 	    pixel = image[row*width+col];
    4383. 

  4383. 	    if (pixel[c] / hsat[c] == 1 && pixel[kc] > 24000) {
    4384. 

  4384. 	      sum += pixel[c];
    4385. 

  4385. 	      wgt += pixel[kc];
    4386. 

  4386. 	      count++;
    4387. 

  4387. 	    }
    4388. 

  4388. 	  }
    4389. 

  4389. 	if (count == SCALE*SCALE)
    4390. 

  4390. 	  map[mrow*wide+mcol] = sum / wgt;
    4391. 

  4391.       }
    4392. 

  4392.     for (spread = 32/grow; spread--; ) {
    4393. 

  4393.       for (mrow=0; mrow < high; mrow++)
    4394. 

  4394. 	for (mcol=0; mcol < wide; mcol++) {
    4395. 

  4395. 	  if (map[mrow*wide+mcol]) continue;
    4396. 

  4396. 	  sum = count = 0;
    4397. 

  4397. 	  for (d=0; d < 8; d++) {
    4398. 

  4398. 	    y = mrow + dir[d][0];
    4399. 

  4399. 	    x = mcol + dir[d][1];
    4400. 

  4400. 	    if (y < high && x < wide && map[y*wide+x] > 0) {
    4401. 

  4401. 	      sum  += (1 + (d & 1)) * map[y*wide+x];
    4402. 

  4402. 	      count += 1 + (d & 1);
    4403. 

  4403. 	    }
    4404. 

  4404. 	  }
    4405. 

  4405. 	  if (count > 3)
    4406. 

  4406. 	    map[mrow*wide+mcol] = - (sum+grow) / (count+grow);
    4407. 

  4407. 	}
    4408. 

  4408.       for (change=i=0; i < high*wide; i++)
    4409. 

  4409. 	if (map[i] < 0) {
    4410. 

  4410. 	  map[i] = -map[i];
    4411. 

  4411. 	  change = 1;
    4412. 

  4412. 	}
    4413. 

  4413.       if (!change) break;
    4414. 

  4414.     }
    4415. 

  4415.     for (i=0; i < high*wide; i++)
    4416. 

  4416.       if (map[i] == 0) map[i] = 1;
    4417. 

  4417.     for (mrow=0; mrow < high; mrow++)
    4418. 

  4418.       for (mcol=0; mcol < wide; mcol++) {
    4419. 

  4419. 	for (row = mrow*SCALE; row < (mrow+1)*SCALE; row++)
    4420. 

  4420. 	  for (col = mcol*SCALE; col < (mcol+1)*SCALE; col++) {
    4421. 

  4421. 	    pixel = image[row*width+col];
    4422. 

  4422. 	    if (pixel[c] / hsat[c] > 1) {
    4423. 

  4423. 	      val = pixel[kc] * map[mrow*wide+mcol];
    4424. 

  4424. 	      if (pixel[c] < val) pixel[c] = CLIP(val);
    4425. 

  4425. 	    }
    4426. 

  4426. 	  }
    4427. 

  4427.       }
    4428. 

  4428.   }
    4429. 

  4429.   free (map);
    4430. 

  4430. }
    4431. 

  4431. #undef SCALE
    4432. 

  4432. 

  4433. void CLASS tiff_get (unsigned base,
    4434. 

  4434. 	unsigned *tag, unsigned *type, unsigned *len, unsigned *save)
    4435. 

  4435. {
    4436. 

  4436.   *tag  = get2();
    4437. 

  4437.   *type = get2();
    4438. 

  4438.   *len  = get4();
    4439. 

  4439.   *save = ftell(ifp) + 4;
    4440. 

  4440.   if (*len * ("11124811248488"[*type < 14 ? *type:0]-'0') > 4)
    4441. 

  4441.     fseek (ifp, get4()+base, SEEK_SET);
    4442. 

  4442. }
    4443. 

  4443. 

  4444. void CLASS parse_thumb_note (int base, unsigned toff, unsigned tlen)
    4445. 

  4445. {
    4446. 

  4446.   unsigned entries, tag, type, len, save;
    4447. 

  4447. 

  4448.   entries = get2();
    4449. 

  4449.   while (entries--) {
    4450. 

  4450.     tiff_get (base, &tag, &type, &len, &save);
    4451. 

  4451.     if (tag == toff) thumb_offset = get4()+base;
    4452. 

  4452.     if (tag == tlen) thumb_length = get4();
    4453. 

  4453.     fseek (ifp, save, SEEK_SET);
    4454. 

  4454.   }
    4455. 

  4455. }
    4456. 

  4456. void CLASS parse_makernote (int base, int uptag)
    4457. 

  4457. {
    4458. 

  4458.   static const uchar xlat[2][256] = {
    4459. 

  4459.   { 0xc1,0xbf,0x6d,0x0d,0x59,0xc5,0x13,0x9d,0x83,0x61,0x6b,0x4f,0xc7,0x7f,0x3d,0x3d,
    4460. 

  4460.     0x53,0x59,0xe3,0xc7,0xe9,0x2f,0x95,0xa7,0x95,0x1f,0xdf,0x7f,0x2b,0x29,0xc7,0x0d,
    4461. 

  4461.     0xdf,0x07,0xef,0x71,0x89,0x3d,0x13,0x3d,0x3b,0x13,0xfb,0x0d,0x89,0xc1,0x65,0x1f,
    4462. 

  4462.     0xb3,0x0d,0x6b,0x29,0xe3,0xfb,0xef,0xa3,0x6b,0x47,0x7f,0x95,0x35,0xa7,0x47,0x4f,
    4463. 

  4463.     0xc7,0xf1,0x59,0x95,0x35,0x11,0x29,0x61,0xf1,0x3d,0xb3,0x2b,0x0d,0x43,0x89,0xc1,
    4464. 

  4464.     0x9d,0x9d,0x89,0x65,0xf1,0xe9,0xdf,0xbf,0x3d,0x7f,0x53,0x97,0xe5,0xe9,0x95,0x17,
    4465. 

  4465.     0x1d,0x3d,0x8b,0xfb,0xc7,0xe3,0x67,0xa7,0x07,0xf1,0x71,0xa7,0x53,0xb5,0x29,0x89,
    4466. 

  4466.     0xe5,0x2b,0xa7,0x17,0x29,0xe9,0x4f,0xc5,0x65,0x6d,0x6b,0xef,0x0d,0x89,0x49,0x2f,
    4467. 

  4467.     0xb3,0x43,0x53,0x65,0x1d,0x49,0xa3,0x13,0x89,0x59,0xef,0x6b,0xef,0x65,0x1d,0x0b,
    4468. 

  4468.     0x59,0x13,0xe3,0x4f,0x9d,0xb3,0x29,0x43,0x2b,0x07,0x1d,0x95,0x59,0x59,0x47,0xfb,
    4469. 

  4469.     0xe5,0xe9,0x61,0x47,0x2f,0x35,0x7f,0x17,0x7f,0xef,0x7f,0x95,0x95,0x71,0xd3,0xa3,
    4470. 

  4470.     0x0b,0x71,0xa3,0xad,0x0b,0x3b,0xb5,0xfb,0xa3,0xbf,0x4f,0x83,0x1d,0xad,0xe9,0x2f,
    4471. 

  4471.     0x71,0x65,0xa3,0xe5,0x07,0x35,0x3d,0x0d,0xb5,0xe9,0xe5,0x47,0x3b,0x9d,0xef,0x35,
    4472. 

  4472.     0xa3,0xbf,0xb3,0xdf,0x53,0xd3,0x97,0x53,0x49,0x71,0x07,0x35,0x61,0x71,0x2f,0x43,
    4473. 

  4473.     0x2f,0x11,0xdf,0x17,0x97,0xfb,0x95,0x3b,0x7f,0x6b,0xd3,0x25,0xbf,0xad,0xc7,0xc5,
    4474. 

  4474.     0xc5,0xb5,0x8b,0xef,0x2f,0xd3,0x07,0x6b,0x25,0x49,0x95,0x25,0x49,0x6d,0x71,0xc7 },
    4475. 

  4475.   { 0xa7,0xbc,0xc9,0xad,0x91,0xdf,0x85,0xe5,0xd4,0x78,0xd5,0x17,0x46,0x7c,0x29,0x4c,
    4476. 

  4476.     0x4d,0x03,0xe9,0x25,0x68,0x11,0x86,0xb3,0xbd,0xf7,0x6f,0x61,0x22,0xa2,0x26,0x34,
    4477. 

  4477.     0x2a,0xbe,0x1e,0x46,0x14,0x68,0x9d,0x44,0x18,0xc2,0x40,0xf4,0x7e,0x5f,0x1b,0xad,
    4478. 

  4478.     0x0b,0x94,0xb6,0x67,0xb4,0x0b,0xe1,0xea,0x95,0x9c,0x66,0xdc,0xe7,0x5d,0x6c,0x05,
    4479. 

  4479.     0xda,0xd5,0xdf,0x7a,0xef,0xf6,0xdb,0x1f,0x82,0x4c,0xc0,0x68,0x47,0xa1,0xbd,0xee,
    4480. 

  4480.     0x39,0x50,0x56,0x4a,0xdd,0xdf,0xa5,0xf8,0xc6,0xda,0xca,0x90,0xca,0x01,0x42,0x9d,
    4481. 

  4481.     0x8b,0x0c,0x73,0x43,0x75,0x05,0x94,0xde,0x24,0xb3,0x80,0x34,0xe5,0x2c,0xdc,0x9b,
    4482. 

  4482.     0x3f,0xca,0x33,0x45,0xd0,0xdb,0x5f,0xf5,0x52,0xc3,0x21,0xda,0xe2,0x22,0x72,0x6b,
    4483. 

  4483.     0x3e,0xd0,0x5b,0xa8,0x87,0x8c,0x06,0x5d,0x0f,0xdd,0x09,0x19,0x93,0xd0,0xb9,0xfc,
    4484. 

  4484.     0x8b,0x0f,0x84,0x60,0x33,0x1c,0x9b,0x45,0xf1,0xf0,0xa3,0x94,0x3a,0x12,0x77,0x33,
    4485. 

  4485.     0x4d,0x44,0x78,0x28,0x3c,0x9e,0xfd,0x65,0x57,0x16,0x94,0x6b,0xfb,0x59,0xd0,0xc8,
    4486. 

  4486.     0x22,0x36,0xdb,0xd2,0x63,0x98,0x43,0xa1,0x04,0x87,0x86,0xf7,0xa6,0x26,0xbb,0xd6,
    4487. 

  4487.     0x59,0x4d,0xbf,0x6a,0x2e,0xaa,0x2b,0xef,0xe6,0x78,0xb6,0x4e,0xe0,0x2f,0xdc,0x7c,
    4488. 

  4488.     0xbe,0x57,0x19,0x32,0x7e,0x2a,0xd0,0xb8,0xba,0x29,0x00,0x3c,0x52,0x7d,0xa8,0x49,
    4489. 

  4489.     0x3b,0x2d,0xeb,0x25,0x49,0xfa,0xa3,0xaa,0x39,0xa7,0xc5,0xa7,0x50,0x11,0x36,0xfb,
    4490. 

  4490.     0xc6,0x67,0x4a,0xf5,0xa5,0x12,0x65,0x7e,0xb0,0xdf,0xaf,0x4e,0xb3,0x61,0x7f,0x2f } };
    4491. 

  4491.   unsigned offset=0, entries, tag, type, len, save, c;
    4492. 

  4492.   unsigned ver97=0, serial=0, i, wbi=0, wb[4]={0,0,0,0};
    4493. 

  4493.   uchar buf97[324], ci, cj, ck;
    4494. 

  4494.   short morder, sorder=order;
    4495. 

  4495.   char buf[10];
    4496. 

  4496. /*
    4497. 

  4497.    The MakerNote might have its own TIFF header (possibly with
    4498. 

  4498.    its own byte-order!), or it might just be a table.
    4499. 

  4499.  */
    4500. 

  4500.   if (!strcmp(make,"Nokia")) return;
    4501. 

  4501.   fread (buf, 1, 10, ifp);
    4502. 

  4502.   if (!strncmp (buf,"KDK" ,3) ||	/* these aren't TIFF tables */
    4503. 

  4503.       !strncmp (buf,"VER" ,3) ||
    4504. 

  4504.       !strncmp (buf,"IIII",4) ||
    4505. 

  4505.       !strncmp (buf,"MMMM",4)) return;
    4506. 

  4506.   if (!strncmp (buf,"KC"  ,2) ||	/* Konica KD-400Z, KD-510Z */
    4507. 

  4507.       !strncmp (buf,"MLY" ,3)) {	/* Minolta DiMAGE G series */
    4508. 

  4508.     order = 0x4d4d;
    4509. 

  4509.     while ((i=ftell(ifp)) < data_offset && i < 16384) {
    4510. 

  4510.       wb[0] = wb[2];  wb[2] = wb[1];  wb[1] = wb[3];
    4511. 

  4511.       wb[3] = get2();
    4512. 

  4512.       if (wb[1] == 256 && wb[3] == 256 &&
    4513. 

  4513. 	  wb[0] > 256 && wb[0] < 640 && wb[2] > 256 && wb[2] < 640)
    4514. 

  4514. 	FORC4 cam_mul[c] = wb[c];
    4515. 

  4515.     }
    4516. 

  4516.     goto quit;
    4517. 

  4517.   }
    4518. 

  4518.   if (!strcmp (buf,"Nikon")) {
    4519. 

  4519.     base = ftell(ifp);
    4520. 

  4520.     order = get2();
    4521. 

  4521.     if (get2() != 42) goto quit;
    4522. 

  4522.     offset = get4();
    4523. 

  4523.     fseek (ifp, offset-8, SEEK_CUR);
    4524. 

  4524.   } else if (!strcmp (buf,"OLYMPUS")) {
    4525. 

  4525.     base = ftell(ifp)-10;
    4526. 

  4526.     fseek (ifp, -2, SEEK_CUR);
    4527. 

  4527.     order = get2();  get2();
    4528. 

  4528.   } else if (!strncmp (buf,"SONY",4) ||
    4529. 

  4529. 	     !strcmp  (buf,"Panasonic")) {
    4530. 

  4530.     goto nf;
    4531. 

  4531.   } else if (!strncmp (buf,"FUJIFILM",8)) {
    4532. 

  4532.     base = ftell(ifp)-10;
    4533. 

  4533. nf: order = 0x4949;
    4534. 

  4534.     fseek (ifp,  2, SEEK_CUR);
    4535. 

  4535.   } else if (!strcmp (buf,"OLYMP") ||
    4536. 

  4536. 	     !strcmp (buf,"LEICA") ||
    4537. 

  4537. 	     !strcmp (buf,"Ricoh") ||
    4538. 

  4538. 	     !strcmp (buf,"EPSON"))
    4539. 

  4539.     fseek (ifp, -2, SEEK_CUR);
    4540. 

  4540.   else if (!strcmp (buf,"AOC") ||
    4541. 

  4541. 	   !strcmp (buf,"QVC"))
    4542. 

  4542.     fseek (ifp, -4, SEEK_CUR);
    4543. 

  4543.   else {
    4544. 

  4544.     fseek (ifp, -10, SEEK_CUR);
    4545. 

  4545.     if (!strncmp(make,"SAMSUNG",7))
    4546. 

  4546.       base = ftell(ifp);
    4547. 

  4547.   }
    4548. 

  4548.   entries = get2();
    4549. 

  4549.   if (entries > 1000) return;
    4550. 

  4550.   morder = order;
    4551. 

  4551.   while (entries--) {
    4552. 

  4552.     order = morder;
    4553. 

  4553.     tiff_get (base, &tag, &type, &len, &save);
    4554. 

  4554.     tag |= uptag << 16;
    4555. 

  4555.     if (tag == 2 && strstr(make,"NIKON") && !iso_speed)
    4556. 

  4556.       iso_speed = (get2(),get2());
    4557. 

  4557.     if (tag == 4 && len > 26 && len < 35) {
    4558. 

  4558.       if ((i=(get4(),get2())) != 0x7fff && !iso_speed)
    4559. 

  4559. 	iso_speed = 50 * pow (2.0, i/32.0 - 4);
    4560. 

  4560.       if ((i=(get2(),get2())) != 0x7fff && !aperture)
    4561. 

  4561. 	aperture = pow (2.0, i/64.0);
    4562. 

  4562.       if ((i=get2()) != 0xffff && !shutter)
    4563. 

  4563. 	shutter = pow (2.0, (short) i/-32.0);
    4564. 

  4564.       wbi = (get2(),get2());
    4565. 

  4565.       shot_order = (get2(),get2());
    4566. 

  4566.     }
    4567. 

  4567.     if ((tag == 4 || tag == 0x114) && !strncmp(make,"KONICA",6)) {
    4568. 

  4568.       fseek (ifp, tag == 4 ? 140:160, SEEK_CUR);
    4569. 

  4569.       switch (get2()) {
    4570. 

  4570. 	case 72:  flip = 0;  break;
    4571. 

  4571. 	case 76:  flip = 6;  break;
    4572. 

  4572. 	case 82:  flip = 5;  break;
    4573. 

  4573.       }
    4574. 

  4574.     }
    4575. 

  4575.     if (tag == 7 && type == 2 && len > 20)
    4576. 

  4576.       fgets (model2, 64, ifp);
    4577. 

  4577.     if (tag == 8 && type == 4)
    4578. 

  4578.       shot_order = get4();
    4579. 

  4579.     if (tag == 9 && !strcmp(make,"Canon"))
    4580. 

  4580.       fread (artist, 64, 1, ifp);
    4581. 

  4581.     if (tag == 0xc && len == 4) {
    4582. 

  4582.       cam_mul[0] = getreal(type);
    4583. 

  4583.       cam_mul[2] = getreal(type);
    4584. 

  4584.     }
    4585. 

  4585.     if (tag == 0xd && type == 7 && get2() == 0xaaaa) {
    4586. 

  4586.       for (c=i=2; (ushort) c != 0xbbbb && i < len; i++)
    4587. 

  4587. 	c = c << 8 | fgetc(ifp);
    4588. 

  4588.       while ((i+=4) < len-5)
    4589. 

  4589. 	if (get4() == 257 && (i=len) && (c = (get4(),fgetc(ifp))) < 3)
    4590. 

  4590. 	  flip = "065"[c]-'0';
    4591. 

  4591.     }
    4592. 

  4592.     if (tag == 0x10 && type == 4)
    4593. 

  4593.       unique_id = get4();
    4594. 

  4594.     if (tag == 0x11 && is_raw && !strncmp(make,"NIKON",5)) {
    4595. 

  4595.       fseek (ifp, get4()+base, SEEK_SET);
    4596. 

  4596.       parse_tiff_ifd (base);
    4597. 

  4597.     }
    4598. 

  4598.     if (tag == 0x14 && type == 7) {
    4599. 

  4599.       if (len == 2560) {
    4600. 

  4600. 	fseek (ifp, 1248, SEEK_CUR);
    4601. 

  4601. 	goto get2_256;
    4602. 

  4602.       }
    4603. 

  4603.       fread (buf, 1, 10, ifp);
    4604. 

  4604.       if (!strncmp(buf,"NRW ",4)) {
    4605. 

  4605. 	fseek (ifp, strcmp(buf+4,"0100") ? 46:1546, SEEK_CUR);
    4606. 

  4606. 	cam_mul[0] = get4() << 2;
    4607. 

  4607. 	cam_mul[1] = get4() + get4();
    4608. 

  4608. 	cam_mul[2] = get4() << 2;
    4609. 

  4609.       }
    4610. 

  4610.     }
    4611. 

  4611.     if (tag == 0x15 && type == 2 && is_raw)
    4612. 

  4612.       fread (model, 64, 1, ifp);
    4613. 

  4613.     if (strstr(make,"PENTAX")) {
    4614. 

  4614.       if (tag == 0x1b) tag = 0x1018;
    4615. 

  4615.       if (tag == 0x1c) tag = 0x1017;
    4616. 

  4616.     }
    4617. 

  4617.     if (tag == 0x1d)
    4618. 

  4618.       while ((c = fgetc(ifp)) && c != EOF)
    4619. 

  4619. 	serial = serial*10 + (isdigit(c) ? c - '0' : c % 10);
    4620. 

  4620.     if (tag == 0x81 && type == 4) {
    4621. 

  4621.       data_offset = get4();
    4622. 

  4622.       fseek (ifp, data_offset + 41, SEEK_SET);
    4623. 

  4623.       raw_height = get2() * 2;
    4624. 

  4624.       raw_width  = get2();
    4625. 

  4625.       filters = 0x61616161;
    4626. 

  4626.     }
    4627. 

  4627.     if (tag == 0x29 && type == 1) {
    4628. 

  4628.       c = wbi < 18 ? "012347800000005896"[wbi]-'0' : 0;
    4629. 

  4629.       fseek (ifp, 8 + c*32, SEEK_CUR);
    4630. 

  4630.       FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get4();
    4631. 

  4631.     }
    4632. 

  4632.     if ((tag == 0x81  && type == 7) ||
    4633. 

  4633. 	(tag == 0x100 && type == 7) ||
    4634. 

  4634. 	(tag == 0x280 && type == 1)) {
    4635. 

  4635.       thumb_offset = ftell(ifp);
    4636. 

  4636.       thumb_length = len;
    4637. 

  4637.     }
    4638. 

  4638.     if (tag == 0x88 && type == 4 && (thumb_offset = get4()))
    4639. 

  4639.       thumb_offset += base;
    4640. 

  4640.     if (tag == 0x89 && type == 4)
    4641. 

  4641.       thumb_length = get4();
    4642. 

  4642.     if (tag == 0x8c || tag == 0x96)
    4643. 

  4643.       meta_offset = ftell(ifp);
    4644. 

  4644.     if (tag == 0x97) {
    4645. 

  4645.       for (i=0; i < 4; i++)
    4646. 

  4646. 	ver97 = ver97 * 10 + fgetc(ifp)-'0';
    4647. 

  4647.       switch (ver97) {
    4648. 

  4648. 	case 100:
    4649. 

  4649. 	  fseek (ifp, 68, SEEK_CUR);
    4650. 

  4650. 	  FORC4 cam_mul[(c >> 1) | ((c & 1) << 1)] = get2();
    4651. 

  4651. 	  break;
    4652. 

  4652. 	case 102:
    4653. 

  4653. 	  fseek (ifp, 6, SEEK_CUR);
    4654. 

  4654. 	  goto get2_rggb;
    4655. 

  4655. 	case 103:
    4656. 

  4656. 	  fseek (ifp, 16, SEEK_CUR);
    4657. 

  4657. 	  FORC4 cam_mul[c] = get2();
    4658. 

  4658.       }
    4659. 

  4659.       if (ver97 >= 200) {
    4660. 

  4660. 	if (ver97 != 205) fseek (ifp, 280, SEEK_CUR);
    4661. 

  4661. 	fread (buf97, 324, 1, ifp);
    4662. 

  4662.       }
    4663. 

  4663.     }
    4664. 

  4664.     if (tag == 0xa1 && type == 7) {
    4665. 

  4665.       order = 0x4949;
    4666. 

  4666.       fseek (ifp, 140, SEEK_CUR);
    4667. 

  4667.       FORC3 cam_mul[c] = get4();
    4668. 

  4668.     }
    4669. 

  4669.     if (tag == 0xa4 && type == 3) {
    4670. 

  4670.       fseek (ifp, wbi*48, SEEK_CUR);
    4671. 

  4671.       FORC3 cam_mul[c] = get2();
    4672. 

  4672.     }
    4673. 

  4673.     if (tag == 0xa7 && (unsigned) (ver97-200) < 17) {
    4674. 

  4674.       ci = xlat[0][serial & 0xff];
    4675. 

  4675.       cj = xlat[1][fgetc(ifp)^fgetc(ifp)^fgetc(ifp)^fgetc(ifp)];
    4676. 

  4676.       ck = 0x60;
    4677. 

  4677.       for (i=0; i < 324; i++)
    4678. 

  4678. 	buf97[i] ^= (cj += ci * ck++);
    4679. 

  4679.       i = "66666>666;6A;:;55"[ver97-200] - '0';
    4680. 

  4680.       FORC4 cam_mul[c ^ (c >> 1) ^ (i & 1)] =
    4681. 

  4681. 	sget2 (buf97 + (i & -2) + c*2);
    4682. 

  4682.     }
    4683. 

  4683.     if (tag == 0x200 && len == 3)
    4684. 

  4684.       shot_order = (get4(),get4());
    4685. 

  4685.     if (tag == 0x200 && len == 4)
    4686. 

  4686.       FORC4 cblack[c ^ c >> 1] = get2();
    4687. 

  4687.     if (tag == 0x201 && len == 4)
    4688. 

  4688.       goto get2_rggb;
    4689. 

  4689.     if (tag == 0x220 && type == 7)
    4690. 

  4690.       meta_offset = ftell(ifp);
    4691. 

  4691.     if (tag == 0x401 && type == 4 && len == 4)
    4692. 

  4692.       FORC4 cblack[c ^ c >> 1] = get4();
    4693. 

  4693.     if (tag == 0xe01) {		/* Nikon Capture Note */
    4694. 

  4694.       order = 0x4949;
    4695. 

  4695.       fseek (ifp, 22, SEEK_CUR);
    4696. 

  4696.       for (offset=22; offset+22 < len; offset += 22+i) {
    4697. 

  4697. 	tag = get4();
    4698. 

  4698. 	fseek (ifp, 14, SEEK_CUR);
    4699. 

  4699. 	i = get4()-4;
    4700. 

  4700. 	if (tag == 0x76a43207) flip = get2();
    4701. 

  4701. 	else fseek (ifp, i, SEEK_CUR);
    4702. 

  4702.       }
    4703. 

  4703.     }
    4704. 

  4704.     if (tag == 0xe80 && len == 256 && type == 7) {
    4705. 

  4705.       fseek (ifp, 48, SEEK_CUR);
    4706. 

  4706.       cam_mul[0] = get2() * 508 * 1.078 / 0x10000;
    4707. 

  4707.       cam_mul[2] = get2() * 382 * 1.173 / 0x10000;
    4708. 

  4708.     }
    4709. 

  4709.     if (tag == 0xf00 && type == 7) {
    4710. 

  4710.       if (len == 614)
    4711. 

  4711. 	fseek (ifp, 176, SEEK_CUR);
    4712. 

  4712.       else if (len == 734 || len == 1502)
    4713. 

  4713. 	fseek (ifp, 148, SEEK_CUR);
    4714. 

  4714.       else goto next;
    4715. 

  4715.       goto get2_256;
    4716. 

  4716.     }
    4717. 

  4717.     if ((tag == 0x1011 && len == 9) || tag == 0x20400200)
    4718. 

  4718.       for (i=0; i < 3; i++)
    4719. 

  4719. 	FORC3 cmatrix[i][c] = ((short) get2()) / 256.0;
    4720. 

  4720.     if ((tag == 0x1012 || tag == 0x20400600) && len == 4)
    4721. 

  4721.       FORC4 cblack[c ^ c >> 1] = get2();
    4722. 

  4722.     if (tag == 0x1017 || tag == 0x20400100)
    4723. 

  4723.       cam_mul[0] = get2() / 256.0;
    4724. 

  4724.     if (tag == 0x1018 || tag == 0x20400100)
    4725. 

  4725.       cam_mul[2] = get2() / 256.0;
    4726. 

  4726.     if (tag == 0x2011 && len == 2) {
    4727. 

  4727. get2_256:
    4728. 

  4728.       order = 0x4d4d;
    4729. 

  4729.       cam_mul[0] = get2() / 256.0;
    4730. 

  4730.       cam_mul[2] = get2() / 256.0;
    4731. 

  4731.     }
    4732. 

  4732.     if ((tag | 0x70) == 0x2070 && type == 4)
    4733. 

  4733.       fseek (ifp, get4()+base, SEEK_SET);
    4734. 

  4734.     if (tag == 0x2010 && type != 7)
    4735. 

  4735.       load_raw = &CLASS olympus_load_raw;
    4736. 

  4736.     if (tag == 0x2020)
    4737. 

  4737.       parse_thumb_note (base, 257, 258);
    4738. 

  4738.     if (tag == 0x2040)
    4739. 

  4739.       parse_makernote (base, 0x2040);
    4740. 

  4740.     if (tag == 0xb028) {
    4741. 

  4741.       fseek (ifp, get4()+base, SEEK_SET);
    4742. 

  4742.       parse_thumb_note (base, 136, 137);
    4743. 

  4743.     }
    4744. 

  4744.     if (tag == 0x4001 && len > 500) {
    4745. 

  4745.       i = len == 582 ? 50 : len == 653 ? 68 : len == 5120 ? 142 : 126;
    4746. 

  4746.       fseek (ifp, i, SEEK_CUR);
    4747. 

  4747. get2_rggb:
    4748. 

  4748.       FORC4 cam_mul[c ^ (c >> 1)] = get2();
    4749. 

  4749.       i = len >> 3 == 164 ? 112:22;
    4750. 

  4750.       fseek (ifp, i, SEEK_CUR);
    4751. 

  4751.       FORC4 sraw_mul[c ^ (c >> 1)] = get2();
    4752. 

  4752.     }
    4753. 

  4753.     if (tag == 0xa021)
    4754. 

  4754.       FORC4 cam_mul[c ^ (c >> 1)] = get4();
    4755. 

  4755.     if (tag == 0xa028)
    4756. 

  4756.       FORC4 cam_mul[c ^ (c >> 1)] -= get4();
    4757. 

  4757. next:
    4758. 

  4758.     fseek (ifp, save, SEEK_SET);
    4759. 

  4759.   }
    4760. 

  4760. quit:
    4761. 

  4761.   order = sorder;
    4762. 

  4762. }
    4763. 

  4763. 

  4764. /*
    4765. 

  4765.    Since the TIFF DateTime string has no timezone information,
    4766. 

  4766.    assume that the camera's clock was set to Universal Time.
    4767. 

  4767.  */
    4768. 

  4768. void CLASS get_timestamp (int reversed)
    4769. 

  4769. {
    4770. 

  4770.   struct tm t;
    4771. 

  4771.   char str[20];
    4772. 

  4772.   int i;
    4773. 

  4773. 

  4774.   str[19] = 0;
    4775. 

  4775.   if (reversed)
    4776. 

  4776.     for (i=19; i--; ) str[i] = fgetc(ifp);
    4777. 

  4777.   else
    4778. 

  4778.     fread (str, 19, 1, ifp);
    4779. 

  4779.   memset (&t, 0, sizeof t);
    4780. 

  4780.   if (sscanf (str, "%d:%d:%d %d:%d:%d", &t.tm_year, &t.tm_mon,
    4781. 

  4781. 	&t.tm_mday, &t.tm_hour, &t.tm_min, &t.tm_sec) != 6)
    4782. 

  4782.     return;
    4783. 

  4783.   t.tm_year -= 1900;
    4784. 

  4784.   t.tm_mon -= 1;
    4785. 

  4785.   t.tm_isdst = -1;
    4786. 

  4786.   if (mktime(&t) > 0)
    4787. 

  4787.     timestamp = mktime(&t);
    4788. 

  4788. }
    4789. 

  4789. 

  4790. void CLASS parse_exif (int base)
    4791. 

  4791. {
    4792. 

  4792.   unsigned kodak, entries, tag, type, len, save, c;
    4793. 

  4793.   double expo;
    4794. 

  4794. 

  4795.   kodak = !strncmp(make,"EASTMAN",7) && tiff_nifds < 3;
    4796. 

  4796.   entries = get2();
    4797. 

  4797.   while (entries--) {
    4798. 

  4798.     tiff_get (base, &tag, &type, &len, &save);
    4799. 

  4799.     switch (tag) {
    4800. 

  4800.       case 33434:  shutter = getreal(type);		break;
    4801. 

  4801.       case 33437:  aperture = getreal(type);		break;
    4802. 

  4802.       case 34855:  iso_speed = get2();			break;
    4803. 

  4803.       case 36867:
    4804. 

  4804.       case 36868:  get_timestamp(0);			break;
    4805. 

  4805.       case 37377:  if ((expo = -getreal(type)) < 128)
    4806. 

  4806. 		     shutter = pow (2.0, expo);		break;
    4807. 

  4807.       case 37378:  aperture = pow (2.0, getreal(type)/2);	break;
    4808. 

  4808.       case 37386:  focal_len = getreal(type);		break;
    4809. 

  4809.       case 37500:  parse_makernote (base, 0);		break;
    4810. 

  4810.       case 40962:  if (kodak) raw_width  = get4();	break;
    4811. 

  4811.       case 40963:  if (kodak) raw_height = get4();	break;
    4812. 

  4812.       case 41730:
    4813. 

  4813. 	if (get4() == 0x20002)
    4814. 

  4814. 	  for (exif_cfa=c=0; c < 8; c+=2)
    4815. 

  4815. 	    exif_cfa |= fgetc(ifp) * 0x01010101 << c;
    4816. 

  4816.     }
    4817. 

  4817.     fseek (ifp, save, SEEK_SET);
    4818. 

  4818.   }
    4819. 

  4819. }
    4820. 

  4820. 

  4821. void CLASS parse_gps (int base)
    4822. 

  4822. {
    4823. 

  4823.   unsigned entries, tag, type, len, save, c;
    4824. 

  4824. 

  4825.   entries = get2();
    4826. 

  4826.   while (entries--) {
    4827. 

  4827.     tiff_get (base, &tag, &type, &len, &save);
    4828. 

  4828.     switch (tag) {
    4829. 

  4829.       case 1: case 3: case 5:
    4830. 

  4830. 	gpsdata[29+tag/2] = getc(ifp);			break;
    4831. 

  4831.       case 2: case 4: case 7:
    4832. 

  4832. 	FORC(6) gpsdata[tag/3*6+c] = get4();		break;
    4833. 

  4833.       case 6:
    4834. 

  4834. 	FORC(2) gpsdata[18+c] = get4();			break;
    4835. 

  4835.       case 18: case 29:
    4836. 

  4836. 	fgets ((char *) (gpsdata+14+tag/3), MIN(len,12), ifp);
    4837. 

  4837.     }
    4838. 

  4838.     fseek (ifp, save, SEEK_SET);
    4839. 

  4839.   }
    4840. 

  4840. }
    4841. 

  4841. 

  4842. void CLASS romm_coeff (float romm_cam[3][3])
    4843. 

  4843. {
    4844. 

  4844.   static const float rgb_romm[3][3] =	/* ROMM == Kodak ProPhoto */
    4845. 

  4845.   { {  2.034193, -0.727420, -0.306766 },
    4846. 

  4846.     { -0.228811,  1.231729, -0.002922 },
    4847. 

  4847.     { -0.008565, -0.153273,  1.161839 } };
    4848. 

  4848.   int i, j, k;
    4849. 

  4849. 

  4850.   for (i=0; i < 3; i++)
    4851. 

  4851.     for (j=0; j < 3; j++)
    4852. 

  4852.       for (cmatrix[i][j] = k=0; k < 3; k++)
    4853. 

  4853. 	cmatrix[i][j] += rgb_romm[i][k] * romm_cam[k][j];
    4854. 

  4854. }
    4855. 

  4855. 

  4856. void CLASS parse_mos (int offset)
    4857. 

  4857. {
    4858. 

  4858.   char data[40];
    4859. 

  4859.   int skip, from, i, c, neut[4], planes=0, frot=0;
    4860. 

  4860.   static const char *mod[] =
    4861. 

  4861.   { "","DCB2","Volare","Cantare","CMost","Valeo 6","Valeo 11","Valeo 22",
    4862. 

  4862.     "Valeo 11p","Valeo 17","","Aptus 17","Aptus 22","Aptus 75","Aptus 65",
    4863. 

  4863.     "Aptus 54S","Aptus 65S","Aptus 75S","AFi 5","AFi 6","AFi 7",
    4864. 

  4864.     "","","","","","","","","","","","","","","","","","AFi-II 12" };
    4865. 

  4865.   float romm_cam[3][3];
    4866. 

  4866. 

  4867.   fseek (ifp, offset, SEEK_SET);
    4868. 

  4868.   while (1) {
    4869. 

  4869.     if (get4() != 0x504b5453) break;
    4870. 

  4870.     get4();
    4871. 

  4871.     fread (data, 1, 40, ifp);
    4872. 

  4872.     skip = get4();
    4873. 

  4873.     from = ftell(ifp);
    4874. 

  4874.     if (!strcmp(data,"JPEG_preview_data")) {
    4875. 

  4875.       thumb_offset = from;
    4876. 

  4876.       thumb_length = skip;
    4877. 

  4877.     }
    4878. 

  4878.     if (!strcmp(data,"icc_camera_profile")) {
    4879. 

  4879.       profile_offset = from;
    4880. 

  4880.       profile_length = skip;
    4881. 

  4881.     }
    4882. 

  4882.     if (!strcmp(data,"ShootObj_back_type")) {
    4883. 

  4883.       fscanf (ifp, "%d", &i);
    4884. 

  4884.       if ((unsigned) i < sizeof mod / sizeof (*mod))
    4885. 

  4885. 	strcpy (model, mod[i]);
    4886. 

  4886.     }
    4887. 

  4887.     if (!strcmp(data,"icc_camera_to_tone_matrix")) {
    4888. 

  4888.       for (i=0; i < 9; i++)
    4889. 

  4889. 	romm_cam[0][i] = int_to_float(get4());
    4890. 

  4890.       romm_coeff (romm_cam);
    4891. 

  4891.     }
    4892. 

  4892.     if (!strcmp(data,"CaptProf_color_matrix")) {
    4893. 

  4893.       for (i=0; i < 9; i++)
    4894. 

  4894. 	fscanf (ifp, "%f", &romm_cam[0][i]);
    4895. 

  4895.       romm_coeff (romm_cam);
    4896. 

  4896.     }
    4897. 

  4897.     if (!strcmp(data,"CaptProf_number_of_planes"))
    4898. 

  4898.       fscanf (ifp, "%d", &planes);
    4899. 

  4899.     if (!strcmp(data,"CaptProf_raw_data_rotation"))
    4900. 

  4900.       fscanf (ifp, "%d", &flip);
    4901. 

  4901.     if (!strcmp(data,"CaptProf_mosaic_pattern"))
    4902. 

  4902.       FORC4 {
    4903. 

  4903. 	fscanf (ifp, "%d", &i);
    4904. 

  4904. 	if (i == 1) frot = c ^ (c >> 1);
    4905. 

  4905.       }
    4906. 

  4906.     if (!strcmp(data,"ImgProf_rotation_angle")) {
    4907. 

  4907.       fscanf (ifp, "%d", &i);
    4908. 

  4908.       flip = i - flip;
    4909. 

  4909.     }
    4910. 

  4910.     if (!strcmp(data,"NeutObj_neutrals") && !cam_mul[0]) {
    4911. 

  4911.       FORC4 fscanf (ifp, "%d", neut+c);
    4912. 

  4912.       FORC3 cam_mul[c] = (float) neut[0] / neut[c+1];
    4913. 

  4913.     }
    4914. 

  4914.     if (!strcmp(data,"Rows_data"))
    4915. 

  4915.       load_flags = get4();
    4916. 

  4916.     parse_mos (from);
    4917. 

  4917.     fseek (ifp, skip+from, SEEK_SET);
    4918. 

  4918.   }
    4919. 

  4919.   if (planes)
    4920. 

  4920.     filters = (planes == 1) * 0x01010101 *
    4921. 

  4921. 	(uchar) "\x94\x61\x16\x49"[(flip/90 + frot) & 3];
    4922. 

  4922. }
    4923. 

  4923. 

  4924. void CLASS linear_table (unsigned len)
    4925. 

  4925. {
    4926. 

  4926.   int i;
    4927. 

  4927.   if (len > 0x1000) len = 0x1000;
    4928. 

  4928.   read_shorts (curve, len);
    4929. 

  4929.   for (i=len; i < 0x1000; i++)
    4930. 

  4930.     curve[i] = curve[i-1];
    4931. 

  4931.   maximum = curve[0xfff];
    4932. 

  4932. }
    4933. 

  4933. 

  4934. void CLASS parse_kodak_ifd (int base)
    4935. 

  4935. {
    4936. 

  4936.   unsigned entries, tag, type, len, save;
    4937. 

  4937.   int i, c, wbi=-2, wbtemp=6500;
    4938. 

  4938.   float mul[3]={1,1,1}, num;
    4939. 

  4939.   static const int wbtag[] = { 64037,64040,64039,64041,-1,-1,64042 };
    4940. 

  4940. 

  4941.   entries = get2();
    4942. 

  4942.   if (entries > 1024) return;
    4943. 

  4943.   while (entries--) {
    4944. 

  4944.     tiff_get (base, &tag, &type, &len, &save);
    4945. 

  4945.     if (tag == 1020) wbi = getint(type);
    4946. 

  4946.     if (tag == 1021 && len == 72) {		/* WB set in software */
    4947. 

  4947.       fseek (ifp, 40, SEEK_CUR);
    4948. 

  4948.       FORC3 cam_mul[c] = 2048.0 / get2();
    4949. 

  4949.       wbi = -2;
    4950. 

  4950.     }
    4951. 

  4951.     if (tag == 2118) wbtemp = getint(type);
    4952. 

  4952.     if (tag == 2130 + wbi)
    4953. 

  4953.       FORC3 mul[c] = getreal(type);
    4954. 

  4954.     if (tag == 2140 + wbi && wbi >= 0)
    4955. 

  4955.       FORC3 {
    4956. 

  4956. 	for (num=i=0; i < 4; i++)
    4957. 

  4957. 	  num += getreal(type) * pow (wbtemp/100.0, i);
    4958. 

  4958. 	cam_mul[c] = 2048 / (num * mul[c]);
    4959. 

  4959.       }
    4960. 

  4960.     if (tag == 2317) linear_table (len);
    4961. 

  4961.     if (tag == 6020) iso_speed = getint(type);
    4962. 

  4962.     if (tag == 64013) wbi = fgetc(ifp);
    4963. 

  4963.     if ((unsigned) wbi < 7 && tag == wbtag[wbi])
    4964. 

  4964.       FORC3 cam_mul[c] = get4();
    4965. 

  4965.     if (tag == 64019) width = getint(type);
    4966. 

  4966.     if (tag == 64020) height = (getint(type)+1) & -2;
    4967. 

  4967.     fseek (ifp, save, SEEK_SET);
    4968. 

  4968.   }
    4969. 

  4969. }
    4970. 

  4970. int CLASS parse_tiff_ifd (int base)
    4971. 

  4971. {
    4972. 

  4972.   unsigned entries, tag, type, len, plen=16, save;
    4973. 

  4973.   int ifd, use_cm=0, cfa, i, j, c, ima_len=0;
    4974. 

  4974.   int blrr=1, blrc=1, dblack[] = { 0,0,0,0 };
    4975. 

  4975.   char software[64], *cbuf, *cp;
    4976. 

  4976.   uchar cfa_pat[16], cfa_pc[] = { 0,1,2,3 }, tab[256];
    4977. 

  4977.   double cc[4][4], cm[4][3], cam_xyz[4][3], num;
    4978. 

  4978.   double ab[]={ 1,1,1,1 }, asn[] = { 0,0,0,0 }, xyz[] = { 1,1,1 };
    4979. 

  4979.   unsigned sony_curve[] = { 0,0,0,0,0,4095 };
    4980. 

  4980.   unsigned *buf, sony_offset=0, sony_length=0, sony_key=0;
    4981. 

  4981.   struct jhead jh;
    4982. 

  4982. #ifndef LIBRAW_LIBRARY_BUILD
    4983. 

  4983.   FILE *sfp;
    4984. 

  4984. #endif
    4985. 

  4985. 

  4986.   if (tiff_nifds >= sizeof tiff_ifd / sizeof tiff_ifd[0])
    4987. 

  4987.     return 1;
    4988. 

  4988.   ifd = tiff_nifds++;
    4989. 

  4989.   for (j=0; j < 4; j++)
    4990. 

  4990.     for (i=0; i < 4; i++)
    4991. 

  4991.       cc[j][i] = i == j;
    4992. 

  4992.   entries = get2();
    4993. 

  4993.   if (entries > 512) return 1;
    4994. 

  4994.   while (entries--) {
    4995. 

  4995.     tiff_get (base, &tag, &type, &len, &save);
    4996. 

  4996.     switch (tag) {
    4997. 

  4997.       case 5:   width  = get2();  break;
    4998. 

  4998.       case 6:   height = get2();  break;
    4999. 

  4999.       case 7:   width += get2();  break;
    5000. 

  5000.       case 9:  filters = get2();  break;
    5001. 

  5001.       case 17: case 18:
    5002. 

  5002. 	if (type == 3 && len == 1)
    5003. 

  5003. 	  cam_mul[(tag-17)*2] = get2() / 256.0;
    5004. 

  5004. 	break;
    5005. 

  5005.       case 23:
    5006. 

  5006. 	if (type == 3) iso_speed = get2();
    5007. 

  5007. 	break;
    5008. 

  5008.       case 36: case 37: case 38:
    5009. 

  5009. 	cam_mul[tag-0x24] = get2();
    5010. 

  5010. 	break;
    5011. 

  5011.       case 39:
    5012. 

  5012. 	if (len < 50 || cam_mul[0]) break;
    5013. 

  5013. 	fseek (ifp, 12, SEEK_CUR);
    5014. 

  5014. 	FORC3 cam_mul[c] = get2();
    5015. 

  5015. 	break;
    5016. 

  5016.       case 46:
    5017. 

  5017. 	if (type != 7 || fgetc(ifp) != 0xff || fgetc(ifp) != 0xd8) break;
    5018. 

  5018. 	thumb_offset = ftell(ifp) - 2;
    5019. 

  5019. 	thumb_length = len;
    5020. 

  5020. 	break;
    5021. 

  5021.       case 61440:			/* Fuji HS10 table */
    5022. 

  5022. 	parse_tiff_ifd (base);
    5023. 

  5023. 	break;
    5024. 

  5024.       case 2: case 256: case 61441:	/* ImageWidth */
    5025. 

  5025. 	tiff_ifd[ifd].t_width = getint(type);
    5026. 

  5026. 	break;
    5027. 

  5027.       case 3: case 257: case 61442:	/* ImageHeight */
    5028. 

  5028. 	tiff_ifd[ifd].t_height = getint(type);
    5029. 

  5029. 	break;
    5030. 

  5030.       case 258:				/* BitsPerSample */
    5031. 

  5031.       case 61443:
    5032. 

  5032. 	tiff_ifd[ifd].samples = len & 7;
    5033. 

  5033. 	tiff_ifd[ifd].bps = getint(type);
    5034. 

  5034. 	break;
    5035. 

  5035.       case 61446:
    5036. 

  5036. 	raw_height = 0;
    5037. 

  5037. 	load_raw = &CLASS packed_load_raw;
    5038. 

  5038. 	load_flags = get4() && (filters=0x16161616) ? 24:80;
    5039. 

  5039. 	break;
    5040. 

  5040.       case 259:				/* Compression */
    5041. 

  5041. 	tiff_ifd[ifd].comp = getint(type);
    5042. 

  5042. 	break;
    5043. 

  5043.       case 262:				/* PhotometricInterpretation */
    5044. 

  5044. 	tiff_ifd[ifd].phint = get2();
    5045. 

  5045. 	break;
    5046. 

  5046.       case 270:				/* ImageDescription */
    5047. 

  5047. 	fread (desc, 512, 1, ifp);
    5048. 

  5048. 	break;
    5049. 

  5049.       case 271:				/* Make */
    5050. 

  5050. 	fgets (make, 64, ifp);
    5051. 

  5051. 	break;
    5052. 

  5052.       case 272:				/* Model */
    5053. 

  5053. 	fgets (model, 64, ifp);
    5054. 

  5054. 	break;
    5055. 

  5055.       case 280:				/* Panasonic RW2 offset */
    5056. 

  5056. 	if (type != 4) break;
    5057. 

  5057. 	load_raw = &CLASS panasonic_load_raw;
    5058. 

  5058. 	load_flags = 0x2008;
    5059. 

  5059.       case 273:				/* StripOffset */
    5060. 

  5060.       case 513:				/* JpegIFOffset */
    5061. 

  5061.       case 61447:
    5062. 

  5062. 	tiff_ifd[ifd].offset = get4()+base;
    5063. 

  5063. 	if (!tiff_ifd[ifd].bps && tiff_ifd[ifd].offset > 0) {
    5064. 

  5064. 	  fseek (ifp, tiff_ifd[ifd].offset, SEEK_SET);
    5065. 

  5065. 	  if (ljpeg_start (&jh, 1)) {
    5066. 

  5066. 	    tiff_ifd[ifd].comp    = 6;
    5067. 

  5067. 	    tiff_ifd[ifd].t_width   = jh.wide;
    5068. 

  5068. 	    tiff_ifd[ifd].t_height  = jh.high;
    5069. 

  5069. 	    tiff_ifd[ifd].bps     = jh.bits;
    5070. 

  5070. 	    tiff_ifd[ifd].samples = jh.clrs;
    5071. 

  5071. 	    if (!(jh.sraw || (jh.clrs & 1)))
    5072. 

  5072. 	      tiff_ifd[ifd].t_width *= jh.clrs;
    5073. 

  5073. 	    i = order;
    5074. 

  5074. 	    parse_tiff (tiff_ifd[ifd].offset + 12);
    5075. 

  5075. 	    order = i;
    5076. 

  5076. 	  }
    5077. 

  5077. 	}
    5078. 

  5078. 	break;
    5079. 

  5079.       case 274:				/* Orientation */
    5080. 

  5080. 	tiff_ifd[ifd].t_flip = "50132467"[get2() & 7]-'0';
    5081. 

  5081. 	break;
    5082. 

  5082.       case 277:				/* SamplesPerPixel */
    5083. 

  5083. 	tiff_ifd[ifd].samples = getint(type) & 7;
    5084. 

  5084. 	break;
    5085. 

  5085.       case 279:				/* StripByteCounts */
    5086. 

  5086.       case 514:
    5087. 

  5087.       case 61448:
    5088. 

  5088. 	tiff_ifd[ifd].bytes = get4();
    5089. 

  5089. 	break;
    5090. 

  5090.       case 61454:
    5091. 

  5091. 	FORC3 cam_mul[(4-c) % 3] = getint(type);
    5092. 

  5092. 	break;
    5093. 

  5093.       case 305:  case 11:		/* Software */
    5094. 

  5094. 	fgets (software, 64, ifp);
    5095. 

  5095. 	if (!strncmp(software,"Adobe",5) ||
    5096. 

  5096. 	    !strncmp(software,"dcraw",5) ||
    5097. 

  5097. 	    !strncmp(software,"UFRaw",5) ||
    5098. 

  5098. 	    !strncmp(software,"Bibble",6) ||
    5099. 

  5099. 	    !strncmp(software,"Nikon Scan",10) ||
    5100. 

  5100. 	    !strcmp (software,"Digital Photo Professional"))
    5101. 

  5101. 	  is_raw = 0;
    5102. 

  5102. 	break;
    5103. 

  5103.       case 306:				/* DateTime */
    5104. 

  5104. 	get_timestamp(0);
    5105. 

  5105. 	break;
    5106. 

  5106.       case 315:				/* Artist */
    5107. 

  5107. 	fread (artist, 64, 1, ifp);
    5108. 

  5108. 	break;
    5109. 

  5109.       case 322:				/* TileWidth */
    5110. 

  5110. 	tiff_ifd[ifd].t_tile_width = getint(type);
    5111. 

  5111. 	break;
    5112. 

  5112.       case 323:				/* TileLength */
    5113. 

  5113. 	tiff_ifd[ifd].t_tile_length = getint(type);
    5114. 

  5114. 	break;
    5115. 

  5115.       case 324:				/* TileOffsets */
    5116. 

  5116. 	tiff_ifd[ifd].offset = len > 1 ? ftell(ifp) : get4();
    5117. 

  5117. 	if (len == 4) {
    5118. 

  5118. 	  load_raw = &CLASS sinar_4shot_load_raw;
    5119. 

  5119. 	  is_raw = 5;
    5120. 

  5120. 	}
    5121. 

  5121. 	break;
    5122. 

  5122. #ifdef LIBRAW_LIBRARY_BUILD
    5123. 

  5123.       case 325:				/* TileByteCount */
    5124. 

  5124.           tiff_ifd[ifd].tile_maxbytes = 0;
    5125. 

  5125.           for(int jj=0;jj<len;jj++)
    5126. 

  5126.               {
    5127. 

  5127.                   int s = get4();
    5128. 

  5128.                   if(s > tiff_ifd[ifd].tile_maxbytes) tiff_ifd[ifd].tile_maxbytes=s;
    5129. 

  5129.               }
    5130. 

  5130. 	break;
    5131. 

  5131. #endif
    5132. 

  5132.       case 330:				/* SubIFDs */
    5133. 

  5133. 	if (!strcmp(model,"DSLR-A100") && tiff_ifd[ifd].t_width == 3872) {
    5134. 

  5134. 	  load_raw = &CLASS sony_arw_load_raw;
    5135. 

  5135. 	  data_offset = get4()+base;
    5136. 

  5136. 	  ifd++;  break;
    5137. 

  5137. 	}
    5138. 

  5138. 	while (len--) {
    5139. 

  5139. 	  i = ftell(ifp);
    5140. 

  5140. 	  fseek (ifp, get4()+base, SEEK_SET);
    5141. 

  5141. 	  if (parse_tiff_ifd (base)) break;
    5142. 

  5142. 	  fseek (ifp, i+4, SEEK_SET);
    5143. 

  5143. 	}
    5144. 

  5144. 	break;
    5145. 

  5145.       case 400:
    5146. 

  5146. 	strcpy (make, "Sarnoff");
    5147. 

  5147. 	maximum = 0xfff;
    5148. 

  5148. 	break;
    5149. 

  5149.       case 28688:
    5150. 

  5150. 	FORC4 sony_curve[c+1] = get2() >> 2 & 0xfff;
    5151. 

  5151. 	for (i=0; i < 5; i++)
    5152. 

  5152. 	  for (j = sony_curve[i]+1; j <= sony_curve[i+1]; j++)
    5153. 

  5153. 	    curve[j] = curve[j-1] + (1 << i);
    5154. 

  5154. 	break;
    5155. 

  5155.       case 29184: sony_offset = get4();  break;
    5156. 

  5156.       case 29185: sony_length = get4();  break;
    5157. 

  5157.       case 29217: sony_key    = get4();  break;
    5158. 

  5158.       case 29264:
    5159. 

  5159. 	parse_minolta (ftell(ifp));
    5160. 

  5160. 	raw_width = 0;
    5161. 

  5161. 	break;
    5162. 

  5162.       case 29443:
    5163. 

  5163. 	FORC4 cam_mul[c ^ (c < 2)] = get2();
    5164. 

  5164. 	break;
    5165. 

  5165.       case 29459:
    5166. 

  5166. 	FORC4 cam_mul[c] = get2();
    5167. 

  5167. 	i = (cam_mul[1] == 1024 && cam_mul[2] == 1024) << 1;
    5168. 

  5168. 	SWAP (cam_mul[i],cam_mul[i+1])
    5169. 

  5169. 	break;
    5170. 

  5170.       case 33405:			/* Model2 */
    5171. 

  5171. 	fgets (model2, 64, ifp);
    5172. 

  5172. 	break;
    5173. 

  5173.       case 33422:			/* CFAPattern */
    5174. 

  5174.       case 64777:			/* Kodak P-series */
    5175. 

  5175. 	if ((plen=len) > 16) plen = 16;
    5176. 

  5176. 	fread (cfa_pat, 1, plen, ifp);
    5177. 

  5177. 	for (colors=cfa=i=0; i < plen; i++) {
    5178. 

  5178. 	  colors += !(cfa & (1 << cfa_pat[i]));
    5179. 

  5179. 	  cfa |= 1 << cfa_pat[i];
    5180. 

  5180. 	}
    5181. 

  5181. 	if (cfa == 070) memcpy (cfa_pc,"\003\004\005",3);	/* CMY */
    5182. 

  5182. 	if (cfa == 072) memcpy (cfa_pc,"\005\003\004\001",4);	/* GMCY */
    5183. 

  5183. 	goto guess_cfa_pc;
    5184. 

  5184.       case 33424:
    5185. 

  5185.       case 65024:
    5186. 

  5186. 	fseek (ifp, get4()+base, SEEK_SET);
    5187. 

  5187. 	parse_kodak_ifd (base);
    5188. 

  5188. 	break;
    5189. 

  5189.       case 33434:			/* ExposureTime */
    5190. 

  5190. 	shutter = getreal(type);
    5191. 

  5191. 	break;
    5192. 

  5192.       case 33437:			/* FNumber */
    5193. 

  5193. 	aperture = getreal(type);
    5194. 

  5194. 	break;
    5195. 

  5195.       case 34306:			/* Leaf white balance */
    5196. 

  5196. 	FORC4 cam_mul[c ^ 1] = 4096.0 / get2();
    5197. 

  5197. 	break;
    5198. 

  5198.       case 34307:			/* Leaf CatchLight color matrix */
    5199. 

  5199. 	fread (software, 1, 7, ifp);
    5200. 

  5200. 	if (strncmp(software,"MATRIX",6)) break;
    5201. 

  5201. 	colors = 4;
    5202. 

  5202. 	for (raw_color = i=0; i < 3; i++) {
    5203. 

  5203. 	  FORC4 fscanf (ifp, "%f", &rgb_cam[i][c^1]);
    5204. 

  5204. 	  if (!use_camera_wb) continue;
    5205. 

  5205. 	  num = 0;
    5206. 

  5206. 	  FORC4 num += rgb_cam[i][c];
    5207. 

  5207. 	  FORC4 rgb_cam[i][c] /= num;
    5208. 

  5208. 	}
    5209. 

  5209. 	break;
    5210. 

  5210.       case 34310:			/* Leaf metadata */
    5211. 

  5211. 	parse_mos (ftell(ifp));
    5212. 

  5212.       case 34303:
    5213. 

  5213. 	strcpy (make, "Leaf");
    5214. 

  5214. 	break;
    5215. 

  5215.       case 34665:			/* EXIF tag */
    5216. 

  5216. 	fseek (ifp, get4()+base, SEEK_SET);
    5217. 

  5217. 	parse_exif (base);
    5218. 

  5218. 	break;
    5219. 

  5219.       case 34853:			/* GPSInfo tag */
    5220. 

  5220. 	fseek (ifp, get4()+base, SEEK_SET);
    5221. 

  5221. 	parse_gps (base);
    5222. 

  5222. 	break;
    5223. 

  5223.       case 34675:			/* InterColorProfile */
    5224. 

  5224.       case 50831:			/* AsShotICCProfile */
    5225. 

  5225. 	profile_offset = ftell(ifp);
    5226. 

  5226. 	profile_length = len;
    5227. 

  5227. 	break;
    5228. 

  5228.       case 37122:			/* CompressedBitsPerPixel */
    5229. 

  5229. 	kodak_cbpp = get4();
    5230. 

  5230. 	break;
    5231. 

  5231.       case 37386:			/* FocalLength */
    5232. 

  5232. 	focal_len = getreal(type);
    5233. 

  5233. 	break;
    5234. 

  5234.       case 37393:			/* ImageNumber */
    5235. 

  5235. 	shot_order = getint(type);
    5236. 

  5236. 	break;
    5237. 

  5237.       case 37400:			/* old Kodak KDC tag */
    5238. 

  5238. 	for (raw_color = i=0; i < 3; i++) {
    5239. 

  5239. 	  getreal(type);
    5240. 

  5240. 	  FORC3 rgb_cam[i][c] = getreal(type);
    5241. 

  5241. 	}
    5242. 

  5242. 	break;
    5243. 

  5243.       case 46275:			/* Imacon tags */
    5244. 

  5244. 	strcpy (make, "Imacon");
    5245. 

  5245. 	data_offset = ftell(ifp);
    5246. 

  5246. 	ima_len = len;
    5247. 

  5247. 	break;
    5248. 

  5248.       case 46279:
    5249. 

  5249. 	if (!ima_len) break;
    5250. 

  5250. 	fseek (ifp, 38, SEEK_CUR);
    5251. 

  5251.       case 46274:
    5252. 

  5252. 	fseek (ifp, 40, SEEK_CUR);
    5253. 

  5253. 	raw_width  = get4();
    5254. 

  5254. 	raw_height = get4();
    5255. 

  5255. 	left_margin = get4() & 7;
    5256. 

  5256. 	width = raw_width - left_margin - (get4() & 7);
    5257. 

  5257. 	top_margin = get4() & 7;
    5258. 

  5258. 	height = raw_height - top_margin - (get4() & 7);
    5259. 

  5259. 	if (raw_width == 7262 && ima_len == 234317952 ) {
    5260. 

  5260. 	  height = 5412;
    5261. 

  5261. 	  width  = 7216;
    5262. 

  5262. 	  left_margin = 7;
    5263. 

  5263.           filters=0;
    5264. 

  5264. 	} else 	if (raw_width == 7262) {
    5265. 

  5265. 	  height = 5444;
    5266. 

  5266. 	  width  = 7244;
    5267. 

  5267. 	  left_margin = 7;
    5268. 

  5268. 	}
    5269. 

  5269. 	fseek (ifp, 52, SEEK_CUR);
    5270. 

  5270. 	FORC3 cam_mul[c] = getreal(11);
    5271. 

  5271. 	fseek (ifp, 114, SEEK_CUR);
    5272. 

  5272. 	flip = (get2() >> 7) * 90;
    5273. 

  5273. 	if (width * height * 6 == ima_len) {
    5274. 

  5274. 	  if (flip % 180 == 90) SWAP(width,height);
    5275. 

  5275. 	  raw_width = width;
    5276. 

  5276. 	  raw_height = height;
    5277. 

  5277. 	  left_margin = top_margin = filters = flip = 0;
    5278. 

  5278. 	}
    5279. 

  5279. 	sprintf (model, "Ixpress %d-Mp", height*width/1000000);
    5280. 

  5280. 	load_raw = &CLASS imacon_full_load_raw;
    5281. 

  5281. 	if (filters) {
    5282. 

  5282. 	  if (left_margin & 1) filters = 0x61616161;
    5283. 

  5283. 	  load_raw = &CLASS unpacked_load_raw;
    5284. 

  5284. 	}
    5285. 

  5285. 	maximum = 0xffff;
    5286. 

  5286. 	break;
    5287. 

  5287.       case 50454:			/* Sinar tag */
    5288. 

  5288.       case 50455:
    5289. 

  5289. 	if (!(cbuf = (char *) malloc(len))) break;
    5290. 

  5290. 	fread (cbuf, 1, len, ifp);
    5291. 

  5291. 	for (cp = cbuf-1; cp && cp < cbuf+len; cp = strchr(cp,'\n'))
    5292. 

  5292. 	  if (!strncmp (++cp,"Neutral ",8))
    5293. 

  5293. 	    sscanf (cp+8, "%f %f %f", cam_mul, cam_mul+1, cam_mul+2);
    5294. 

  5294. 	free (cbuf);
    5295. 

  5295. 	break;
    5296. 

  5296.       case 50458:
    5297. 

  5297. 	if (!make[0]) strcpy (make, "Hasselblad");
    5298. 

  5298. 	break;
    5299. 

  5299.       case 50459:			/* Hasselblad tag */
    5300. 

  5300. 	i = order;
    5301. 

  5301. 	j = ftell(ifp);
    5302. 

  5302. 	c = tiff_nifds;
    5303. 

  5303. 	order = get2();
    5304. 

  5304. 	fseek (ifp, j+(get2(),get4()), SEEK_SET);
    5305. 

  5305. 	parse_tiff_ifd (j);
    5306. 

  5306. 	maximum = 0xffff;
    5307. 

  5307. 	tiff_nifds = c;
    5308. 

  5308. 	order = i;
    5309. 

  5309. 	break;
    5310. 

  5310.       case 50706:			/* DNGVersion */
    5311. 

  5311. 	FORC4 dng_version = (dng_version << 8) + fgetc(ifp);
    5312. 

  5312. 	if (!make[0]) strcpy (make, "DNG");
    5313. 

  5313. 	is_raw = 1;
    5314. 

  5314. 	break;
    5315. 

  5315.       case 50710:			/* CFAPlaneColor */
    5316. 

  5316. 	if (len > 4) len = 4;
    5317. 

  5317. 	colors = len;
    5318. 

  5318. 	fread (cfa_pc, 1, colors, ifp);
    5319. 

  5319. guess_cfa_pc:
    5320. 

  5320. 	FORCC tab[cfa_pc[c]] = c;
    5321. 

  5321. 	cdesc[c] = 0;
    5322. 

  5322. 	for (i=16; i--; )
    5323. 

  5323. 	  filters = filters << 2 | tab[cfa_pat[i % plen]];
    5324. 

  5324. 	break;
    5325. 

  5325.       case 50711:			/* CFALayout */
    5326. 

  5326. 	if (get2() == 2) {
    5327. 

  5327. 	  fuji_width = 1;
    5328. 

  5328. 	  filters = 0x49494949;
    5329. 

  5329. 	}
    5330. 

  5330. 	break;
    5331. 

  5331.       case 291:
    5332. 

  5332.       case 50712:			/* LinearizationTable */
    5333. 

  5333. 	linear_table (len);
    5334. 

  5334. 	break;
    5335. 

  5335.       case 50713:			/* BlackLevelRepeatDim */
    5336. 

  5336. 	blrr = get2();
    5337. 

  5337. 	blrc = get2();
    5338. 

  5338. 	break;
    5339. 

  5339.       case 61450:
    5340. 

  5340. 	blrr = blrc = 2;
    5341. 

  5341.       case 50714:			/* BlackLevel */
    5342. 

  5342. 	black = getreal(type);
    5343. 

  5343. 	if (!filters || !~filters) break;
    5344. 

  5344. 	dblack[0] = black;
    5345. 

  5345. 	dblack[1] = (blrc == 2) ? getreal(type):dblack[0];
    5346. 

  5346. 	dblack[2] = (blrr == 2) ? getreal(type):dblack[0];
    5347. 

  5347. 	dblack[3] = (blrc == 2 && blrr == 2) ? getreal(type):dblack[1];
    5348. 

  5348. 	if (colors == 3)
    5349. 

  5349. 	  filters |= ((filters >> 2 & 0x22222222) |
    5350. 

  5350. 		      (filters << 2 & 0x88888888)) & filters << 1;
    5351. 

  5351. 	FORC4 cblack[filters >> (c << 1) & 3] = dblack[c];
    5352. 

  5352. 	black = 0;
    5353. 

  5353. 	break;
    5354. 

  5354.       case 50715:			/* BlackLevelDeltaH */
    5355. 

  5355.       case 50716:			/* BlackLevelDeltaV */
    5356. 

  5356. 	for (num=i=0; i < len; i++)
    5357. 

  5357. 	  num += getreal(type);
    5358. 

  5358. 	black += num/len + 0.5;
    5359. 

  5359. 	break;
    5360. 

  5360.       case 50717:			/* WhiteLevel */
    5361. 

  5361. 	maximum = getint(type);
    5362. 

  5362. 	break;
    5363. 

  5363.       case 50718:			/* DefaultScale */
    5364. 

  5364. 	pixel_aspect  = getreal(type);
    5365. 

  5365. 	pixel_aspect /= getreal(type);
    5366. 

  5366. 	break;
    5367. 

  5367.       case 50721:			/* ColorMatrix1 */
    5368. 

  5368.       case 50722:			/* ColorMatrix2 */
    5369. 

  5369. 	FORCC for (j=0; j < 3; j++)
    5370. 

  5370. 	  cm[c][j] = getreal(type);
    5371. 

  5371. 	use_cm = 1;
    5372. 

  5372. 	break;
    5373. 

  5373.       case 50723:			/* CameraCalibration1 */
    5374. 

  5374.       case 50724:			/* CameraCalibration2 */
    5375. 

  5375. 	for (i=0; i < colors; i++)
    5376. 

  5376. 	  FORCC cc[i][c] = getreal(type);
    5377. 

  5377. 	break;
    5378. 

  5378.       case 50727:			/* AnalogBalance */
    5379. 

  5379. 	FORCC ab[c] = getreal(type);
    5380. 

  5380. 	break;
    5381. 

  5381.       case 50728:			/* AsShotNeutral */
    5382. 

  5382. 	FORCC asn[c] = getreal(type);
    5383. 

  5383. 	break;
    5384. 

  5384.       case 50729:			/* AsShotWhiteXY */
    5385. 

  5385. 	xyz[0] = getreal(type);
    5386. 

  5386. 	xyz[1] = getreal(type);
    5387. 

  5387. 	xyz[2] = 1 - xyz[0] - xyz[1];
    5388. 

  5388. 	FORC3 xyz[c] /= d65_white[c];
    5389. 

  5389. 	break;
    5390. 

  5390.       case 50740:			/* DNGPrivateData */
    5391. 

  5391. 	if (dng_version) break;
    5392. 

  5392. 	parse_minolta (j = get4()+base);
    5393. 

  5393. 	fseek (ifp, j, SEEK_SET);
    5394. 

  5394. 	parse_tiff_ifd (base);
    5395. 

  5395. 	break;
    5396. 

  5396.       case 50752:
    5397. 

  5397. 	read_shorts (cr2_slice, 3);
    5398. 

  5398. 	break;
    5399. 

  5399.       case 50829:			/* ActiveArea */
    5400. 

  5400. 	top_margin = getint(type);
    5401. 

  5401. 	left_margin = getint(type);
    5402. 

  5402. 	height = getint(type) - top_margin;
    5403. 

  5403. 	width = getint(type) - left_margin;
    5404. 

  5404. 	break;
    5405. 

  5405.       case 50830:			/* MaskedAreas */
    5406. 

  5406.         for (i=0; i < len && i < 32; i++)
    5407. 

  5407. 	  mask[0][i] = getint(type);
    5408. 

  5408. 	black = 0;
    5409. 

  5409. 	break;
    5410. 

  5410.       case 51009:			/* OpcodeList2 */
    5411. 

  5411. 	meta_offset = ftell(ifp);
    5412. 

  5412. 	break;
    5413. 

  5413.       case 64772:			/* Kodak P-series */
    5414. 

  5414. 	if (len < 13) break;
    5415. 

  5415. 	fseek (ifp, 16, SEEK_CUR);
    5416. 

  5416. 	data_offset = get4();
    5417. 

  5417. 	fseek (ifp, 28, SEEK_CUR);
    5418. 

  5418. 	data_offset += get4();
    5419. 

  5419. 	load_raw = &CLASS packed_load_raw;
    5420. 

  5420. 	break;
    5421. 

  5421.       case 65026:
    5422. 

  5422. 	if (type == 2) fgets (model2, 64, ifp);
    5423. 

  5423.     }
    5424. 

  5424.     fseek (ifp, save, SEEK_SET);
    5425. 

  5425.   }
    5426. 

  5426.   if (sony_length && (buf = (unsigned *) malloc(sony_length))) {
    5427. 

  5427.     fseek (ifp, sony_offset, SEEK_SET);
    5428. 

  5428.     fread (buf, sony_length, 1, ifp);
    5429. 

  5429.     sony_decrypt (buf, sony_length/4, 1, sony_key);
    5430. 

  5430. #ifndef LIBRAW_LIBRARY_BUILD
    5431. 

  5431.     sfp = ifp;
    5432. 

  5432.     if ((ifp = tmpfile())) {
    5433. 

  5433.       fwrite (buf, sony_length, 1, ifp);
    5434. 

  5434.       fseek (ifp, 0, SEEK_SET);
    5435. 

  5435.       parse_tiff_ifd (-sony_offset);
    5436. 

  5436.       fclose (ifp);
    5437. 

  5437.     }
    5438. 

  5438.     ifp = sfp;
    5439. 

  5439. #else
    5440. 

  5440.     if( !ifp->tempbuffer_open(buf,sony_length))
    5441. 

  5441.         {
    5442. 

  5442.             parse_tiff_ifd(-sony_offset);
    5443. 

  5443.             ifp->tempbuffer_close();
    5444. 

  5444.         }
    5445. 

  5445. #endif
    5446. 

  5446.     free (buf);
    5447. 

  5447.   }
    5448. 

  5448.   for (i=0; i < colors; i++)
    5449. 

  5449.     FORCC cc[i][c] *= ab[i];
    5450. 

  5450.   if (use_cm) {
    5451. 

  5451.     FORCC for (i=0; i < 3; i++)
    5452. 

  5452.       for (cam_xyz[c][i]=j=0; j < colors; j++)
    5453. 

  5453. 	cam_xyz[c][i] += cc[c][j] * cm[j][i] * xyz[i];
    5454. 

  5454.     cam_xyz_coeff (cam_xyz);
    5455. 

  5455.   }
    5456. 

  5456.   if (asn[0]) {
    5457. 

  5457.     cam_mul[3] = 0;
    5458. 

  5458.     FORCC cam_mul[c] = 1 / asn[c];
    5459. 

  5459.   }
    5460. 

  5460.   if (!use_cm)
    5461. 

  5461.     FORCC pre_mul[c] /= cc[c][c];
    5462. 

  5462.   return 0;
    5463. 

  5463. }
    5464. 

  5464. 

  5465. int CLASS parse_tiff (int base)
    5466. 

  5466. {
    5467. 

  5467.   int doff;
    5468. 

  5468. 

  5469.   fseek (ifp, base, SEEK_SET);
    5470. 

  5470.   order = get2();
    5471. 

  5471.   if (order != 0x4949 && order != 0x4d4d) return 0;
    5472. 

  5472.   get2();
    5473. 

  5473.   while ((doff = get4())) {
    5474. 

  5474.     fseek (ifp, doff+base, SEEK_SET);
    5475. 

  5475.     if (parse_tiff_ifd (base)) break;
    5476. 

  5476.   }
    5477. 

  5477.   return 1;
    5478. 

  5478. }
    5479. 

  5479. 

  5480. void CLASS apply_tiff()
    5481. 

  5481. {
    5482. 

  5482.   int max_samp=0, raw=-1, thm=-1, i;
    5483. 

  5483.   struct jhead jh;
    5484. 

  5484. 

  5485.   thumb_misc = 16;
    5486. 

  5486.   if (thumb_offset) {
    5487. 

  5487.     fseek (ifp, thumb_offset, SEEK_SET);
    5488. 

  5488.     if (ljpeg_start (&jh, 1)) {
    5489. 

  5489.       thumb_misc   = jh.bits;
    5490. 

  5490.       thumb_width  = jh.wide;
    5491. 

  5491.       thumb_height = jh.high;
    5492. 

  5492.     }
    5493. 

  5493.   }
    5494. 

  5494.   for (i=0; i < tiff_nifds; i++) {
    5495. 

  5495.     if (max_samp < tiff_ifd[i].samples)
    5496. 

  5496. 	max_samp = tiff_ifd[i].samples;
    5497. 

  5497.     if (max_samp > 3) max_samp = 3;
    5498. 

  5498.     if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3) &&
    5499. 

  5499. 	(tiff_ifd[i].t_width | tiff_ifd[i].t_height) < 0x10000 &&
    5500. 

  5500. 	tiff_ifd[i].t_width*tiff_ifd[i].t_height > raw_width*raw_height) {
    5501. 

  5501.       raw_width     = tiff_ifd[i].t_width;
    5502. 

  5502.       raw_height    = tiff_ifd[i].t_height;
    5503. 

  5503.       tiff_bps      = tiff_ifd[i].bps;
    5504. 

  5504.       tiff_compress = tiff_ifd[i].comp;
    5505. 

  5505.       data_offset   = tiff_ifd[i].offset;
    5506. 

  5506.       tiff_flip     = tiff_ifd[i].t_flip;
    5507. 

  5507.       tiff_samples  = tiff_ifd[i].samples;
    5508. 

  5508.       tile_width    = tiff_ifd[i].t_tile_width;
    5509. 

  5509.       tile_length   = tiff_ifd[i].t_tile_length;
    5510. 

  5510. #ifdef LIBRAW_LIBRARY_BUILD
    5511. 

  5511.       data_size     = tile_length < INT_MAX && tile_length>0 ? tiff_ifd[i].tile_maxbytes: tiff_ifd[i].bytes;
    5512. 

  5512. #endif
    5513. 

  5513.       raw = i;
    5514. 

  5514.     }
    5515. 

  5515.   }
    5516. 

  5516.   if (!tile_width ) tile_width  = INT_MAX;
    5517. 

  5517.   if (!tile_length) tile_length = INT_MAX;
    5518. 

  5518.   for (i=tiff_nifds; i--; )
    5519. 

  5519.     if (tiff_ifd[i].t_flip) tiff_flip = tiff_ifd[i].t_flip;
    5520. 

  5520.   if (raw >= 0 && !load_raw)
    5521. 

  5521.     switch (tiff_compress) {
    5522. 

  5522.       case 32767:
    5523. 

  5523. 	if (tiff_ifd[raw].bytes == raw_width*raw_height) {
    5524. 

  5524. 	  tiff_bps = 12;
    5525. 

  5525. 	  load_raw = &CLASS sony_arw2_load_raw;			break;
    5526. 

  5526. 	}
    5527. 

  5527. 	if (tiff_ifd[raw].bytes*8 != raw_width*raw_height*tiff_bps) {
    5528. 

  5528. 	  raw_height += 8;
    5529. 

  5529. 	  load_raw = &CLASS sony_arw_load_raw;			break;
    5530. 

  5530. 	}
    5531. 

  5531. 	load_flags = 79;
    5532. 

  5532.       case 32769:
    5533. 

  5533. 	load_flags++;
    5534. 

  5534.       case 32770:
    5535. 

  5535.       case 32773: goto slr;
    5536. 

  5536.       case 0:  case 1:
    5537. 

  5537. 	if (tiff_ifd[raw].bytes*5 == raw_width*raw_height*8) {
    5538. 

  5538. 	  load_flags = 81;
    5539. 

  5539. 	  tiff_bps = 12;
    5540. 

  5540. 	} slr:
    5541. 

  5541. 	switch (tiff_bps) {
    5542. 

  5542. 	  case  8: load_raw = &CLASS eight_bit_load_raw;	break;
    5543. 

  5543. 	  case 12: if (tiff_ifd[raw].phint == 2)
    5544. 

  5544. 		     load_flags = 6;
    5545. 

  5545. 		   load_raw = &CLASS packed_load_raw;		break;
    5546. 

  5546. 	  case 14: load_flags = 0;
    5547. 

  5547. 	  case 16: load_raw = &CLASS unpacked_load_raw;		break;
    5548. 

  5548. 	}
    5549. 

  5549. 	break;
    5550. 

  5550.       case 6:  case 7:  case 99:
    5551. 

  5551. 	load_raw = &CLASS lossless_jpeg_load_raw;		break;
    5552. 

  5552.       case 262:
    5553. 

  5553. 	load_raw = &CLASS kodak_262_load_raw;			break;
    5554. 

  5554.       case 34713:
    5555. 

  5555. 	if ((raw_width+9)/10*16*raw_height == tiff_ifd[raw].bytes) {
    5556. 

  5556. 	  load_raw = &CLASS packed_load_raw;
    5557. 

  5557. 	  load_flags = 1;
    5558. 

  5558. 	} else if (raw_width*raw_height*2 == tiff_ifd[raw].bytes) {
    5559. 

  5559. 	  load_raw = &CLASS unpacked_load_raw;
    5560. 

  5560. 	  load_flags = 4;
    5561. 

  5561. 	  order = 0x4d4d;
    5562. 

  5562. 	} else
    5563. 

  5563. 	  load_raw = &CLASS nikon_load_raw;			break;
    5564. 

  5564.       case 34892:
    5565. 

  5565. 	load_raw = &CLASS lossy_dng_load_raw;			break;
    5566. 

  5566.       case 65535:
    5567. 

  5567. 	load_raw = &CLASS pentax_load_raw;			break;
    5568. 

  5568.       case 65000:
    5569. 

  5569. 	switch (tiff_ifd[raw].phint) {
    5570. 

  5570. 	  case 2: load_raw = &CLASS kodak_rgb_load_raw;   filters = 0;  break;
    5571. 

  5571. 	  case 6: load_raw = &CLASS kodak_ycbcr_load_raw; filters = 0;  break;
    5572. 

  5572. 	  case 32803: load_raw = &CLASS kodak_65000_load_raw;
    5573. 

  5573. 	}
    5574. 

  5574.       case 32867: break;
    5575. 

  5575.       default: is_raw = 0;
    5576. 

  5576.     }
    5577. 

  5577.   if (!dng_version)
    5578. 

  5578.     if ( (tiff_samples == 3 && tiff_ifd[raw].bytes &&
    5579. 

  5579. 	  tiff_bps != 14 && tiff_bps != 2048 && 
    5580. 

  5580. 	  tiff_compress != 32769 && tiff_compress != 32770)
    5581. 

  5581.       || (tiff_bps == 8 && !strstr(make,"KODAK") && !strstr(make,"Kodak") &&
    5582. 

  5582. 	  !strstr(model2,"DEBUG RAW")))
    5583. 

  5583.       is_raw = 0;
    5584. 

  5584.   for (i=0; i < tiff_nifds; i++)
    5585. 

  5585.     if (i != raw && tiff_ifd[i].samples == max_samp &&
    5586. 

  5586. 	tiff_ifd[i].t_width * tiff_ifd[i].t_height / SQR(tiff_ifd[i].bps+1) >
    5587. 

  5587. 	      thumb_width *       thumb_height / SQR(thumb_misc+1)
    5588. 

  5588. 	&& tiff_ifd[i].comp != 34892) {
    5589. 

  5589.       thumb_width  = tiff_ifd[i].t_width;
    5590. 

  5590.       thumb_height = tiff_ifd[i].t_height;
    5591. 

  5591.       thumb_offset = tiff_ifd[i].offset;
    5592. 

  5592.       thumb_length = tiff_ifd[i].bytes;
    5593. 

  5593.       thumb_misc   = tiff_ifd[i].bps;
    5594. 

  5594.       thm = i;
    5595. 

  5595.     }
    5596. 

  5596.   if (thm >= 0) {
    5597. 

  5597.     thumb_misc |= tiff_ifd[thm].samples << 5;
    5598. 

  5598.     switch (tiff_ifd[thm].comp) {
    5599. 

  5599.       case 0:
    5600. 

  5600. 	write_thumb = &CLASS layer_thumb;
    5601. 

  5601. 	break;
    5602. 

  5602.       case 1:
    5603. 

  5603. 	if (tiff_ifd[thm].bps <= 8)
    5604. 

  5604. 	  write_thumb = &CLASS ppm_thumb;
    5605. 

  5605. 	else if (!strcmp(make,"Imacon"))
    5606. 

  5606. 	  write_thumb = &CLASS ppm16_thumb;
    5607. 

  5607. 	else
    5608. 

  5608. 	  thumb_load_raw = &CLASS kodak_thumb_load_raw;
    5609. 

  5609. 	break;
    5610. 

  5610.       case 65000:
    5611. 

  5611. 	thumb_load_raw = tiff_ifd[thm].phint == 6 ?
    5612. 

  5612. 		&CLASS kodak_ycbcr_load_raw : &CLASS kodak_rgb_load_raw;
    5613. 

  5613.     }
    5614. 

  5614.   }
    5615. 

  5615. }
    5616. 

  5616. 

  5617. void CLASS parse_minolta (int base)
    5618. 

  5618. {
    5619. 

  5619.   int save, tag, len, offset, high=0, wide=0, i, c;
    5620. 

  5620.   short sorder=order;
    5621. 

  5621. 

  5622.   fseek (ifp, base, SEEK_SET);
    5623. 

  5623.   if (fgetc(ifp) || fgetc(ifp)-'M' || fgetc(ifp)-'R') return;
    5624. 

  5624.   order = fgetc(ifp) * 0x101;
    5625. 

  5625.   offset = base + get4() + 8;
    5626. 

  5626.   while ((save=ftell(ifp)) < offset) {
    5627. 

  5627.     for (tag=i=0; i < 4; i++)
    5628. 

  5628.       tag = tag << 8 | fgetc(ifp);
    5629. 

  5629.     len = get4();
    5630. 

  5630.     switch (tag) {
    5631. 

  5631.       case 0x505244:				/* PRD */
    5632. 

  5632. 	fseek (ifp, 8, SEEK_CUR);
    5633. 

  5633. 	high = get2();
    5634. 

  5634. 	wide = get2();
    5635. 

  5635. 	break;
    5636. 

  5636.       case 0x574247:				/* WBG */
    5637. 

  5637. 	get4();
    5638. 

  5638. 	i = strcmp(model,"DiMAGE A200") ? 0:3;
    5639. 

  5639. 	FORC4 cam_mul[c ^ (c >> 1) ^ i] = get2();
    5640. 

  5640. 	break;
    5641. 

  5641.       case 0x545457:				/* TTW */
    5642. 

  5642. 	parse_tiff (ftell(ifp));
    5643. 

  5643. 	data_offset = offset;
    5644. 

  5644.     }
    5645. 

  5645.     fseek (ifp, save+len+8, SEEK_SET);
    5646. 

  5646.   }
    5647. 

  5647.   raw_height = high;
    5648. 

  5648.   raw_width  = wide;
    5649. 

  5649.   order = sorder;
    5650. 

  5650. }
    5651. 

  5651. 

  5652. /*
    5653. 

  5653.    Many cameras have a "debug mode" that writes JPEG and raw
    5654. 

  5654.    at the same time.  The raw file has no header, so try to
    5655. 

  5655.    to open the matching JPEG file and read its metadata.
    5656. 

  5656.  */
    5657. 

  5657. void CLASS parse_external_jpeg()
    5658. 

  5658. {
    5659. 

  5659.   const char *file, *ext;
    5660. 

  5660.   char *jname, *jfile, *jext;
    5661. 

  5661. #ifndef LIBRAW_LIBRARY_BUILD
    5662. 

  5662.   FILE *save=ifp;
    5663. 

  5663. #else
    5664. 

  5664. #if (defined(_MSC_VER) && _MSC_VER > 1310)
    5665. 

  5665.   if(ifp->wfname())
    5666. 

  5666.   {
    5667. 

  5667. 	  std::wstring rawfile(ifp->wfname());
    5668. 

  5668. 	  rawfile.replace(rawfile.length()-3,3,L"JPG");
    5669. 

  5669. 	  if(!ifp->subfile_open(rawfile.c_str()))
    5670. 

  5670. 	  {
    5671. 

  5671. 		  parse_tiff (12);
    5672. 

  5672. 		  thumb_offset = 0;
    5673. 

  5673. 		  is_raw = 1;
    5674. 

  5674. 		  ifp->subfile_close();
    5675. 

  5675. 	  }
    5676. 

  5676. 	  else
    5677. 

  5677. 		  imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5678. 

  5678. 	 return;
    5679. 

  5679.   }
    5680. 

  5680. #endif // _MSC_VER
    5681. 

  5681.   if(!ifp->fname())
    5682. 

  5682.       {
    5683. 

  5683.           imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5684. 

  5684.           return;
    5685. 

  5685.       }
    5686. 

  5686. #endif
    5687. 

  5687. 

  5688.   ext  = strrchr (ifname, '.');
    5689. 

  5689.   file = strrchr (ifname, '/');
    5690. 

  5690.   if (!file) file = strrchr (ifname, '\\');
    5691. 

  5691. #ifndef LIBRAW_LIBRARY_BUILD
    5692. 

  5692.   if (!file) file = ifname-1;
    5693. 

  5693. #else
    5694. 

  5694.   if (!file) file = (char*)ifname-1;
    5695. 

  5695. #endif
    5696. 

  5696.   file++;
    5697. 

  5697.   if (!ext || strlen(ext) != 4 || ext-file != 8) return;
    5698. 

  5698.   jname = (char *) malloc (strlen(ifname) + 1);
    5699. 

  5699.   merror (jname, "parse_external_jpeg()");
    5700. 

  5700.   strcpy (jname, ifname);
    5701. 

  5701.   jfile = file - ifname + jname;
    5702. 

  5702.   jext  = ext  - ifname + jname;
    5703. 

  5703.   if (strcasecmp (ext, ".jpg")) {
    5704. 

  5704.     strcpy (jext, isupper(ext[1]) ? ".JPG":".jpg");
    5705. 

  5705.     if (isdigit(*file)) {
    5706. 

  5706.       memcpy (jfile, file+4, 4);
    5707. 

  5707.       memcpy (jfile+4, file, 4);
    5708. 

  5708.     }
    5709. 

  5709.   } else
    5710. 

  5710.     while (isdigit(*--jext)) {
    5711. 

  5711.       if (*jext != '9') {
    5712. 

  5712. 	(*jext)++;
    5713. 

  5713. 	break;
    5714. 

  5714.       }
    5715. 

  5715.       *jext = '0';
    5716. 

  5716.     }
    5717. 

  5717. #ifndef LIBRAW_LIBRARY_BUILD
    5718. 

  5718.   if (strcmp (jname, ifname)) {
    5719. 

  5719.     if ((ifp = fopen (jname, "rb"))) {
    5720. 

  5720. #ifdef DCRAW_VERBOSE
    5721. 

  5721.       if (verbose)
    5722. 

  5722. 	fprintf (stderr,_("Reading metadata from %s ...\n"), jname);
    5723. 

  5723. #endif
    5724. 

  5724.       parse_tiff (12);
    5725. 

  5725.       thumb_offset = 0;
    5726. 

  5726.       is_raw = 1;
    5727. 

  5727.       fclose (ifp);
    5728. 

  5728.     }
    5729. 

  5729.   }
    5730. 

  5730. #else
    5731. 

  5731.   if (strcmp (jname, ifname)) 
    5732. 

  5732.       {
    5733. 

  5733.           if(!ifp->subfile_open(jname))
    5734. 

  5734.               {
    5735. 

  5735.                   parse_tiff (12);
    5736. 

  5736.                   thumb_offset = 0;
    5737. 

  5737.                   is_raw = 1;
    5738. 

  5738.                   ifp->subfile_close();
    5739. 

  5739.               }
    5740. 

  5740.           else
    5741. 

  5741.               imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5742. 

  5742.       }
    5743. 

  5743. #endif
    5744. 

  5744.   if (!timestamp)
    5745. 

  5745.       {
    5746. 

  5746. #ifdef LIBRAW_LIBRARY_BUILD
    5747. 

  5747.           imgdata.process_warnings |= LIBRAW_WARN_NO_METADATA ;
    5748. 

  5748. #endif
    5749. 

  5749. #ifdef DCRAW_VERBOSE
    5750. 

  5750.           fprintf (stderr,_("Failed to read metadata from %s\n"), jname);
    5751. 

  5751. #endif
    5752. 

  5752.       }
    5753. 

  5753.   free (jname);
    5754. 

  5754. #ifndef LIBRAW_LIBRARY_BUILD
    5755. 

  5755.   ifp = save;
    5756. 

  5756. #endif
    5757. 

  5757. }
    5758. 

  5758. 

  5759. /*
    5760. 

  5760.    CIFF block 0x1030 contains an 8x8 white sample.
    5761. 

  5761.    Load this into white[][] for use in scale_colors().
    5762. 

  5762.  */
    5763. 

  5763. void CLASS ciff_block_1030()
    5764. 

  5764. {
    5765. 

  5765.   static const ushort key[] = { 0x410, 0x45f3 };
    5766. 

  5766.   int i, bpp, row, col, vbits=0;
    5767. 

  5767.   unsigned long bitbuf=0;
    5768. 

  5768. 

  5769.   if ((get2(),get4()) != 0x80008 || !get4()) return;
    5770. 

  5770.   bpp = get2();
    5771. 

  5771.   if (bpp != 10 && bpp != 12) return;
    5772. 

  5772.   for (i=row=0; row < 8; row++)
    5773. 

  5773.     for (col=0; col < 8; col++) {
    5774. 

  5774.       if (vbits < bpp) {
    5775. 

  5775. 	bitbuf = bitbuf << 16 | (get2() ^ key[i++ & 1]);
    5776. 

  5776. 	vbits += 16;
    5777. 

  5777.       }
    5778. 

  5778.       white[row][col] =
    5779. 

  5779. 	bitbuf << (LONG_BIT - vbits) >> (LONG_BIT - bpp);
    5780. 

  5780.       vbits -= bpp;
    5781. 

  5781.     }
    5782. 

  5782. }
    5783. 

  5783. 

  5784. /*
    5785. 

  5785.    Parse a CIFF file, better known as Canon CRW format.
    5786. 

  5786.  */
    5787. 

  5787. void CLASS parse_ciff (int offset, int length)
    5788. 

  5788. {
    5789. 

  5789.   int tboff, nrecs, c, type, len, save, wbi=-1;
    5790. 

  5790.   ushort key[] = { 0x410, 0x45f3 };
    5791. 

  5791. 

  5792.   fseek (ifp, offset+length-4, SEEK_SET);
    5793. 

  5793.   tboff = get4() + offset;
    5794. 

  5794.   fseek (ifp, tboff, SEEK_SET);
    5795. 

  5795.   nrecs = get2();
    5796. 

  5796.   if (nrecs > 100) return;
    5797. 

  5797.   while (nrecs--) {
    5798. 

  5798.     type = get2();
    5799. 

  5799.     len  = get4();
    5800. 

  5800.     save = ftell(ifp) + 4;
    5801. 

  5801.     fseek (ifp, offset+get4(), SEEK_SET);
    5802. 

  5802.     if ((((type >> 8) + 8) | 8) == 0x38)
    5803. 

  5803.       parse_ciff (ftell(ifp), len);	/* Parse a sub-table */
    5804. 

  5804. 

  5805.     if (type == 0x0810)
    5806. 

  5806.       fread (artist, 64, 1, ifp);
    5807. 

  5807.     if (type == 0x080a) {
    5808. 

  5808.       fread (make, 64, 1, ifp);
    5809. 

  5809.       fseek (ifp, strlen(make) - 63, SEEK_CUR);
    5810. 

  5810.       fread (model, 64, 1, ifp);
    5811. 

  5811.     }
    5812. 

  5812.     if (type == 0x1810) {
    5813. 

  5813.       fseek (ifp, 12, SEEK_CUR);
    5814. 

  5814.       flip = get4();
    5815. 

  5815.     }
    5816. 

  5816.     if (type == 0x1835)			/* Get the decoder table */
    5817. 

  5817.       tiff_compress = get4();
    5818. 

  5818.     if (type == 0x2007) {
    5819. 

  5819.       thumb_offset = ftell(ifp);
    5820. 

  5820.       thumb_length = len;
    5821. 

  5821.     }
    5822. 

  5822.     if (type == 0x1818) {
    5823. 

  5823.       shutter = pow (2.0f, -int_to_float((get4(),get4())));
    5824. 

  5824.       aperture = pow (2.0f, int_to_float(get4())/2);
    5825. 

  5825.     }
    5826. 

  5826.     if (type == 0x102a) {
    5827. 

  5827.       iso_speed = pow (2.0, (get4(),get2())/32.0 - 4) * 50;
    5828. 

  5828.       aperture  = pow (2.0, (get2(),(short)get2())/64.0);
    5829. 

  5829.       shutter   = pow (2.0,-((short)get2())/32.0);
    5830. 

  5830.       wbi = (get2(),get2());
    5831. 

  5831.       if (wbi > 17) wbi = 0;
    5832. 

  5832.       fseek (ifp, 32, SEEK_CUR);
    5833. 

  5833.       if (shutter > 1e6) shutter = get2()/10.0;
    5834. 

  5834.     }
    5835. 

  5835.     if (type == 0x102c) {
    5836. 

  5836.       if (get2() > 512) {		/* Pro90, G1 */
    5837. 

  5837. 	fseek (ifp, 118, SEEK_CUR);
    5838. 

  5838. 	FORC4 cam_mul[c ^ 2] = get2();
    5839. 

  5839.       } else {				/* G2, S30, S40 */
    5840. 

  5840. 	fseek (ifp, 98, SEEK_CUR);
    5841. 

  5841. 	FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get2();
    5842. 

  5842.       }
    5843. 

  5843.     }
    5844. 

  5844.     if (type == 0x0032) {
    5845. 

  5845.       if (len == 768) {			/* EOS D30 */
    5846. 

  5846. 	fseek (ifp, 72, SEEK_CUR);
    5847. 

  5847. 	FORC4 cam_mul[c ^ (c >> 1)] = 1024.0 / get2();
    5848. 

  5848. 	if (!wbi) cam_mul[0] = -1;	/* use my auto white balance */
    5849. 

  5849.       } else if (!cam_mul[0]) {
    5850. 

  5850. 	if (get2() == key[0])		/* Pro1, G6, S60, S70 */
    5851. 

  5851. 	  c = (strstr(model,"Pro1") ?
    5852. 

  5852. 	      "012346000000000000":"01345:000000006008")[wbi]-'0'+ 2;
    5853. 

  5853. 	else {				/* G3, G5, S45, S50 */
    5854. 

  5854. 	  c = "023457000000006000"[wbi]-'0';
    5855. 

  5855. 	  key[0] = key[1] = 0;
    5856. 

  5856. 	}
    5857. 

  5857. 	fseek (ifp, 78 + c*8, SEEK_CUR);
    5858. 

  5858. 	FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get2() ^ key[c & 1];
    5859. 

  5859. 	if (!wbi) cam_mul[0] = -1;
    5860. 

  5860.       }
    5861. 

  5861.     }
    5862. 

  5862.     if (type == 0x10a9) {		/* D60, 10D, 300D, and clones */
    5863. 

  5863.       if (len > 66) wbi = "0134567028"[wbi]-'0';
    5864. 

  5864.       fseek (ifp, 2 + wbi*8, SEEK_CUR);
    5865. 

  5865.       FORC4 cam_mul[c ^ (c >> 1)] = get2();
    5866. 

  5866.     }
    5867. 

  5867.     if (type == 0x1030 && (0x18040 >> wbi & 1))
    5868. 

  5868.       ciff_block_1030();		/* all that don't have 0x10a9 */
    5869. 

  5869.     if (type == 0x1031) {
    5870. 

  5870.       raw_width = (get2(),get2());
    5871. 

  5871.       raw_height = get2();
    5872. 

  5872.     }
    5873. 

  5873.     if (type == 0x5029) {
    5874. 

  5874.       focal_len = len >> 16;
    5875. 

  5875.       if ((len & 0xffff) == 2) focal_len /= 32;
    5876. 

  5876.     }
    5877. 

  5877.     if (type == 0x5813) flash_used = int_to_float(len);
    5878. 

  5878.     if (type == 0x5814) canon_ev   = int_to_float(len);
    5879. 

  5879.     if (type == 0x5817) shot_order = len;
    5880. 

  5880.     if (type == 0x5834) unique_id  = len;
    5881. 

  5881.     if (type == 0x580e) timestamp  = len;
    5882. 

  5882.     if (type == 0x180e) timestamp  = get4();
    5883. 

  5883. #ifdef LOCALTIME
    5884. 

  5884.     if ((type | 0x4000) == 0x580e)
    5885. 

  5885.       timestamp = mktime (gmtime (&timestamp));
    5886. 

  5886. #endif
    5887. 

  5887.     fseek (ifp, save, SEEK_SET);
    5888. 

  5888.   }
    5889. 

  5889. }
    5890. 

  5890. 

  5891. void CLASS parse_rollei()
    5892. 

  5892. {
    5893. 

  5893.   char line[128], *val;
    5894. 

  5894.   struct tm t;
    5895. 

  5895. 

  5896.   fseek (ifp, 0, SEEK_SET);
    5897. 

  5897.   memset (&t, 0, sizeof t);
    5898. 

  5898.   do {
    5899. 

  5899.     fgets (line, 128, ifp);
    5900. 

  5900.     if ((val = strchr(line,'=')))
    5901. 

  5901.       *val++ = 0;
    5902. 

  5902.     else
    5903. 

  5903.       val = line + strlen(line);
    5904. 

  5904.     if (!strcmp(line,"DAT"))
    5905. 

  5905.       sscanf (val, "%d.%d.%d", &t.tm_mday, &t.tm_mon, &t.tm_year);
    5906. 

  5906.     if (!strcmp(line,"TIM"))
    5907. 

  5907.       sscanf (val, "%d:%d:%d", &t.tm_hour, &t.tm_min, &t.tm_sec);
    5908. 

  5908.     if (!strcmp(line,"HDR"))
    5909. 

  5909.       thumb_offset = atoi(val);
    5910. 

  5910.     if (!strcmp(line,"X  "))
    5911. 

  5911.       raw_width = atoi(val);
    5912. 

  5912.     if (!strcmp(line,"Y  "))
    5913. 

  5913.       raw_height = atoi(val);
    5914. 

  5914.     if (!strcmp(line,"TX "))
    5915. 

  5915.       thumb_width = atoi(val);
    5916. 

  5916.     if (!strcmp(line,"TY "))
    5917. 

  5917.       thumb_height = atoi(val);
    5918. 

  5918.   } while (strncmp(line,"EOHD",4));
    5919. 

  5919.   data_offset = thumb_offset + thumb_width * thumb_height * 2;
    5920. 

  5920.   t.tm_year -= 1900;
    5921. 

  5921.   t.tm_mon -= 1;
    5922. 

  5922.   if (mktime(&t) > 0)
    5923. 

  5923.     timestamp = mktime(&t);
    5924. 

  5924.   strcpy (make, "Rollei");
    5925. 

  5925.   strcpy (model,"d530flex");
    5926. 

  5926.   write_thumb = &CLASS rollei_thumb;
    5927. 

  5927. }
    5928. 

  5928. 

  5929. void CLASS parse_sinar_ia()
    5930. 

  5930. {
    5931. 

  5931.   int entries, off;
    5932. 

  5932.   char str[8], *cp;
    5933. 

  5933. 

  5934.   order = 0x4949;
    5935. 

  5935.   fseek (ifp, 4, SEEK_SET);
    5936. 

  5936.   entries = get4();
    5937. 

  5937.   fseek (ifp, get4(), SEEK_SET);
    5938. 

  5938.   while (entries--) {
    5939. 

  5939.     off = get4(); get4();
    5940. 

  5940.     fread (str, 8, 1, ifp);
    5941. 

  5941.     if (!strcmp(str,"META"))   meta_offset = off;
    5942. 

  5942.     if (!strcmp(str,"THUMB")) thumb_offset = off;
    5943. 

  5943.     if (!strcmp(str,"RAW0"))   data_offset = off;
    5944. 

  5944.   }
    5945. 

  5945.   fseek (ifp, meta_offset+20, SEEK_SET);
    5946. 

  5946.   fread (make, 64, 1, ifp);
    5947. 

  5947.   make[63] = 0;
    5948. 

  5948.   if ((cp = strchr(make,' '))) {
    5949. 

  5949.     strcpy (model, cp+1);
    5950. 

  5950.     *cp = 0;
    5951. 

  5951.   }
    5952. 

  5952.   raw_width  = get2();
    5953. 

  5953.   raw_height = get2();
    5954. 

  5954.   load_raw = &CLASS unpacked_load_raw;
    5955. 

  5955.   thumb_width = (get4(),get2());
    5956. 

  5956.   thumb_height = get2();
    5957. 

  5957.   write_thumb = &CLASS ppm_thumb;
    5958. 

  5958.   maximum = 0x3fff;
    5959. 

  5959. }
    5960. 

  5960. 

  5961. void CLASS parse_phase_one (int base)
    5962. 

  5962. {
    5963. 

  5963.   unsigned entries, tag, type, len, data, save, i, c;
    5964. 

  5964.   float romm_cam[3][3];
    5965. 

  5965.   char *cp;
    5966. 

  5966. 

  5967.   memset (&ph1, 0, sizeof ph1);
    5968. 

  5968.   fseek (ifp, base, SEEK_SET);
    5969. 

  5969.   order = get4() & 0xffff;
    5970. 

  5970.   if (get4() >> 8 != 0x526177) return;		/* "Raw" */
    5971. 

  5971.   fseek (ifp, get4()+base, SEEK_SET);
    5972. 

  5972.   entries = get4();
    5973. 

  5973.   get4();
    5974. 

  5974.   while (entries--) {
    5975. 

  5975.     tag  = get4();
    5976. 

  5976.     type = get4();
    5977. 

  5977.     len  = get4();
    5978. 

  5978.     data = get4();
    5979. 

  5979.     save = ftell(ifp);
    5980. 

  5980.     fseek (ifp, base+data, SEEK_SET);
    5981. 

  5981.     switch (tag) {
    5982. 

  5982.       case 0x100:  flip = "0653"[data & 3]-'0';  break;
    5983. 

  5983.       case 0x106:
    5984. 

  5984. 	for (i=0; i < 9; i++)
    5985. 

  5985. 	  romm_cam[0][i] = getreal(11);
    5986. 

  5986. 	romm_coeff (romm_cam);
    5987. 

  5987. 	break;
    5988. 

  5988.       case 0x107:
    5989. 

  5989. 	FORC3 cam_mul[c] = getreal(11);
    5990. 

  5990. 	break;
    5991. 

  5991.       case 0x108:  raw_width     = data;	break;
    5992. 

  5992.       case 0x109:  raw_height    = data;	break;
    5993. 

  5993.       case 0x10a:  left_margin   = data;	break;
    5994. 

  5994.       case 0x10b:  top_margin    = data;	break;
    5995. 

  5995.       case 0x10c:  width         = data;	break;
    5996. 

  5996.       case 0x10d:  height        = data;	break;
    5997. 

  5997.       case 0x10e:  ph1.format    = data;	break;
    5998. 

  5998.       case 0x10f:  data_offset   = data+base;	break;
    5999. 

  5999.       case 0x110:  meta_offset   = data+base;
    6000. 

  6000. 		   meta_length   = len;			break;
    6001. 

  6001.       case 0x112:  ph1.key_off   = save - 4;		break;
    6002. 

  6002.       case 0x210:  ph1.tag_210   = int_to_float(data);	break;
    6003. 

  6003.       case 0x21a:  ph1.tag_21a   = data;		break;
    6004. 

  6004.       case 0x21c:  strip_offset  = data+base;		break;
    6005. 

  6005.       case 0x21d:  ph1.t_black     = data;		break;
    6006. 

  6006.       case 0x222:  ph1.split_col = data;		break;
    6007. 

  6007.       case 0x223:  ph1.black_off = data+base;		break;
    6008. 

  6008.       case 0x301:
    6009. 

  6009. 	model[63] = 0;
    6010. 

  6010. 	fread (model, 1, 63, ifp);
    6011. 

  6011. 	if ((cp = strstr(model," camera"))) *cp = 0;
    6012. 

  6012.     }
    6013. 

  6013.     fseek (ifp, save, SEEK_SET);
    6014. 

  6014.   }
    6015. 

  6015.   load_raw = ph1.format < 3 ?
    6016. 

  6016. 	&CLASS phase_one_load_raw : &CLASS phase_one_load_raw_c;
    6017. 

  6017.   maximum = 0xffff;
    6018. 

  6018.   strcpy (make, "Phase One");
    6019. 

  6019.   if (model[0]) return;
    6020. 

  6020.   switch (raw_height) {
    6021. 

  6021.     case 2060: strcpy (model,"LightPhase");	break;
    6022. 

  6022.     case 2682: strcpy (model,"H 10");		break;
    6023. 

  6023.     case 4128: strcpy (model,"H 20");		break;
    6024. 

  6024.     case 5488: strcpy (model,"H 25");		break;
    6025. 

  6025.   }
    6026. 

  6026. }
    6027. 

  6027. 

  6028. void CLASS parse_fuji (int offset)
    6029. 

  6029. {
    6030. 

  6030.   unsigned entries, tag, len, save, c;
    6031. 

  6031. 

  6032.   fseek (ifp, offset, SEEK_SET);
    6033. 

  6033.   entries = get4();
    6034. 

  6034.   if (entries > 255) return;
    6035. 

  6035.   while (entries--) {
    6036. 

  6036.     tag = get2();
    6037. 

  6037.     len = get2();
    6038. 

  6038.     save = ftell(ifp);
    6039. 

  6039.     if (tag == 0x100) {
    6040. 

  6040.       raw_height = get2();
    6041. 

  6041.       raw_width  = get2();
    6042. 

  6042.     } else if (tag == 0x121) {
    6043. 

  6043.       height = get2();
    6044. 

  6044.       if ((width = get2()) == 4284) width += 3;
    6045. 

  6045.     } else if (tag == 0x130) {
    6046. 

  6046.       fuji_layout = fgetc(ifp) >> 7;
    6047. 

  6047.       fuji_width = !(fgetc(ifp) & 8);
    6048. 

  6048.     } else if (tag == 0x2ff0) {
    6049. 

  6049.       FORC4 cam_mul[c ^ 1] = get2();
    6050. 

  6050.     } else if (tag == 0xc000) {
    6051. 

  6051.       c = order;
    6052. 

  6052.       order = 0x4949;
    6053. 

  6053.       if ((width = get4()) > 10000) width = get4();
    6054. 

  6054.       height = get4();
    6055. 

  6055.       order = c;
    6056. 

  6056.     }
    6057. 

  6057.     fseek (ifp, save+len, SEEK_SET);
    6058. 

  6058.   }
    6059. 

  6059.   height <<= fuji_layout;
    6060. 

  6060.   width  >>= fuji_layout;
    6061. 

  6061. }
    6062. 

  6062. 

  6063. int CLASS parse_jpeg (int offset)
    6064. 

  6064. {
    6065. 

  6065.   int len, save, hlen, mark;
    6066. 

  6066. 

  6067.   fseek (ifp, offset, SEEK_SET);
    6068. 

  6068.   if (fgetc(ifp) != 0xff || fgetc(ifp) != 0xd8) return 0;
    6069. 

  6069. 

  6070.   while (fgetc(ifp) == 0xff && (mark = fgetc(ifp)) != 0xda) {
    6071. 

  6071.     order = 0x4d4d;
    6072. 

  6072.     len   = get2() - 2;
    6073. 

  6073.     save  = ftell(ifp);
    6074. 

  6074.     if (mark == 0xc0 || mark == 0xc3) {
    6075. 

  6075.       fgetc(ifp);
    6076. 

  6076.       raw_height = get2();
    6077. 

  6077.       raw_width  = get2();
    6078. 

  6078.     }
    6079. 

  6079.     order = get2();
    6080. 

  6080.     hlen  = get4();
    6081. 

  6081.     if (get4() == 0x48454150)		/* "HEAP" */
    6082. 

  6082.       parse_ciff (save+hlen, len-hlen);
    6083. 

  6083.     if (parse_tiff (save+6)) apply_tiff();
    6084. 

  6084.     fseek (ifp, save+len, SEEK_SET);
    6085. 

  6085.   }
    6086. 

  6086.   return 1;
    6087. 

  6087. }
    6088. 

  6088. 

  6089. void CLASS parse_riff()
    6090. 

  6090. {
    6091. 

  6091.   unsigned i, size, end;
    6092. 

  6092.   char tag[4], date[64], month[64];
    6093. 

  6093.   static const char mon[12][4] =
    6094. 

  6094.   { "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" };
    6095. 

  6095.   struct tm t;
    6096. 

  6096. 

  6097.   order = 0x4949;
    6098. 

  6098.   fread (tag, 4, 1, ifp);
    6099. 

  6099.   size = get4();
    6100. 

  6100.   end = ftell(ifp) + size;
    6101. 

  6101.   if (!memcmp(tag,"RIFF",4) || !memcmp(tag,"LIST",4)) {
    6102. 

  6102.     get4();
    6103. 

  6103.     while (ftell(ifp)+7 < end)
    6104. 

  6104.       parse_riff();
    6105. 

  6105.   } else if (!memcmp(tag,"nctg",4)) {
    6106. 

  6106.     while (ftell(ifp)+7 < end) {
    6107. 

  6107.       i = get2();
    6108. 

  6108.       size = get2();
    6109. 

  6109.       if ((i+1) >> 1 == 10 && size == 20)
    6110. 

  6110. 	get_timestamp(0);
    6111. 

  6111.       else fseek (ifp, size, SEEK_CUR);
    6112. 

  6112.     }
    6113. 

  6113.   } else if (!memcmp(tag,"IDIT",4) && size < 64) {
    6114. 

  6114.     fread (date, 64, 1, ifp);
    6115. 

  6115.     date[size] = 0;
    6116. 

  6116.     memset (&t, 0, sizeof t);
    6117. 

  6117.     if (sscanf (date, "%*s %s %d %d:%d:%d %d", month, &t.tm_mday,
    6118. 

  6118. 	&t.tm_hour, &t.tm_min, &t.tm_sec, &t.tm_year) == 6) {
    6119. 

  6119.       for (i=0; i < 12 && strcasecmp(mon[i],month); i++);
    6120. 

  6120.       t.tm_mon = i;
    6121. 

  6121.       t.tm_year -= 1900;
    6122. 

  6122.       if (mktime(&t) > 0)
    6123. 

  6123. 	timestamp = mktime(&t);
    6124. 

  6124.     }
    6125. 

  6125.   } else
    6126. 

  6126.     fseek (ifp, size, SEEK_CUR);
    6127. 

  6127. }
    6128. 

  6128. 

  6129. void CLASS parse_smal (int offset, int fsize)
    6130. 

  6130. {
    6131. 

  6131.   int ver;
    6132. 

  6132. 

  6133.   fseek (ifp, offset+2, SEEK_SET);
    6134. 

  6134.   order = 0x4949;
    6135. 

  6135.   ver = fgetc(ifp);
    6136. 

  6136.   if (ver == 6)
    6137. 

  6137.     fseek (ifp, 5, SEEK_CUR);
    6138. 

  6138.   if (get4() != fsize) return;
    6139. 

  6139.   if (ver > 6) data_offset = get4();
    6140. 

  6140.   raw_height = height = get2();
    6141. 

  6141.   raw_width  = width  = get2();
    6142. 

  6142.   strcpy (make, "SMaL");
    6143. 

  6143.   sprintf (model, "v%d %dx%d", ver, width, height);
    6144. 

  6144.   if (ver == 6) load_raw = &CLASS smal_v6_load_raw;
    6145. 

  6145.   if (ver == 9) load_raw = &CLASS smal_v9_load_raw;
    6146. 

  6146. }
    6147. 

  6147. 

  6148. void CLASS parse_cine()
    6149. 

  6149. {
    6150. 

  6150.   unsigned off_head, off_setup, off_image, i;
    6151. 

  6151. 

  6152.   order = 0x4949;
    6153. 

  6153.   fseek (ifp, 4, SEEK_SET);
    6154. 

  6154.   is_raw = get2() == 2;
    6155. 

  6155.   fseek (ifp, 14, SEEK_CUR);
    6156. 

  6156.   is_raw *= get4();
    6157. 

  6157.   off_head = get4();
    6158. 

  6158.   off_setup = get4();
    6159. 

  6159.   off_image = get4();
    6160. 

  6160.   timestamp = get4();
    6161. 

  6161.   if ((i = get4())) timestamp = i;
    6162. 

  6162.   fseek (ifp, off_head+4, SEEK_SET);
    6163. 

  6163.   raw_width = get4();
    6164. 

  6164.   raw_height = get4();
    6165. 

  6165.   switch (get2(),get2()) {
    6166. 

  6166.     case  8:  load_raw = &CLASS eight_bit_load_raw;  break;
    6167. 

  6167.     case 16:  load_raw = &CLASS  unpacked_load_raw;
    6168. 

  6168.   }
    6169. 

  6169.   fseek (ifp, off_setup+792, SEEK_SET);
    6170. 

  6170.   strcpy (make, "CINE");
    6171. 

  6171.   sprintf (model, "%d", get4());
    6172. 

  6172.   fseek (ifp, 12, SEEK_CUR);
    6173. 

  6173.   switch ((i=get4()) & 0xffffff) {
    6174. 

  6174.     case  3:  filters = 0x94949494;  break;
    6175. 

  6175.     case  4:  filters = 0x49494949;  break;
    6176. 

  6176.     default:  is_raw = 0;
    6177. 

  6177.   }
    6178. 

  6178.   fseek (ifp, 72, SEEK_CUR);
    6179. 

  6179.   switch ((get4()+3600) % 360) {
    6180. 

  6180.     case 270:  flip = 4;  break;
    6181. 

  6181.     case 180:  flip = 1;  break;
    6182. 

  6182.     case  90:  flip = 7;  break;
    6183. 

  6183.     case   0:  flip = 2;
    6184. 

  6184.   }
    6185. 

  6185.   cam_mul[0] = getreal(11);
    6186. 

  6186.   cam_mul[2] = getreal(11);
    6187. 

  6187.   maximum = ~(-1 << get4());
    6188. 

  6188.   fseek (ifp, 668, SEEK_CUR);
    6189. 

  6189.   shutter = get4()/1000000000.0;
    6190. 

  6190.   fseek (ifp, off_image, SEEK_SET);
    6191. 

  6191.   if (shot_select < is_raw)
    6192. 

  6192.     fseek (ifp, shot_select*8, SEEK_CUR);
    6193. 

  6193.   data_offset  = (INT64) get4() + 8;
    6194. 

  6194.   data_offset += (INT64) get4() << 32;
    6195. 

  6195. }
    6196. 

  6196. 

  6197. void CLASS parse_redcine()
    6198. 

  6198. {
    6199. 

  6199.   unsigned i, len, rdvo;
    6200. 

  6200. 

  6201.   order = 0x4d4d;
    6202. 

  6202.   is_raw = 0;
    6203. 

  6203.   fseek (ifp, 52, SEEK_SET);
    6204. 

  6204.   width  = get4();
    6205. 

  6205.   height = get4();
    6206. 

  6206.   fseek (ifp, 0, SEEK_END);
    6207. 

  6207.   fseek (ifp, -(i = ftello(ifp) & 511), SEEK_CUR);
    6208. 

  6208.   if (get4() != i || get4() != 0x52454f42) {
    6209. 

  6209. #ifdef DCRAW_VERBOSE
    6210. 

  6210.     fprintf (stderr,_("%s: Tail is missing, parsing from head...\n"), ifname);
    6211. 

  6211. #endif
    6212. 

  6212.     fseek (ifp, 0, SEEK_SET);
    6213. 

  6213.     while ((len = get4()) != EOF) {
    6214. 

  6214.       if (get4() == 0x52454456)
    6215. 

  6215. 	if (is_raw++ == shot_select)
    6216. 

  6216. 	  data_offset = ftello(ifp) - 8;
    6217. 

  6217.       fseek (ifp, len-8, SEEK_CUR);
    6218. 

  6218.     }
    6219. 

  6219.   } else {
    6220. 

  6220.     rdvo = get4();
    6221. 

  6221.     fseek (ifp, 12, SEEK_CUR);
    6222. 

  6222.     is_raw = get4();
    6223. 

  6223.     fseeko (ifp, rdvo+8 + shot_select*4, SEEK_SET);
    6224. 

  6224.     data_offset = get4();
    6225. 

  6225.   }
    6226. 

  6226. }
    6227. 

  6227. char * CLASS foveon_gets (int offset, char *str, int len)
    6228. 

  6228. {
    6229. 

  6229.   int i;
    6230. 

  6230.   fseek (ifp, offset, SEEK_SET);
    6231. 

  6231.   for (i=0; i < len-1; i++)
    6232. 

  6232.     if ((str[i] = get2()) == 0) break;
    6233. 

  6233.   str[i] = 0;
    6234. 

  6234.   return str;
    6235. 

  6235. }
    6236. 

  6236. 

  6237. void CLASS parse_foveon()
    6238. 

  6238. {
    6239. 

  6239.   int entries, img=0, off, len, tag, save, i, wide, high, pent, poff[256][2];
    6240. 

  6240.   char name[64], value[64];
    6241. 

  6241. 

  6242.   order = 0x4949;			/* Little-endian */
    6243. 

  6243.   fseek (ifp, 36, SEEK_SET);
    6244. 

  6244.   flip = get4();
    6245. 

  6245.   fseek (ifp, -4, SEEK_END);
    6246. 

  6246.   fseek (ifp, get4(), SEEK_SET);
    6247. 

  6247.   if (get4() != 0x64434553) return;	/* SECd */
    6248. 

  6248.   entries = (get4(),get4());
    6249. 

  6249.   while (entries--) {
    6250. 

  6250.     off = get4();
    6251. 

  6251.     len = get4();
    6252. 

  6252.     tag = get4();
    6253. 

  6253.     save = ftell(ifp);
    6254. 

  6254.     fseek (ifp, off, SEEK_SET);
    6255. 

  6255.     if (get4() != (0x20434553 | (tag << 24))) return;
    6256. 

  6256.     switch (tag) {
    6257. 

  6257.       case 0x47414d49:			/* IMAG */
    6258. 

  6258.       case 0x32414d49:			/* IMA2 */
    6259. 

  6259. 	fseek (ifp, 8, SEEK_CUR);
    6260. 

  6260. 	pent = get4();
    6261. 

  6261. 	wide = get4();
    6262. 

  6262. 	high = get4();
    6263. 

  6263. 	if (wide > raw_width && high > raw_height) {
    6264. 

  6264. 	  switch (pent) {
    6265. 

  6265. 	    case  5:  load_flags = 1;
    6266. 

  6266. 	    case  6:  load_raw = &CLASS foveon_sd_load_raw;  break;
    6267. 

  6267. 	    case 30:  load_raw = &CLASS foveon_dp_load_raw;  break;
    6268. 

  6268. 	    default:  load_raw = 0;
    6269. 

  6269. 	  }
    6270. 

  6270. 	  raw_width  = wide;
    6271. 

  6271. 	  raw_height = high;
    6272. 

  6272. 	  data_offset = off+28;
    6273. 

  6273. 	}
    6274. 

  6274. 	fseek (ifp, off+28, SEEK_SET);
    6275. 

  6275. 	if (fgetc(ifp) == 0xff && fgetc(ifp) == 0xd8
    6276. 

  6276. 		&& thumb_length < len-28) {
    6277. 

  6277. 	  thumb_offset = off+28;
    6278. 

  6278. 	  thumb_length = len-28;
    6279. 

  6279. 	  write_thumb = &CLASS jpeg_thumb;
    6280. 

  6280. 	}
    6281. 

  6281. 	if (++img == 2 && !thumb_length) {
    6282. 

  6282. 	  thumb_offset = off+24;
    6283. 

  6283. 	  thumb_width = wide;
    6284. 

  6284. 	  thumb_height = high;
    6285. 

  6285. 	  write_thumb = &CLASS foveon_thumb;
    6286. 

  6286. 	}
    6287. 

  6287. 	break;
    6288. 

  6288.       case 0x464d4143:			/* CAMF */
    6289. 

  6289. 	meta_offset = off+8;
    6290. 

  6290. 	meta_length = len-28;
    6291. 

  6291. 	break;
    6292. 

  6292.       case 0x504f5250:			/* PROP */
    6293. 

  6293. 	pent = (get4(),get4());
    6294. 

  6294. 	fseek (ifp, 12, SEEK_CUR);
    6295. 

  6295. 	off += pent*8 + 24;
    6296. 

  6296. 	if ((unsigned) pent > 256) pent=256;
    6297. 

  6297. 	for (i=0; i < pent*2; i++)
    6298. 

  6298. 	  poff[0][i] = off + get4()*2;
    6299. 

  6299. 	for (i=0; i < pent; i++) {
    6300. 

  6300. 	  foveon_gets (poff[i][0], name, 64);
    6301. 

  6301. 	  foveon_gets (poff[i][1], value, 64);
    6302. 

  6302. 	  if (!strcmp (name, "ISO"))
    6303. 

  6303. 	    iso_speed = atoi(value);
    6304. 

  6304. 	  if (!strcmp (name, "CAMMANUF"))
    6305. 

  6305. 	    strcpy (make, value);
    6306. 

  6306. 	  if (!strcmp (name, "CAMMODEL"))
    6307. 

  6307. 	    strcpy (model, value);
    6308. 

  6308. 	  if (!strcmp (name, "WB_DESC"))
    6309. 

  6309. 	    strcpy (model2, value);
    6310. 

  6310. 	  if (!strcmp (name, "TIME"))
    6311. 

  6311. 	    timestamp = atoi(value);
    6312. 

  6312. 	  if (!strcmp (name, "EXPTIME"))
    6313. 

  6313. 	    shutter = atoi(value) / 1000000.0;
    6314. 

  6314. 	  if (!strcmp (name, "APERTURE"))
    6315. 

  6315. 	    aperture = atof(value);
    6316. 

  6316. 	  if (!strcmp (name, "FLENGTH"))
    6317. 

  6317. 	    focal_len = atof(value);
    6318. 

  6318. 	}
    6319. 

  6319. #ifdef LOCALTIME
    6320. 

  6320. 	timestamp = mktime (gmtime (&timestamp));
    6321. 

  6321. #endif
    6322. 

  6322.     }
    6323. 

  6323.     fseek (ifp, save, SEEK_SET);
    6324. 

  6324.   }
    6325. 

  6325.   is_foveon = 1;
    6326. 

  6326. }
    6327. 

  6327. /*
    6328. 

  6328.    All matrices are from Adobe DNG Converter unless otherwise noted.
    6329. 

  6329.  */
    6330. 

  6330. void CLASS adobe_coeff (const char *t_make, const char *t_model)
    6331. 

  6331. {
    6332. 

  6332.   static const struct {
    6333. 

  6333.     const char *prefix;
    6334. 

  6334.     short t_black, t_maximum, trans[12];
    6335. 

  6335.   } table[] = {
    6336. 

  6336.     { "AGFAPHOTO DC-833m", 0, 0,	/* DJC */
    6337. 

  6337. 	{ 11438,-3762,-1115,-2409,9914,2497,-1227,2295,5300 } },
    6338. 

  6338.     { "Apple QuickTake", 0, 0,		/* DJC */
    6339. 

  6339. 	{ 21392,-5653,-3353,2406,8010,-415,7166,1427,2078 } },
    6340. 

  6340.     { "Canon EOS D2000", 0, 0,
    6341. 

  6341. 	{ 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } },
    6342. 

  6342.     { "Canon EOS D6000", 0, 0,
    6343. 

  6343. 	{ 20482,-7172,-3125,-1033,10410,-285,2542,226,3136 } },
    6344. 

  6344.     { "Canon EOS D30", 0, 0,
    6345. 

  6345. 	{ 9805,-2689,-1312,-5803,13064,3068,-2438,3075,8775 } },
    6346. 

  6346.     { "Canon EOS D60", 0, 0xfa0,
    6347. 

  6347. 	{ 6188,-1341,-890,-7168,14489,2937,-2640,3228,8483 } },
    6348. 

  6348.     { "Canon EOS 5D Mark III", 0, 0x3c80,
    6349. 

  6349. 	{ 6722,-635,-963,-4287,12460,2028,-908,2162,5668 } },
    6350. 

  6350.     { "Canon EOS 5D Mark II", 0, 0x3cf0,
    6351. 

  6351. 	{ 4716,603,-830,-7798,15474,2480,-1496,1937,6651 } },
    6352. 

  6352.     { "Canon EOS 5D", 0, 0xe6c,
    6353. 

  6353. 	{ 6347,-479,-972,-8297,15954,2480,-1968,2131,7649 } },
    6354. 

  6354.     { "Canon EOS 6D", 0, 0x3c82,
    6355. 

  6355. 	{ 7034,-804,-1014,-4420,12564,2058,-851,1994,5758 } },
    6356. 

  6356.     { "Canon EOS 7D", 0, 0x3510,
    6357. 

  6357. 	{ 6844,-996,-856,-3876,11761,2396,-593,1772,6198 } },
    6358. 

  6358.     { "Canon EOS 10D", 0, 0xfa0,
    6359. 

  6359. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6360. 

  6360.     { "Canon EOS 20Da", 0, 0,
    6361. 

  6361. 	{ 14155,-5065,-1382,-6550,14633,2039,-1623,1824,6561 } },
    6362. 

  6362.     { "Canon EOS 20D", 0, 0xfff,
    6363. 

  6363. 	{ 6599,-537,-891,-8071,15783,2424,-1983,2234,7462 } },
    6364. 

  6364.     { "Canon EOS 30D", 0, 0,
    6365. 

  6365. 	{ 6257,-303,-1000,-7880,15621,2396,-1714,1904,7046 } },
    6366. 

  6366.     { "Canon EOS 40D", 0, 0x3f60,
    6367. 

  6367. 	{ 6071,-747,-856,-7653,15365,2441,-2025,2553,7315 } },
    6368. 

  6368.     { "Canon EOS 50D", 0, 0x3d93,
    6369. 

  6369. 	{ 4920,616,-593,-6493,13964,2784,-1774,3178,7005 } },
    6370. 

  6370.     { "Canon EOS 60D", 0, 0x2ff7,
    6371. 

  6371. 	{ 6719,-994,-925,-4408,12426,2211,-887,2129,6051 } },
    6372. 

  6372.     { "Canon EOS 300D", 0, 0xfa0,
    6373. 

  6373. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6374. 

  6374.     { "Canon EOS 350D", 0, 0xfff,
    6375. 

  6375. 	{ 6018,-617,-965,-8645,15881,2975,-1530,1719,7642 } },
    6376. 

  6376.     { "Canon EOS 400D", 0, 0xe8e,
    6377. 

  6377. 	{ 7054,-1501,-990,-8156,15544,2812,-1278,1414,7796 } },
    6378. 

  6378.     { "Canon EOS 450D", 0, 0x390d,
    6379. 

  6379. 	{ 5784,-262,-821,-7539,15064,2672,-1982,2681,7427 } },
    6380. 

  6380.     { "Canon EOS 500D", 0, 0x3479,
    6381. 

  6381. 	{ 4763,712,-646,-6821,14399,2640,-1921,3276,6561 } },
    6382. 

  6382.     { "Canon EOS 550D", 0, 0x3dd7,
    6383. 

  6383. 	{ 6941,-1164,-857,-3825,11597,2534,-416,1540,6039 } },
    6384. 

  6384.     { "Canon EOS 600D", 0, 0x3510,
    6385. 

  6385. 	{ 6461,-907,-882,-4300,12184,2378,-819,1944,5931 } },
    6386. 

  6386.     { "Canon EOS 650D", 0, 0x354d,
    6387. 

  6387. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6388. 

  6388.     { "Canon EOS 700D", 0, 0x354d,
    6389. 

  6389. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6390. 

  6390.     { "Canon EOS REBEL T5i", 0, 0x354d,
    6391. 

  6391. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6392. 

  6392.     { "Canon EOS 1000D", 0, 0xe43,
    6393. 

  6393. 	{ 6771,-1139,-977,-7818,15123,2928,-1244,1437,7533 } },
    6394. 

  6394.     { "Canon EOS 1100D", 0, 0x3510,
    6395. 

  6395. 	{ 6444,-904,-893,-4563,12308,2535,-903,2016,6728 } },
    6396. 

  6396.     { "Canon EOS M", 0, 0,
    6397. 

  6397. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6398. 

  6398.     { "Canon EOS-1Ds Mark III", 0, 0x3bb0,
    6399. 

  6399. 	{ 5859,-211,-930,-8255,16017,2353,-1732,1887,7448 } },
    6400. 

  6400.     { "Canon EOS-1Ds Mark II", 0, 0xe80,
    6401. 

  6401. 	{ 6517,-602,-867,-8180,15926,2378,-1618,1771,7633 } },
    6402. 

  6402.     { "Canon EOS-1D Mark IV", 0, 0x3bb0,
    6403. 

  6403. 	{ 6014,-220,-795,-4109,12014,2361,-561,1824,5787 } },
    6404. 

  6404.     { "Canon EOS-1D Mark III", 0, 0x3bb0,
    6405. 

  6405. 	{ 6291,-540,-976,-8350,16145,2311,-1714,1858,7326 } },
    6406. 

  6406.     { "Canon EOS-1D Mark II N", 0, 0xe80,
    6407. 

  6407. 	{ 6240,-466,-822,-8180,15825,2500,-1801,1938,8042 } },
    6408. 

  6408.     { "Canon EOS-1D Mark II", 0, 0xe80,
    6409. 

  6409. 	{ 6264,-582,-724,-8312,15948,2504,-1744,1919,8664 } },
    6410. 

  6410.     { "Canon EOS-1DS", 0, 0xe20,
    6411. 

  6411. 	{ 4374,3631,-1743,-7520,15212,2472,-2892,3632,8161 } },
    6412. 

  6412.     { "Canon EOS-1D X", 0, 0x3c4e,
    6413. 

  6413. 	{ 6847,-614,-1014,-4669,12737,2139,-1197,2488,6846 } },
    6414. 

  6414.     { "Canon EOS-1D", 0, 0xe20,
    6415. 

  6415. 	{ 6806,-179,-1020,-8097,16415,1687,-3267,4236,7690 } },
    6416. 

  6416.     { "Canon EOS 100D", 0, 0x3cf0,
    6417. 

  6417. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6418. 

  6418.     { "Canon EOS REBEL SL1", 0, 0x3cf0,
    6419. 

  6419. 	{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
    6420. 

  6420.     { "Canon EOS", 0, 0,
    6421. 

  6421. 	{ 8197,-2000,-1118,-6714,14335,2592,-2536,3178,8266 } },
    6422. 

  6422.     { "Canon PowerShot A530", 0, 0,
    6423. 

  6423. 	{ 0 } },	/* don't want the A5 matrix */
    6424. 

  6424.     { "Canon PowerShot A50", 0, 0,
    6425. 

  6425. 	{ -5300,9846,1776,3436,684,3939,-5540,9879,6200,-1404,11175,217 } },
    6426. 

  6426.     { "Canon PowerShot A5", 0, 0,
    6427. 

  6427. 	{ -4801,9475,1952,2926,1611,4094,-5259,10164,5947,-1554,10883,547 } },
    6428. 

  6428.     { "Canon PowerShot G10", 0, 0,
    6429. 

  6429. 	{ 11093,-3906,-1028,-5047,12492,2879,-1003,1750,5561 } },
    6430. 

  6430.     { "Canon PowerShot G11", 0, 0,
    6431. 

  6431. 	{ 12177,-4817,-1069,-1612,9864,2049,-98,850,4471 } },
    6432. 

  6432.     { "Canon PowerShot G12", 0, 0,
    6433. 

  6433. 	{ 13244,-5501,-1248,-1508,9858,1935,-270,1083,4366 } },
    6434. 

  6434.     { "Canon PowerShot G15", 0, 0,
    6435. 

  6435. 	{ 7474,-2301,-567,-4056,11456,2975,-222,716,4181 } },
    6436. 

  6436.     { "Canon PowerShot G1 X", 0, 0,
    6437. 

  6437. 	{ 7378,-1255,-1043,-4088,12251,2048,-876,1946,5805 } },
    6438. 

  6438.     { "Canon PowerShot G1", 0, 0,
    6439. 

  6439. 	{ -4778,9467,2172,4743,-1141,4344,-5146,9908,6077,-1566,11051,557 } },
    6440. 

  6440.     { "Canon PowerShot G2", 0, 0,
    6441. 

  6441. 	{ 9087,-2693,-1049,-6715,14382,2537,-2291,2819,7790 } },
    6442. 

  6442.     { "Canon PowerShot G3", 0, 0,
    6443. 

  6443. 	{ 9212,-2781,-1073,-6573,14189,2605,-2300,2844,7664 } },
    6444. 

  6444.     { "Canon PowerShot G5", 0, 0,
    6445. 

  6445. 	{ 9757,-2872,-933,-5972,13861,2301,-1622,2328,7212 } },
    6446. 

  6446.     { "Canon PowerShot G6", 0, 0,
    6447. 

  6447. 	{ 9877,-3775,-871,-7613,14807,3072,-1448,1305,7485 } },
    6448. 

  6448.     { "Canon PowerShot G9", 0, 0,
    6449. 

  6449. 	{ 7368,-2141,-598,-5621,13254,2625,-1418,1696,5743 } },
    6450. 

  6450.     { "Canon PowerShot Pro1", 0, 0,
    6451. 

  6451. 	{ 10062,-3522,-999,-7643,15117,2730,-765,817,7323 } },
    6452. 

  6452.     { "Canon PowerShot Pro70", 34, 0,
    6453. 

  6453. 	{ -4155,9818,1529,3939,-25,4522,-5521,9870,6610,-2238,10873,1342 } },
    6454. 

  6454.     { "Canon PowerShot Pro90", 0, 0,
    6455. 

  6455. 	{ -4963,9896,2235,4642,-987,4294,-5162,10011,5859,-1770,11230,577 } },
    6456. 

  6456.     { "Canon PowerShot S30", 0, 0,
    6457. 

  6457. 	{ 10566,-3652,-1129,-6552,14662,2006,-2197,2581,7670 } },
    6458. 

  6458.     { "Canon PowerShot S40", 0, 0,
    6459. 

  6459. 	{ 8510,-2487,-940,-6869,14231,2900,-2318,2829,9013 } },
    6460. 

  6460.     { "Canon PowerShot S45", 0, 0,
    6461. 

  6461. 	{ 8163,-2333,-955,-6682,14174,2751,-2077,2597,8041 } },
    6462. 

  6462.     { "Canon PowerShot S50", 0, 0,
    6463. 

  6463. 	{ 8882,-2571,-863,-6348,14234,2288,-1516,2172,6569 } },
    6464. 

  6464.     { "Canon PowerShot S60", 0, 0,
    6465. 

  6465. 	{ 8795,-2482,-797,-7804,15403,2573,-1422,1996,7082 } },
    6466. 

  6466.     { "Canon PowerShot S70", 0, 0,
    6467. 

  6467. 	{ 9976,-3810,-832,-7115,14463,2906,-901,989,7889 } },
    6468. 

  6468.     { "Canon PowerShot S90", 0, 0,
    6469. 

  6469. 	{ 12374,-5016,-1049,-1677,9902,2078,-83,852,4683 } },
    6470. 

  6470.     { "Canon PowerShot S95", 0, 0,
    6471. 

  6471. 	{ 13440,-5896,-1279,-1236,9598,1931,-180,1001,4651 } },
    6472. 

  6472.     { "Canon PowerShot S110", 0, 0,
    6473. 

  6473. 	{ 8039,-2643,-654,-3783,11230,2930,-206,690,4194 } },
    6474. 

  6474.     { "Canon PowerShot S100", 0, 0,
    6475. 

  6475. 	{ 7968,-2565,-636,-2873,10697,2513,180,667,4211 } },
    6476. 

  6476.     { "Canon PowerShot S110", 0, 0,
    6477. 

  6477. 	{ 8039,-2643,-654,-3783,11230,2930,-206,690,4194 } },
    6478. 

  6478.     { "Canon PowerShot SX1 IS", 0, 0,
    6479. 

  6479. 	{ 6578,-259,-502,-5974,13030,3309,-308,1058,4970 } },
    6480. 

  6480.     { "Canon PowerShot SX50 HS", 0, 0,
    6481. 

  6481. 	{ 12432,-4753,-1247,-2110,10691,1629,-412,1623,4926 } },
    6482. 

  6482.     { "Canon PowerShot A470", 0, 0,	/* DJC */
    6483. 

  6483. 	{ 12513,-4407,-1242,-2680,10276,2405,-878,2215,4734 } },
    6484. 

  6484.     { "Canon PowerShot A610", 0, 0,	/* DJC */
    6485. 

  6485. 	{ 15591,-6402,-1592,-5365,13198,2168,-1300,1824,5075 } },
    6486. 

  6486.     { "Canon PowerShot A620", 0, 0,	/* DJC */
    6487. 

  6487. 	{ 15265,-6193,-1558,-4125,12116,2010,-888,1639,5220 } },
    6488. 

  6488.     { "Canon PowerShot A630", 0, 0,	/* DJC */
    6489. 

  6489. 	{ 14201,-5308,-1757,-6087,14472,1617,-2191,3105,5348 } },
    6490. 

  6490.     { "Canon PowerShot A640", 0, 0,	/* DJC */
    6491. 

  6491. 	{ 13124,-5329,-1390,-3602,11658,1944,-1612,2863,4885 } },
    6492. 

  6492.     { "Canon PowerShot A650", 0, 0,	/* DJC */
    6493. 

  6493. 	{ 9427,-3036,-959,-2581,10671,1911,-1039,1982,4430 } },
    6494. 

  6494.     { "Canon PowerShot A720", 0, 0,	/* DJC */
    6495. 

  6495. 	{ 14573,-5482,-1546,-1266,9799,1468,-1040,1912,3810 } },
    6496. 

  6496.     { "Canon PowerShot S3 IS", 0, 0,	/* DJC */
    6497. 

  6497. 	{ 14062,-5199,-1446,-4712,12470,2243,-1286,2028,4836 } },
    6498. 

  6498.     { "Canon PowerShot SX110 IS", 0, 0,	/* DJC */
    6499. 

  6499. 	{ 14134,-5576,-1527,-1991,10719,1273,-1158,1929,3581 } },
    6500. 

  6500.     { "Canon PowerShot SX220", 0, 0,	/* DJC */
    6501. 

  6501. 	{ 13898,-5076,-1447,-1405,10109,1297,-244,1860,3687 } },
    6502. 

  6502.     { "Canon PowerShot SX50", 0, 0,
    6503. 

  6503. 	{ 12432,-4753,-1247,-2110,10691,1629,-412,1623,4926 } },
    6504. 

  6504.     { "CASIO EX-S20", 0, 0,		/* DJC */
    6505. 

  6505. 	{ 11634,-3924,-1128,-4968,12954,2015,-1588,2648,7206 } },
    6506. 

  6506.     { "CASIO EX-Z750", 0, 0,		/* DJC */
    6507. 

  6507. 	{ 10819,-3873,-1099,-4903,13730,1175,-1755,3751,4632 } },
    6508. 

  6508.     { "CASIO EX-Z10", 128, 0xfff,	/* DJC */
    6509. 

  6509. 	{ 9790,-3338,-603,-2321,10222,2099,-344,1273,4799 } },
    6510. 

  6510.     { "CINE 650", 0, 0,
    6511. 

  6511. 	{ 3390,480,-500,-800,3610,340,-550,2336,1192 } },
    6512. 

  6512.     { "CINE 660", 0, 0,
    6513. 

  6513. 	{ 3390,480,-500,-800,3610,340,-550,2336,1192 } },
    6514. 

  6514.     { "CINE", 0, 0,
    6515. 

  6515. 	{ 20183,-4295,-423,-3940,15330,3985,-280,4870,9800 } },
    6516. 

  6516.     { "Contax N Digital", 0, 0xf1e,
    6517. 

  6517. 	{ 7777,1285,-1053,-9280,16543,2916,-3677,5679,7060 } },
    6518. 

  6518.     { "EPSON R-D1", 0, 0,
    6519. 

  6519. 	{ 6827,-1878,-732,-8429,16012,2564,-704,592,7145 } },
    6520. 

  6520.     { "FUJIFILM E550", 0, 0,
    6521. 

  6521. 	{ 11044,-3888,-1120,-7248,15168,2208,-1531,2277,8069 } },
    6522. 

  6522.     { "FUJIFILM E900", 0, 0,
    6523. 

  6523. 	{ 9183,-2526,-1078,-7461,15071,2574,-2022,2440,8639 } },
    6524. 

  6524.     { "FUJIFILM F5", 0, 0,
    6525. 

  6525. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6526. 

  6526.     { "FUJIFILM F6", 0, 0,
    6527. 

  6527. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6528. 

  6528.     { "FUJIFILM F77", 0, 0xfe9,
    6529. 

  6529. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6530. 

  6530.     { "FUJIFILM F7", 0, 0,
    6531. 

  6531. 	{ 10004,-3219,-1201,-7036,15047,2107,-1863,2565,7736 } },
    6532. 

  6532.     { "FUJIFILM F800", 0, 0,
    6533. 

  6533. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6534. 

  6534.     { "FUJIFILM F8", 0, 0,
    6535. 

  6535. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6536. 

  6536.     { "FUJIFILM S100FS", 514, 0,
    6537. 

  6537. 	{ 11521,-4355,-1065,-6524,13767,3058,-1466,1984,6045 } },
    6538. 

  6538.     { "FUJIFILM S200EXR", 512, 0x3fff,
    6539. 

  6539. 	{ 11401,-4498,-1312,-5088,12751,2613,-838,1568,5941 } },
    6540. 

  6540.     { "FUJIFILM S20Pro", 0, 0,
    6541. 

  6541. 	{ 10004,-3219,-1201,-7036,15047,2107,-1863,2565,7736 } },
    6542. 

  6542.     { "FUJIFILM S2Pro", 128, 0,
    6543. 

  6543. 	{ 12492,-4690,-1402,-7033,15423,1647,-1507,2111,7697 } },
    6544. 

  6544.     { "FUJIFILM S3Pro", 0, 0,
    6545. 

  6545. 	{ 11807,-4612,-1294,-8927,16968,1988,-2120,2741,8006 } },
    6546. 

  6546.     { "FUJIFILM S5Pro", 0, 0,
    6547. 

  6547. 	{ 12300,-5110,-1304,-9117,17143,1998,-1947,2448,8100 } },
    6548. 

  6548.     { "FUJIFILM S5000", 0, 0,
    6549. 

  6549. 	{ 8754,-2732,-1019,-7204,15069,2276,-1702,2334,6982 } },
    6550. 

  6550.     { "FUJIFILM S5100", 0, 0,
    6551. 

  6551. 	{ 11940,-4431,-1255,-6766,14428,2542,-993,1165,7421 } },
    6552. 

  6552.     { "FUJIFILM S5500", 0, 0,
    6553. 

  6553. 	{ 11940,-4431,-1255,-6766,14428,2542,-993,1165,7421 } },
    6554. 

  6554.     { "FUJIFILM S5200", 0, 0,
    6555. 

  6555. 	{ 9636,-2804,-988,-7442,15040,2589,-1803,2311,8621 } },
    6556. 

  6556.     { "FUJIFILM S5600", 0, 0,
    6557. 

  6557. 	{ 9636,-2804,-988,-7442,15040,2589,-1803,2311,8621 } },
    6558. 

  6558.     { "FUJIFILM S6", 0, 0,
    6559. 

  6559. 	{ 12628,-4887,-1401,-6861,14996,1962,-2198,2782,7091 } },
    6560. 

  6560.     { "FUJIFILM S7000", 0, 0,
    6561. 

  6561. 	{ 10190,-3506,-1312,-7153,15051,2238,-2003,2399,7505 } },
    6562. 

  6562.     { "FUJIFILM S9000", 0, 0,
    6563. 

  6563. 	{ 10491,-3423,-1145,-7385,15027,2538,-1809,2275,8692 } },
    6564. 

  6564.     { "FUJIFILM S9500", 0, 0,
    6565. 

  6565. 	{ 10491,-3423,-1145,-7385,15027,2538,-1809,2275,8692 } },
    6566. 

  6566.     { "FUJIFILM S9100", 0, 0,
    6567. 

  6567. 	{ 12343,-4515,-1285,-7165,14899,2435,-1895,2496,8800 } },
    6568. 

  6568.     { "FUJIFILM S9600", 0, 0,
    6569. 

  6569. 	{ 12343,-4515,-1285,-7165,14899,2435,-1895,2496,8800 } },
    6570. 

  6570.     { "FUJIFILM IS-1", 0, 0,
    6571. 

  6571. 	{ 21461,-10807,-1441,-2332,10599,1999,289,875,7703 } },
    6572. 

  6572.     { "FUJIFILM IS Pro", 0, 0,
    6573. 

  6573. 	{ 12300,-5110,-1304,-9117,17143,1998,-1947,2448,8100 } },
    6574. 

  6574.     { "FUJIFILM HS10 HS11", 0, 0xf68,
    6575. 

  6575. 	{ 12440,-3954,-1183,-1123,9674,1708,-83,1614,4086 } },
    6576. 

  6576.     { "FUJIFILM HS20EXR", 0, 0,
    6577. 

  6577. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6578. 

  6578.     { "FUJIFILM HS3", 0, 0,
    6579. 

  6579. 	{ 13690,-5358,-1474,-3369,11600,1998,-132,1554,4395 } },
    6580. 

  6580.     { "FUJIFILM HS50EXR", 0, 0,
    6581. 

  6581. 	{ 12085,-4727,-953,-3257,11489,2002,-511,2046,4592 } },
    6582. 

  6582.     { "FUJIFILM SL1000", 0, 0,
    6583. 

  6583. 	{ 11705,-4262,-1107,-2282,10791,1709,-555,1713,4945 } },
    6584. 

  6584.     { "FUJIFILM X100S", 0, 0,
    6585. 

  6585. 	{ 10592,-4262,-1008,-3514,11355,2465,-870,2025,6386 } },
    6586. 

  6586.     { "FUJIFILM X100", 0, 0,
    6587. 

  6587. 	{ 12161,-4457,-1069,-5034,12874,2400,-795,1724,6904 } },
    6588. 

  6588.     { "FUJIFILM X10", 0, 0,
    6589. 

  6589. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6590. 

  6590.     { "FUJIFILM X20", 0, 0,
    6591. 

  6591. 	{ 11768,-4971,-1133,-4904,12927,2183,-480,1723,4605 } },
    6592. 

  6592.     { "FUJIFILM XF1", 0, 0,
    6593. 

  6593. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6594. 

  6594.     { "FUJIFILM X-Pro1", 0, 0,
    6595. 

  6595. 	{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
    6596. 

  6596.     { "FUJIFILM X-E1", 0, 0,
    6597. 

  6597. 	{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
    6598. 

  6598.     { "FUJIFILM XF1", 0, 0,
    6599. 

  6599. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6600. 

  6600.     { "FUJIFILM X-S1", 0, 0,
    6601. 

  6601. 	{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
    6602. 

  6602.     { "Imacon Ixpress", 0, 0,		/* DJC */
    6603. 

  6603. 	{ 7025,-1415,-704,-5188,13765,1424,-1248,2742,6038 } },
    6604. 

  6604.     { "KODAK NC2000", 0, 0,
    6605. 

  6605. 	{ 13891,-6055,-803,-465,9919,642,2121,82,1291 } },
    6606. 

  6606.     { "Kodak DCS315C", 8, 0,
    6607. 

  6607. 	{ 17523,-4827,-2510,756,8546,-137,6113,1649,2250 } },
    6608. 

  6608.     { "Kodak DCS330C", 8, 0,
    6609. 

  6609. 	{ 20620,-7572,-2801,-103,10073,-396,3551,-233,2220 } },
    6610. 

  6610.     { "KODAK DCS420", 0, 0,
    6611. 

  6611. 	{ 10868,-1852,-644,-1537,11083,484,2343,628,2216 } },
    6612. 

  6612.     { "KODAK DCS460", 0, 0,
    6613. 

  6613. 	{ 10592,-2206,-967,-1944,11685,230,2206,670,1273 } },
    6614. 

  6614.     { "KODAK EOSDCS1", 0, 0,
    6615. 

  6615. 	{ 10592,-2206,-967,-1944,11685,230,2206,670,1273 } },
    6616. 

  6616.     { "KODAK EOSDCS3B", 0, 0,
    6617. 

  6617. 	{ 9898,-2700,-940,-2478,12219,206,1985,634,1031 } },
    6618. 

  6618.     { "Kodak DCS520C", 178, 0,
    6619. 

  6619. 	{ 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } },
    6620. 

  6620.     { "Kodak DCS560C", 177, 0,
    6621. 

  6621. 	{ 20482,-7172,-3125,-1033,10410,-285,2542,226,3136 } },
    6622. 

  6622.     { "Kodak DCS620C", 177, 0,
    6623. 

  6623. 	{ 23617,-10175,-3149,-2054,11749,-272,2586,-489,3453 } },
    6624. 

  6624.     { "Kodak DCS620X", 176, 0,
    6625. 

  6625. 	{ 13095,-6231,154,12221,-21,-2137,895,4602,2258 } },
    6626. 

  6626.     { "Kodak DCS660C", 173, 0,
    6627. 

  6627. 	{ 18244,-6351,-2739,-791,11193,-521,3711,-129,2802 } },
    6628. 

  6628.     { "Kodak DCS720X", 0, 0,
    6629. 

  6629. 	{ 11775,-5884,950,9556,1846,-1286,-1019,6221,2728 } },
    6630. 

  6630.     { "Kodak DCS760C", 0, 0,
    6631. 

  6631. 	{ 16623,-6309,-1411,-4344,13923,323,2285,274,2926 } },
    6632. 

  6632.     { "Kodak DCS Pro SLR", 0, 0,
    6633. 

  6633. 	{ 5494,2393,-232,-6427,13850,2846,-1876,3997,5445 } },
    6634. 

  6634.     { "Kodak DCS Pro 14nx", 0, 0,
    6635. 

  6635. 	{ 5494,2393,-232,-6427,13850,2846,-1876,3997,5445 } },
    6636. 

  6636.     { "Kodak DCS Pro 14", 0, 0,
    6637. 

  6637. 	{ 7791,3128,-776,-8588,16458,2039,-2455,4006,6198 } },
    6638. 

  6638.     { "Kodak ProBack645", 0, 0,
    6639. 

  6639. 	{ 16414,-6060,-1470,-3555,13037,473,2545,122,4948 } },
    6640. 

  6640.     { "Kodak ProBack", 0, 0,
    6641. 

  6641. 	{ 21179,-8316,-2918,-915,11019,-165,3477,-180,4210 } },
    6642. 

  6642.     { "KODAK P712", 0, 0,
    6643. 

  6643. 	{ 9658,-3314,-823,-5163,12695,2768,-1342,1843,6044 } },
    6644. 

  6644.     { "KODAK P850", 0, 0xf7c,
    6645. 

  6645. 	{ 10511,-3836,-1102,-6946,14587,2558,-1481,1792,6246 } },
    6646. 

  6646.     { "KODAK P880", 0, 0xfff,
    6647. 

  6647. 	{ 12805,-4662,-1376,-7480,15267,2360,-1626,2194,7904 } },
    6648. 

  6648.     { "KODAK EasyShare Z980", 0, 0,
    6649. 

  6649. 	{ 11313,-3559,-1101,-3893,11891,2257,-1214,2398,4908 } },
    6650. 

  6650.     { "KODAK EasyShare Z981", 0, 0,
    6651. 

  6651. 	{ 12729,-4717,-1188,-1367,9187,2582,274,860,4411 } },
    6652. 

  6652.     { "KODAK EasyShare Z990", 0, 0xfed,
    6653. 

  6653. 	{ 11749,-4048,-1309,-1867,10572,1489,-138,1449,4522 } },
    6654. 

  6654.     { "KODAK EASYSHARE Z1015", 0, 0xef1,
    6655. 

  6655. 	{ 11265,-4286,-992,-4694,12343,2647,-1090,1523,5447 } },
    6656. 

  6656.     { "Leaf CMost", 0, 0,
    6657. 

  6657. 	{ 3952,2189,449,-6701,14585,2275,-4536,7349,6536 } },
    6658. 

  6658.     { "Leaf Valeo 6", 0, 0,
    6659. 

  6659. 	{ 3952,2189,449,-6701,14585,2275,-4536,7349,6536 } },
    6660. 

  6660.     { "Leaf Aptus 54S", 0, 0,
    6661. 

  6661. 	{ 8236,1746,-1314,-8251,15953,2428,-3673,5786,5771 } },
    6662. 

  6662.     { "Leaf Aptus 65", 0, 0,
    6663. 

  6663. 	{ 7914,1414,-1190,-8777,16582,2280,-2811,4605,5562 } },
    6664. 

  6664.     { "Leaf Aptus 75", 0, 0,
    6665. 

  6665. 	{ 7914,1414,-1190,-8777,16582,2280,-2811,4605,5562 } },
    6666. 

  6666.     { "Leaf", 0, 0,
    6667. 

  6667. 	{ 8236,1746,-1314,-8251,15953,2428,-3673,5786,5771 } },
    6668. 

  6668.     { "Mamiya ZD", 0, 0,
    6669. 

  6669. 	{ 7645,2579,-1363,-8689,16717,2015,-3712,5941,5961 } },
    6670. 

  6670.     { "Micron 2010", 110, 0,		/* DJC */
    6671. 

  6671. 	{ 16695,-3761,-2151,155,9682,163,3433,951,4904 } },
    6672. 

  6672.     { "Minolta DiMAGE 5", 0, 0xf7d,
    6673. 

  6673. 	{ 8983,-2942,-963,-6556,14476,2237,-2426,2887,8014 } },
    6674. 

  6674.     { "Minolta DiMAGE 7Hi", 0, 0xf7d,
    6675. 

  6675. 	{ 11368,-3894,-1242,-6521,14358,2339,-2475,3056,7285 } },
    6676. 

  6676.     { "Minolta DiMAGE 7", 0, 0xf7d,
    6677. 

  6677. 	{ 9144,-2777,-998,-6676,14556,2281,-2470,3019,7744 } },
    6678. 

  6678.     { "Minolta DiMAGE A1", 0, 0xf8b,
    6679. 

  6679. 	{ 9274,-2547,-1167,-8220,16323,1943,-2273,2720,8340 } },
    6680. 

  6680.     { "MINOLTA DiMAGE A200", 0, 0,
    6681. 

  6681. 	{ 8560,-2487,-986,-8112,15535,2771,-1209,1324,7743 } },
    6682. 

  6682.     { "Minolta DiMAGE A2", 0, 0xf8f,
    6683. 

  6683. 	{ 9097,-2726,-1053,-8073,15506,2762,-966,981,7763 } },
    6684. 

  6684.     { "Minolta DiMAGE Z2", 0, 0,	/* DJC */
    6685. 

  6685. 	{ 11280,-3564,-1370,-4655,12374,2282,-1423,2168,5396 } },
    6686. 

  6686.     { "MINOLTA DYNAX 5", 0, 0xffb,
    6687. 

  6687. 	{ 10284,-3283,-1086,-7957,15762,2316,-829,882,6644 } },
    6688. 

  6688.     { "MINOLTA DYNAX 7", 0, 0xffb,
    6689. 

  6689. 	{ 10239,-3104,-1099,-8037,15727,2451,-927,925,6871 } },
    6690. 

  6690.     { "MOTOROLA PIXL", 0, 0,		/* DJC */
    6691. 

  6691. 	{ 8898,-989,-1033,-3292,11619,1674,-661,3178,5216 } },
    6692. 

  6692.     { "NIKON D100", 0, 0,
    6693. 

  6693. 	{ 5902,-933,-782,-8983,16719,2354,-1402,1455,6464 } },
    6694. 

  6694.     { "NIKON D1H", 0, 0,
    6695. 

  6695. 	{ 7577,-2166,-926,-7454,15592,1934,-2377,2808,8606 } },
    6696. 

  6696.     { "NIKON D1X", 0, 0,
    6697. 

  6697. 	{ 7702,-2245,-975,-9114,17242,1875,-2679,3055,8521 } },
    6698. 

  6698.     { "NIKON D1", 0, 0, /* multiplied by 2.218750, 1.0, 1.148438 */
    6699. 

  6699. 	{ 16772,-4726,-2141,-7611,15713,1972,-2846,3494,9521 } },
    6700. 

  6700.     { "NIKON D200", 0, 0xfbc,
    6701. 

  6701. 	{ 8367,-2248,-763,-8758,16447,2422,-1527,1550,8053 } },
    6702. 

  6702.     { "NIKON D2H", 0, 0,
    6703. 

  6703. 	{ 5710,-901,-615,-8594,16617,2024,-2975,4120,6830 } },
    6704. 

  6704.     { "NIKON D2X", 0, 0,
    6705. 

  6705. 	{ 10231,-2769,-1255,-8301,15900,2552,-797,680,7148 } },
    6706. 

  6706.     { "NIKON D3000", 0, 0,
    6707. 

  6707. 	{ 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
    6708. 

  6708.     { "NIKON D3100", 0, 0,
    6709. 

  6709. 	{ 7911,-2167,-813,-5327,13150,2408,-1288,2483,7968 } },
    6710. 

  6710.     { "NIKON D3200", 0, 0xfb9,
    6711. 

  6711. 	{ 7013,-1408,-635,-5268,12902,2640,-1470,2801,7379 } },
    6712. 

  6712.     { "NIKON D300", 0, 0,
    6713. 

  6713. 	{ 9030,-1992,-715,-8465,16302,2255,-2689,3217,8069 } },
    6714. 

  6714.     { "NIKON D3X", 0, 0,
    6715. 

  6715. 	{ 7171,-1986,-648,-8085,15555,2718,-2170,2512,7457 } },
    6716. 

  6716.     { "NIKON D3S", 0, 0,
    6717. 

  6717. 	{ 8828,-2406,-694,-4874,12603,2541,-660,1509,7587 } },
    6718. 

  6718.     { "NIKON D3", 0, 0,
    6719. 

  6719. 	{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
    6720. 

  6720.     { "NIKON D40X", 0, 0,
    6721. 

  6721. 	{ 8819,-2543,-911,-9025,16928,2151,-1329,1213,8449 } },
    6722. 

  6722.     { "NIKON D40", 0, 0,
    6723. 

  6723. 	{ 6992,-1668,-806,-8138,15748,2543,-874,850,7897 } },
    6724. 

  6724.     { "NIKON D4", 0, 0,
    6725. 

  6725. 	{ 8598,-2848,-857,-5618,13606,2195,-1002,1773,7137 } },
    6726. 

  6726.     { "NIKON D5000", 0, 0xf00,
    6727. 

  6727. 	{ 7309,-1403,-519,-8474,16008,2622,-2433,2826,8064 } },
    6728. 

  6728.     { "NIKON D5100", 0, 0x3de6,
    6729. 

  6729. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6730. 

  6730.     { "NIKON D5200", 0, 0,
    6731. 

  6731. 	{ 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
    6732. 

  6732.     { "NIKON D50", 0, 0,
    6733. 

  6733. 	{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
    6734. 

  6734.     { "NIKON D600", 0, 0x3e07,
    6735. 

  6735. 	{ 8178,-2245,-609,-4857,12394,2776,-1207,2086,7298 } },
    6736. 

  6736.     { "NIKON D60", 0, 0,
    6737. 

  6737. 	{ 8736,-2458,-935,-9075,16894,2251,-1354,1242,8263 } },
    6738. 

  6738.     { "NIKON D7000", 0, 0,
    6739. 

  6739. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6740. 

  6740.     { "NIKON D700", 0, 0,
    6741. 

  6741. 	{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
    6742. 

  6742.     { "NIKON D70", 0, 0,
    6743. 

  6743. 	{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
    6744. 

  6744.     { "NIKON D7100", 0, 0,
    6745. 

  6745. 	{ 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
    6746. 

  6746.     { "NIKON D800", 0, 0,
    6747. 

  6747. 	{ 7866,-2108,-555,-4869,12483,2681,-1176,2069,7501 } },
    6748. 

  6748.     { "NIKON D80", 0, 0,
    6749. 

  6749. 	{ 8629,-2410,-883,-9055,16940,2171,-1490,1363,8520 } },
    6750. 

  6750.     { "NIKON D90", 0, 0xf00,
    6751. 

  6751. 	{ 7309,-1403,-519,-8474,16008,2622,-2434,2826,8064 } },
    6752. 

  6752.     { "NIKON E950", 0, 0x3dd,		/* DJC */
    6753. 

  6753. 	{ -3746,10611,1665,9621,-1734,2114,-2389,7082,3064,3406,6116,-244 } },
    6754. 

  6754.     { "NIKON E995", 0, 0,	/* copied from E5000 */
    6755. 

  6755. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6756. 

  6756.     { "NIKON E2100", 0, 0,	/* copied from Z2, new white balance */
    6757. 

  6757. 	{ 13142,-4152,-1596,-4655,12374,2282,-1769,2696,6711} },
    6758. 

  6758.     { "NIKON E2500", 0, 0,
    6759. 

  6759. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6760. 

  6760.     { "NIKON E3200", 0, 0,		/* DJC */
    6761. 

  6761. 	{ 9846,-2085,-1019,-3278,11109,2170,-774,2134,5745 } },
    6762. 

  6762.     { "NIKON E4300", 0, 0,	/* copied from Minolta DiMAGE Z2 */
    6763. 

  6763. 	{ 11280,-3564,-1370,-4655,12374,2282,-1423,2168,5396 } },
    6764. 

  6764.     { "NIKON E4500", 0, 0,
    6765. 

  6765. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6766. 

  6766.     { "NIKON E5000", 0, 0,
    6767. 

  6767. 	{ -5547,11762,2189,5814,-558,3342,-4924,9840,5949,688,9083,96 } },
    6768. 

  6768.     { "NIKON E5400", 0, 0,
    6769. 

  6769. 	{ 9349,-2987,-1001,-7919,15766,2266,-2098,2680,6839 } },
    6770. 

  6770.     { "NIKON E5700", 0, 0,
    6771. 

  6771. 	{ -5368,11478,2368,5537,-113,3148,-4969,10021,5782,778,9028,211 } },
    6772. 

  6772.     { "NIKON E8400", 0, 0,
    6773. 

  6773. 	{ 7842,-2320,-992,-8154,15718,2599,-1098,1342,7560 } },
    6774. 

  6774.     { "NIKON E8700", 0, 0,
    6775. 

  6775. 	{ 8489,-2583,-1036,-8051,15583,2643,-1307,1407,7354 } },
    6776. 

  6776.     { "NIKON E8800", 0, 0,
    6777. 

  6777. 	{ 7971,-2314,-913,-8451,15762,2894,-1442,1520,7610 } },
    6778. 

  6778.     { "NIKON COOLPIX A", 0, 0,
    6779. 

  6779. 	{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
    6780. 

  6780.     { "NIKON COOLPIX P330", 0, 0,
    6781. 

  6781. 	{ 10321,-3920,-931,-2750,11146,1824,-442,1545,5539 } },
    6782. 

  6782.     { "NIKON COOLPIX P6000", 0, 0,
    6783. 

  6783. 	{ 9698,-3367,-914,-4706,12584,2368,-837,968,5801 } },
    6784. 

  6784.     { "NIKON COOLPIX P7000", 0, 0,
    6785. 

  6785. 	{ 11432,-3679,-1111,-3169,11239,2202,-791,1380,4455 } },
    6786. 

  6786.     { "NIKON COOLPIX P7100", 0, 0,
    6787. 

  6787. 	{ 11053,-4269,-1024,-1976,10182,2088,-526,1263,4469 } },
    6788. 

  6788.     { "NIKON COOLPIX P7700", 200, 0,
    6789. 

  6789. 	{ 10321,-3920,-931,-2750,11146,1824,-442,1545,5539 } },
    6790. 

  6790.     { "NIKON 1 J3", 0, 0,
    6791. 

  6791. 	{ 6588,-1305,-693,-3277,10987,2634,-355,2016,5106 } },
    6792. 

  6792.     { "NIKON 1 S1", 0, 0,
    6793. 

  6793. 	{ 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
    6794. 

  6794.     { "NIKON 1 V2", 0, 0,
    6795. 

  6795. 	{ 6588,-1305,-693,-3277,10987,2634,-355,2016,5106 } },
    6796. 

  6796.     { "NIKON 1 ", 0, 0,
    6797. 

  6797. 	{ 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
    6798. 

  6798.     { "OLYMPUS C5050", 0, 0,
    6799. 

  6799. 	{ 10508,-3124,-1273,-6079,14294,1901,-1653,2306,6237 } },
    6800. 

  6800.     { "OLYMPUS C5060", 0, 0,
    6801. 

  6801. 	{ 10445,-3362,-1307,-7662,15690,2058,-1135,1176,7602 } },
    6802. 

  6802.     { "OLYMPUS C7070", 0, 0,
    6803. 

  6803. 	{ 10252,-3531,-1095,-7114,14850,2436,-1451,1723,6365 } },
    6804. 

  6804.     { "OLYMPUS C70", 0, 0,
    6805. 

  6805. 	{ 10793,-3791,-1146,-7498,15177,2488,-1390,1577,7321 } },
    6806. 

  6806.     { "OLYMPUS C80", 0, 0,
    6807. 

  6807. 	{ 8606,-2509,-1014,-8238,15714,2703,-942,979,7760 } },
    6808. 

  6808.     { "OLYMPUS E-10", 0, 0xffc,
    6809. 

  6809. 	{ 12745,-4500,-1416,-6062,14542,1580,-1934,2256,6603 } },
    6810. 

  6810.     { "OLYMPUS E-1", 0, 0,
    6811. 

  6811. 	{ 11846,-4767,-945,-7027,15878,1089,-2699,4122,8311 } },
    6812. 

  6812.     { "OLYMPUS E-20", 0, 0xffc,
    6813. 

  6813. 	{ 13173,-4732,-1499,-5807,14036,1895,-2045,2452,7142 } },
    6814. 

  6814.     { "OLYMPUS E-300", 0, 0,
    6815. 

  6815. 	{ 7828,-1761,-348,-5788,14071,1830,-2853,4518,6557 } },
    6816. 

  6816.     { "OLYMPUS E-330", 0, 0,
    6817. 

  6817. 	{ 8961,-2473,-1084,-7979,15990,2067,-2319,3035,8249 } },
    6818. 

  6818.     { "OLYMPUS E-30", 0, 0xfbc,
    6819. 

  6819. 	{ 8144,-1861,-1111,-7763,15894,1929,-1865,2542,7607 } },
    6820. 

  6820.     { "OLYMPUS E-3", 0, 0xf99,
    6821. 

  6821. 	{ 9487,-2875,-1115,-7533,15606,2010,-1618,2100,7389 } },
    6822. 

  6822.     { "OLYMPUS E-400", 0, 0,
    6823. 

  6823. 	{ 6169,-1483,-21,-7107,14761,2536,-2904,3580,8568 } },
    6824. 

  6824.     { "OLYMPUS E-410", 0, 0xf6a,
    6825. 

  6825. 	{ 8856,-2582,-1026,-7761,15766,2082,-2009,2575,7469 } },
    6826. 

  6826.     { "OLYMPUS E-420", 0, 0xfd7,
    6827. 

  6827. 	{ 8746,-2425,-1095,-7594,15612,2073,-1780,2309,7416 } },
    6828. 

  6828.     { "OLYMPUS E-450", 0, 0xfd2,
    6829. 

  6829. 	{ 8745,-2425,-1095,-7594,15613,2073,-1780,2309,7416 } },
    6830. 

  6830.     { "OLYMPUS E-500", 0, 0,
    6831. 

  6831. 	{ 8136,-1968,-299,-5481,13742,1871,-2556,4205,6630 } },
    6832. 

  6832.     { "OLYMPUS E-510", 0, 0xf6a,
    6833. 

  6833. 	{ 8785,-2529,-1033,-7639,15624,2112,-1783,2300,7817 } },
    6834. 

  6834.     { "OLYMPUS E-520", 0, 0xfd2,
    6835. 

  6835. 	{ 8344,-2322,-1020,-7596,15635,2048,-1748,2269,7287 } },
    6836. 

  6836.     { "OLYMPUS E-5", 0, 0xeec,
    6837. 

  6837. 	{ 11200,-3783,-1325,-4576,12593,2206,-695,1742,7504 } },
    6838. 

  6838.     { "OLYMPUS E-600", 0, 0xfaf,
    6839. 

  6839. 	{ 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
    6840. 

  6840.     { "OLYMPUS E-620", 0, 0xfaf,
    6841. 

  6841. 	{ 8453,-2198,-1092,-7609,15681,2008,-1725,2337,7824 } },
    6842. 

  6842.     { "OLYMPUS E-P1", 0, 0xffd,
    6843. 

  6843. 	{ 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
    6844. 

  6844.     { "OLYMPUS E-P2", 0, 0xffd,
    6845. 

  6845. 	{ 8343,-2050,-1021,-7715,15705,2103,-1831,2380,8235 } },
    6846. 

  6846.     { "OLYMPUS E-P3", 0, 0,
    6847. 

  6847. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6848. 

  6848.     { "OLYMPUS E-PL1s", 0, 0,
    6849. 

  6849. 	{ 11409,-3872,-1393,-4572,12757,2003,-709,1810,7415 } },
    6850. 

  6850.     { "OLYMPUS E-PL1", 0, 0,
    6851. 

  6851. 	{ 11408,-4289,-1215,-4286,12385,2118,-387,1467,7787 } },
    6852. 

  6852.     { "OLYMPUS E-PL2", 0, 0,
    6853. 

  6853. 	{ 15030,-5552,-1806,-3987,12387,1767,-592,1670,7023 } },
    6854. 

  6854.     { "OLYMPUS E-PL3", 0, 0,
    6855. 

  6855. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6856. 

  6856.     { "OLYMPUS E-PL5", 0, 0xfcb,
    6857. 

  6857. 	{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
    6858. 

  6858.     { "OLYMPUS E-PM1", 0, 0,
    6859. 

  6859. 	{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
    6860. 

  6860.     { "OLYMPUS E-PM2", 0, 0,
    6861. 

  6861. 	{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
    6862. 

  6862.     { "OLYMPUS E-M5", 0, 0xfe1,
    6863. 

  6863. 	{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
    6864. 

  6864.     { "OLYMPUS SP350", 0, 0,
    6865. 

  6865. 	{ 12078,-4836,-1069,-6671,14306,2578,-786,939,7418 } },
    6866. 

  6866.     { "OLYMPUS SP3", 0, 0,
    6867. 

  6867. 	{ 11766,-4445,-1067,-6901,14421,2707,-1029,1217,7572 } },
    6868. 

  6868.     { "OLYMPUS SP500UZ", 0, 0xfff,
    6869. 

  6869. 	{ 9493,-3415,-666,-5211,12334,3260,-1548,2262,6482 } },
    6870. 

  6870.     { "OLYMPUS SP510UZ", 0, 0xffe,
    6871. 

  6871. 	{ 10593,-3607,-1010,-5881,13127,3084,-1200,1805,6721 } },
    6872. 

  6872.     { "OLYMPUS SP550UZ", 0, 0xffe,
    6873. 

  6873. 	{ 11597,-4006,-1049,-5432,12799,2957,-1029,1750,6516 } },
    6874. 

  6874.     { "OLYMPUS SP560UZ", 0, 0xff9,
    6875. 

  6875. 	{ 10915,-3677,-982,-5587,12986,2911,-1168,1968,6223 } },
    6876. 

  6876.     { "OLYMPUS SP570UZ", 0, 0,
    6877. 

  6877. 	{ 11522,-4044,-1146,-4736,12172,2904,-988,1829,6039 } },
    6878. 

  6878.     { "OLYMPUS XZ-10", 0, 0,
    6879. 

  6879. 	{ 9777,-3483,-925,-2886,11297,1800,-602,1663,5134 } },
    6880. 

  6880.     { "OLYMPUS XZ-1", 0, 0,
    6881. 

  6881. 	{ 10901,-4095,-1074,-1141,9208,2293,-62,1417,5158 } },
    6882. 

  6882.     { "OLYMPUS XZ-2", 0, 0,
    6883. 

  6883. 	{ 9777,-3483,-925,-2886,11297,1800,-602,1663,5134 } },
    6884. 

  6884.     { "OmniVision ov5647", 0, 0,	/* DJC */
    6885. 

  6885. 	{ 12782,-4059,-379,-478,9066,1413,1340,1513,5176 } },
    6886. 

  6886.     { "PENTAX *ist DL2", 0, 0,
    6887. 

  6887. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    6888. 

  6888.     { "PENTAX *ist DL", 0, 0,
    6889. 

  6889. 	{ 10829,-2838,-1115,-8339,15817,2696,-837,680,11939 } },
    6890. 

  6890.     { "PENTAX *ist DS2", 0, 0,
    6891. 

  6891. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    6892. 

  6892.     { "PENTAX *ist DS", 0, 0,
    6893. 

  6893. 	{ 10371,-2333,-1206,-8688,16231,2602,-1230,1116,11282 } },
    6894. 

  6894.     { "PENTAX *ist D", 0, 0,
    6895. 

  6895. 	{ 9651,-2059,-1189,-8881,16512,2487,-1460,1345,10687 } },
    6896. 

  6896.     { "PENTAX K10D", 0, 0,
    6897. 

  6897. 	{ 9566,-2863,-803,-7170,15172,2112,-818,803,9705 } },
    6898. 

  6898.     { "PENTAX K1", 0, 0,
    6899. 

  6899. 	{ 11095,-3157,-1324,-8377,15834,2720,-1108,947,11688 } },
    6900. 

  6900.     { "PENTAX K20D", 0, 0,
    6901. 

  6901. 	{ 9427,-2714,-868,-7493,16092,1373,-2199,3264,7180 } },
    6902. 

  6902.     { "PENTAX K200D", 0, 0,
    6903. 

  6903. 	{ 9186,-2678,-907,-8693,16517,2260,-1129,1094,8524 } },
    6904. 

  6904.     { "PENTAX K2000", 0, 0,
    6905. 

  6905. 	{ 11057,-3604,-1155,-5152,13046,2329,-282,375,8104 } },
    6906. 

  6906.     { "PENTAX K-m", 0, 0,
    6907. 

  6907. 	{ 11057,-3604,-1155,-5152,13046,2329,-282,375,8104 } },
    6908. 

  6908.     { "PENTAX K-x", 0, 0,
    6909. 

  6909. 	{ 8843,-2837,-625,-5025,12644,2668,-411,1234,7410 } },
    6910. 

  6910.     { "PENTAX K-r", 0, 0,
    6911. 

  6911. 	{ 9895,-3077,-850,-5304,13035,2521,-883,1768,6936 } },
    6912. 

  6912.     { "PENTAX K-30", 0, 0,
    6913. 

  6913. 	{ 8833,-2670,-1183,-3995,12301,1881,-979,1717,6527 } },
    6914. 

  6914.     { "PENTAX K-5 II s", 0, 0,
    6915. 

  6915. 	{ 8366,-2528,-1120,-3995,12301,1881,-998,1749,6649 } },
    6916. 

  6916.     { "PENTAX K-5 II", 0, 0,
    6917. 

  6917. 	{ 8773,-2651,-1175,-3995,12301,1881,-973,1706,6486 } },
    6918. 

  6918.     { "PENTAX K-5", 0, 0,
    6919. 

  6919. 	{ 8713,-2833,-743,-4342,11900,2772,-722,1543,6247 } },
    6920. 

  6920.     { "PENTAX K-7", 0, 0,
    6921. 

  6921. 	{ 9142,-2947,-678,-8648,16967,1663,-2224,2898,8615 } },
    6922. 

  6922.     { "PENTAX MX-1", 0, 0,
    6923. 

  6923. 	{ 8804,-2523,-1238,-2423,11627,860,-682,1774,4753 } },
    6924. 

  6924.     { "PENTAX Q10", 0, 0,
    6925. 

  6925. 	{ 12995,-5593,-1107,-1879,10139,2027,-64,1233,4919 } },
    6926. 

  6926.     { "PENTAX 645D", 0, 0x3e00,
    6927. 

  6927. 	{ 10646,-3593,-1158,-3329,11699,1831,-667,2874,6287 } },
    6928. 

  6928.     { "Panasonic DMC-FZ8", 0, 0xf7f,
    6929. 

  6929. 	{ 8986,-2755,-802,-6341,13575,3077,-1476,2144,6379 } },
    6930. 

  6930.     { "Panasonic DMC-FZ18", 0, 0,
    6931. 

  6931. 	{ 9932,-3060,-935,-5809,13331,2753,-1267,2155,5575 } },
    6932. 

  6932.     { "Panasonic DMC-FZ28", 15, 0xf96,
    6933. 

  6933. 	{ 10109,-3488,-993,-5412,12812,2916,-1305,2140,5543 } },
    6934. 

  6934.     { "Panasonic DMC-FZ30", 0, 0xf94,
    6935. 

  6935. 	{ 10976,-4029,-1141,-7918,15491,2600,-1670,2071,8246 } },
    6936. 

  6936.     { "Panasonic DMC-FZ3", 143, 0,
    6937. 

  6937. 	{ 9938,-2780,-890,-4604,12393,2480,-1117,2304,4620 } },
    6938. 

  6938.     { "Panasonic DMC-FZ4", 143, 0,
    6939. 

  6939. 	{ 13639,-5535,-1371,-1698,9633,2430,316,1152,4108 } },
    6940. 

  6940.     { "Panasonic DMC-FZ50", 0, 0,
    6941. 

  6941. 	{ 7906,-2709,-594,-6231,13351,3220,-1922,2631,6537 } },
    6942. 

  6942.     { "LEICA V-LUX1", 0, 0,
    6943. 

  6943. 	{ 7906,-2709,-594,-6231,13351,3220,-1922,2631,6537 } },
    6944. 

  6944.     { "Panasonic DMC-L10", 15, 0xf96,
    6945. 

  6945. 	{ 8025,-1942,-1050,-7920,15904,2100,-2456,3005,7039 } },
    6946. 

  6946.     { "Panasonic DMC-L1", 0, 0xf7f,
    6947. 

  6947. 	{ 8054,-1885,-1025,-8349,16367,2040,-2805,3542,7629 } },
    6948. 

  6948.     { "LEICA DIGILUX 3", 0, 0xf7f,
    6949. 

  6949. 	{ 8054,-1885,-1025,-8349,16367,2040,-2805,3542,7629 } },
    6950. 

  6950.     { "Panasonic DMC-LC1", 0, 0,
    6951. 

  6951. 	{ 11340,-4069,-1275,-7555,15266,2448,-2960,3426,7685 } },
    6952. 

  6952.     { "LEICA DIGILUX 2", 0, 0,
    6953. 

  6953. 	{ 11340,-4069,-1275,-7555,15266,2448,-2960,3426,7685 } },
    6954. 

  6954.     { "Panasonic DMC-LX1", 0, 0xf7f,
    6955. 

  6955. 	{ 10704,-4187,-1230,-8314,15952,2501,-920,945,8927 } },
    6956. 

  6956.     { "LEICA D-LUX2", 0, 0xf7f,
    6957. 

  6957. 	{ 10704,-4187,-1230,-8314,15952,2501,-920,945,8927 } },
    6958. 

  6958.     { "Panasonic DMC-LX2", 0, 0,
    6959. 

  6959. 	{ 8048,-2810,-623,-6450,13519,3272,-1700,2146,7049 } },
    6960. 

  6960.     { "LEICA D-LUX3", 0, 0,
    6961. 

  6961. 	{ 8048,-2810,-623,-6450,13519,3272,-1700,2146,7049 } },
    6962. 

  6962.     { "Panasonic DMC-LX3", 15, 0,
    6963. 

  6963. 	{ 8128,-2668,-655,-6134,13307,3161,-1782,2568,6083 } },
    6964. 

  6964.     { "LEICA D-LUX 4", 15, 0,
    6965. 

  6965. 	{ 8128,-2668,-655,-6134,13307,3161,-1782,2568,6083 } },
    6966. 

  6966.     { "Panasonic DMC-LX5", 143, 0,
    6967. 

  6967. 	{ 10909,-4295,-948,-1333,9306,2399,22,1738,4582 } },
    6968. 

  6968.     { "Panasonic DMC-LX7", 143, 0,
    6969. 

  6969. 	{ 10148,-3743,-991,-2837,11366,1659,-701,1893,4899 } },
    6970. 

  6970.     { "LEICA D-LUX 5", 143, 0,
    6971. 

  6971. 	{ 10909,-4295,-948,-1333,9306,2399,22,1738,4582 } },
    6972. 

  6972.     { "Panasonic DMC-LX7", 143, 0,
    6973. 

  6973. 	{ 10148,-3743,-991,-2837,11366,1659,-701,1893,4899 } },
    6974. 

  6974.     { "LEICA D-LUX 6", 143, 0,
    6975. 

  6975. 	{ 10148,-3743,-991,-2837,11366,1659,-701,1893,4899 } },
    6976. 

  6976.     { "Panasonic DMC-FZ100", 143, 0xfff,
    6977. 

  6977. 	{ 16197,-6146,-1761,-2393,10765,1869,366,2238,5248 } },
    6978. 

  6978.     { "LEICA V-LUX 2", 143, 0xfff,
    6979. 

  6979. 	{ 16197,-6146,-1761,-2393,10765,1869,366,2238,5248 } },
    6980. 

  6980.     { "Panasonic DMC-FZ150", 143, 0xfff,
    6981. 

  6981. 	{ 11904,-4541,-1189,-2355,10899,1662,-296,1586,4289 } },
    6982. 

  6982.     { "LEICA V-LUX 3", 143, 0xfff,
    6983. 

  6983. 	{ 11904,-4541,-1189,-2355,10899,1662,-296,1586,4289 } },
    6984. 

  6984.     { "Panasonic DMC-FZ200", 143, 0xfff,
    6985. 

  6985. 	{ 8112,-2563,-740,-3730,11784,2197,-941,2075,4933 } },
    6986. 

  6986.     { "LEICA V-LUX 4", 143, 0xfff,
    6987. 

  6987. 	{ 8112,-2563,-740,-3730,11784,2197,-941,2075,4933 } },
    6988. 

  6988.     { "Panasonic DMC-FX150", 15, 0xfff,
    6989. 

  6989. 	{ 9082,-2907,-925,-6119,13377,3058,-1797,2641,5609 } },
    6990. 

  6990.     { "Panasonic DMC-G10", 0, 0,
    6991. 

  6991. 	{ 10113,-3400,-1114,-4765,12683,2317,-377,1437,6710 } },
    6992. 

  6992.     { "Panasonic DMC-G1", 15, 0xf94,
    6993. 

  6993. 	{ 8199,-2065,-1056,-8124,16156,2033,-2458,3022,7220 } },
    6994. 

  6994.     { "Panasonic DMC-G2", 15, 0xf3c,
    6995. 

  6995. 	{ 10113,-3400,-1114,-4765,12683,2317,-377,1437,6710 } },
    6996. 

  6996.     { "Panasonic DMC-G3", 143, 0xfff,
    6997. 

  6997. 	{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
    6998. 

  6998.     { "Panasonic DMC-G5", 143, 0xfff,
    6999. 

  6999. 	{ 7798,-2562,-740,-3879,11584,2613,-1055,2248,5434 } },
    7000. 

  7000.     { "Panasonic DMC-G6", 143, 0xfff,
    7001. 

  7001. 	{ 8294,-2891,-651,-3869,11590,2595,-1183,2267,5352 } },
    7002. 

  7002.     { "Panasonic DMC-GF1", 15, 0xf92,
    7003. 

  7003. 	{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
    7004. 

  7004.     { "Panasonic DMC-GF2", 143, 0xfff,
    7005. 

  7005. 	{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
    7006. 

  7006.     { "Panasonic DMC-GF3", 143, 0xfff,
    7007. 

  7007. 	{ 9051,-2468,-1204,-5212,13276,2121,-1197,2510,6890 } },
    7008. 

  7008.     { "Panasonic DMC-GF5", 143, 0xfff,
    7009. 

  7009. 	{ 8228,-2945,-660,-3938,11792,2430,-1094,2278,5793 } },
    7010. 

  7010.     { "Panasonic DMC-GF6", 143, 0,
    7011. 

  7011. 	{ 8130,-2801,-946,-3520,11289,2552,-1314,2511,5791 } },
    7012. 

  7012.     { "Panasonic DMC-GH1", 15, 0xf92,
    7013. 

  7013. 	{ 6299,-1466,-532,-6535,13852,2969,-2331,3112,5984 } },
    7014. 

  7014.     { "Panasonic DMC-GH2", 15, 0xf95,
    7015. 

  7015. 	{ 7780,-2410,-806,-3913,11724,2484,-1018,2390,5298 } },
    7016. 

  7016.     { "Panasonic DMC-GH3", 144, 0,
    7017. 

  7017. 	{ 6559,-1752,-491,-3672,11407,2586,-962,1875,5130 } },
    7018. 

  7018.     { "Panasonic DMC-GX1", 143, 0,
    7019. 

  7019. 	{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
    7020. 

  7020.     { "Phase One H 20", 0, 0,		/* DJC */
    7021. 

  7021. 	{ 1313,1855,-109,-6715,15908,808,-327,1840,6020 } },
    7022. 

  7022.     { "Phase One H 25", 0, 0,
    7023. 

  7023. 	{ 2905,732,-237,-8134,16626,1476,-3038,4253,7517 } },
    7024. 

  7024.     { "Phase One P 2", 0, 0,
    7025. 

  7025. 	{ 2905,732,-237,-8134,16626,1476,-3038,4253,7517 } },
    7026. 

  7026.     { "Phase One P 30", 0, 0,
    7027. 

  7027. 	{ 4516,-245,-37,-7020,14976,2173,-3206,4671,7087 } },
    7028. 

  7028.     { "Phase One P 45", 0, 0,
    7029. 

  7029. 	{ 5053,-24,-117,-5684,14076,1702,-2619,4492,5849 } },
    7030. 

  7030.     { "Phase One P40", 0, 0,
    7031. 

  7031. 	{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
    7032. 

  7032.     { "Phase One P65", 0, 0,
    7033. 

  7033. 	{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
    7034. 

  7034.     { "RED ONE", 704, 0xffff,		/* DJC */
    7035. 

  7035. 	{ 21014,-7891,-2613,-3056,12201,856,-2203,5125,8042 } },
    7036. 

  7036.     { "SAMSUNG EX1", 0, 0x3e00,
    7037. 

  7037. 	{ 8898,-2498,-994,-3144,11328,2066,-760,1381,4576 } },
    7038. 

  7038.     { "SAMSUNG EX2F", 0, 0x7ff,
    7039. 

  7039. 	{ 10648,-3897,-1055,-2022,10573,1668,-492,1611,4742 } },
    7040. 

  7040.     { "SAMSUNG NX2", 0, 0xfff,	/* NX20, NX200, NX210 */
    7041. 

  7041. 	{ 6933,-2268,-753,-4921,13387,1647,-803,1641,6096 } },
    7042. 

  7042.     { "SAMSUNG NX1000", 0, 0,
    7043. 

  7043. 	{ 6933,-2268,-753,-4921,13387,1647,-803,1641,6096 } },
    7044. 

  7044.     { "SAMSUNG NX", 0, 0,	/* NX5, NX10, NX11, NX100 */
    7045. 

  7045. 	{ 10332,-3234,-1168,-6111,14639,1520,-1352,2647,8331 } },
    7046. 

  7046.     { "SAMSUNG WB2000", 0, 0xfff,
    7047. 

  7047. 	{ 12093,-3557,-1155,-1000,9534,1733,-22,1787,4576 } },
    7048. 

  7048.     { "SAMSUNG GX-1", 0, 0,
    7049. 

  7049. 	{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
    7050. 

  7050.     { "SAMSUNG S85", 0, 0xffff,		/* DJC */
    7051. 

  7051. 	{ 11885,-3968,-1473,-4214,12299,1916,-835,1655,5549 } },
    7052. 

  7052.     { "Sinar", 0, 0,			/* DJC */
    7053. 

  7053. 	{ 16442,-2956,-2422,-2877,12128,750,-1136,6066,4559 } },
    7054. 

  7054.     { "SONY DSC-F828", 0, 0,
    7055. 

  7055. 	{ 7924,-1910,-777,-8226,15459,2998,-1517,2199,6818,-7242,11401,3481 } },
    7056. 

  7056.     { "SONY DSC-R1", 512, 0,
    7057. 

  7057. 	{ 8512,-2641,-694,-8042,15670,2526,-1821,2117,7414 } },
    7058. 

  7058.     { "SONY DSC-V3", 0, 0,
    7059. 

  7059. 	{ 7511,-2571,-692,-7894,15088,3060,-948,1111,8128 } },
    7060. 

  7060.     { "SONY DSC-RX100", 200, 0,
    7061. 

  7061. 	{ 8651,-2754,-1057,-3464,12207,1373,-568,1398,4434 } },
    7062. 

  7062.     { "SONY DSC-RX1", 128, 0,
    7063. 

  7063. 	{ 6344,-1612,-462,-4863,12477,2681,-865,1786,6899 } },
    7064. 

  7064.     { "SONY DSLR-A100", 0, 0xfeb,
    7065. 

  7065. 	{ 9437,-2811,-774,-8405,16215,2290,-710,596,7181 } },
    7066. 

  7066.     { "SONY DSLR-A290", 0, 0,
    7067. 

  7067. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7068. 

  7068.     { "SONY DSLR-A2", 0, 0,
    7069. 

  7069. 	{ 9847,-3091,-928,-8485,16345,2225,-715,595,7103 } },
    7070. 

  7070.     { "SONY DSLR-A300", 0, 0,
    7071. 

  7071. 	{ 9847,-3091,-928,-8485,16345,2225,-715,595,7103 } },
    7072. 

  7072.     { "SONY DSLR-A330", 0, 0,
    7073. 

  7073. 	{ 9847,-3091,-929,-8485,16346,2225,-714,595,7103 } },
    7074. 

  7074.     { "SONY DSLR-A350", 0, 0xffc,
    7075. 

  7075. 	{ 6038,-1484,-578,-9146,16746,2513,-875,746,7217 } },
    7076. 

  7076.     { "SONY DSLR-A380", 0, 0,
    7077. 

  7077. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7078. 

  7078.     { "SONY DSLR-A390", 0, 0,
    7079. 

  7079. 	{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
    7080. 

  7080.     { "SONY DSLR-A450", 128, 0xfeb,
    7081. 

  7081. 	{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
    7082. 

  7082.     { "SONY DSLR-A580", 128, 0xfeb,
    7083. 

  7083. 	{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
    7084. 

  7084.     { "SONY DSLR-A5", 128, 0xfeb,
    7085. 

  7085. 	{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
    7086. 

  7086.     { "SONY DSLR-A700", 126, 0,
    7087. 

  7087. 	{ 5775,-805,-359,-8574,16295,2391,-1943,2341,7249 } },
    7088. 

  7088.     { "SONY DSLR-A850", 128, 0,
    7089. 

  7089. 	{ 5413,-1162,-365,-5665,13098,2866,-608,1179,8440 } },
    7090. 

  7090.     { "SONY DSLR-A900", 128, 0,
    7091. 

  7091. 	{ 5209,-1072,-397,-8845,16120,2919,-1618,1803,8654 } },
    7092. 

  7092.     { "SONY NEX-3N", 128, 0,		/* Adobe */
    7093. 

  7093. 	{ 6129,-1545,	-418,-4930,12490,2743,-977,1693,6615 } },
    7094. 

  7094.     { "SONY NEX-3", 128, 0,		/* Adobe */
    7095. 

  7095. 	{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
    7096. 

  7096.     { "SONY NEX-5N", 128, 0,
    7097. 

  7097. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7098. 

  7098.     { "SONY NEX-5R", 128, 0,		
    7099. 

  7099. 	{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
    7100. 

  7100.     { "SONY NEX-5", 128, 0,		/* Adobe */
    7101. 

  7101. 	{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
    7102. 

  7102.     { "SONY NEX-6", 128, 0,
    7103. 

  7103. 	{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
    7104. 

  7104.     { "SONY NEX-7", 128, 0,
    7105. 

  7105. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7106. 

  7106.     { "SONY NEX", 128, 0,	/* NEX-C3, NEX-F3 */
    7107. 

  7107. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7108. 

  7108.     { "SONY SLT-A33", 128, 0,
    7109. 

  7109. 	{ 6069,-1221,-366,-5221,12779,2734,-1024,2066,6834 } },
    7110. 

  7110.     { "SONY SLT-A35", 128, 0,
    7111. 

  7111. 	{ 5986,-1618,-415,-4557,11820,3120,-681,1404,6971 } },
    7112. 

  7112.     { "SONY SLT-A37", 128, 0,
    7113. 

  7113. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7114. 

  7114.     { "SONY SLT-A55", 128, 0,
    7115. 

  7115. 	{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
    7116. 

  7116.     { "SONY SLT-A57", 128, 0,
    7117. 

  7117. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7118. 

  7118.     { "SONY SLT-A58", 128, 0,
    7119. 

  7119. 	{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
    7120. 

  7120.     { "SONY SLT-A65", 128, 0,
    7121. 

  7121. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7122. 

  7122.     { "SONY SLT-A77", 128, 0,
    7123. 

  7123. 	{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
    7124. 

  7124.     { "SONY SLT-A99", 128, 0,
    7125. 

  7125. 	{ 6344,-1612,-462,-4863,12477,2681,-865,1786,6899 } },
    7126. 

  7126.   };
    7127. 

  7127.   double cam_xyz[4][3];
    7128. 

  7128.   char name[130];
    7129. 

  7129.   int i, j;
    7130. 

  7130. 

  7131.   sprintf (name, "%s %s", t_make, t_model);
    7132. 

  7132.   for (i=0; i < sizeof table / sizeof *table; i++)
    7133. 

  7133.     if (!strncmp (name, table[i].prefix, strlen(table[i].prefix))) {
    7134. 

  7134.       if (table[i].t_black)   black   = (ushort) table[i].t_black;
    7135. 

  7135.       if (table[i].t_maximum) maximum = (ushort) table[i].t_maximum;
    7136. 

  7136.       if (table[i].trans[0]) {
    7137. 

  7137. 	for (j=0; j < 12; j++)
    7138. 

  7138. #ifdef LIBRAW_LIBRARY_BUILD
    7139. 

  7139.           imgdata.color.cam_xyz[0][j] = 
    7140. 

  7140. #endif
    7141. 

  7141. 	  cam_xyz[0][j] = table[i].trans[j] / 10000.0;
    7142. 

  7142. 	cam_xyz_coeff (cam_xyz);
    7143. 

  7143.       }
    7144. 

  7144.       break;
    7145. 

  7145.     }
    7146. 

  7146. }
    7147. 

  7147. 

  7148. void CLASS simple_coeff (int index)
    7149. 

  7149. {
    7150. 

  7150.   static const float table[][12] = {
    7151. 

  7151.   /* index 0 -- all Foveon cameras */
    7152. 

  7152.   { 1.4032,-0.2231,-0.1016,-0.5263,1.4816,0.017,-0.0112,0.0183,0.9113 },
    7153. 

  7153.   /* index 1 -- Kodak DC20 and DC25 */
    7154. 

  7154.   { 2.25,0.75,-1.75,-0.25,-0.25,0.75,0.75,-0.25,-0.25,-1.75,0.75,2.25 },
    7155. 

  7155.   /* index 2 -- Logitech Fotoman Pixtura */
    7156. 

  7156.   { 1.893,-0.418,-0.476,-0.495,1.773,-0.278,-1.017,-0.655,2.672 },
    7157. 

  7157.   /* index 3 -- Nikon E880, E900, and E990 */
    7158. 

  7158.   { -1.936280,  1.800443, -1.448486,  2.584324,
    7159. 

  7159.      1.405365, -0.524955, -0.289090,  0.408680,
    7160. 

  7160.     -1.204965,  1.082304,  2.941367, -1.818705 }
    7161. 

  7161.   };
    7162. 

  7162.   int i, c;
    7163. 

  7163. 

  7164.   for (raw_color = i=0; i < 3; i++)
    7165. 

  7165.     FORCC rgb_cam[i][c] = table[index][i*colors+c];
    7166. 

  7166. }
    7167. 

  7167. 

  7168. short CLASS guess_byte_order (int words)
    7169. 

  7169. {
    7170. 

  7170.   uchar test[4][2];
    7171. 

  7171.   int t=2, msb;
    7172. 

  7172.   double diff, sum[2] = {0,0};
    7173. 

  7173. 

  7174.   fread (test[0], 2, 2, ifp);
    7175. 

  7175.   for (words-=2; words--; ) {
    7176. 

  7176.     fread (test[t], 2, 1, ifp);
    7177. 

  7177.     for (msb=0; msb < 2; msb++) {
    7178. 

  7178.       diff = (test[t^2][msb] << 8 | test[t^2][!msb])
    7179. 

  7179. 	   - (test[t  ][msb] << 8 | test[t  ][!msb]);
    7180. 

  7180.       sum[msb] += diff*diff;
    7181. 

  7181.     }
    7182. 

  7182.     t = (t+1) & 3;
    7183. 

  7183.   }
    7184. 

  7184.   return sum[0] < sum[1] ? 0x4d4d : 0x4949;
    7185. 

  7185. }
    7186. 

  7186. 

  7187. float CLASS find_green (int bps, int bite, int off0, int off1)
    7188. 

  7188. {
    7189. 

  7189.   UINT64 bitbuf=0;
    7190. 

  7190.   int vbits, col, i, c;
    7191. 

  7191.   ushort img[2][2064];
    7192. 

  7192.   double sum[]={0,0};
    7193. 

  7193. 

  7194.   FORC(2) {
    7195. 

  7195.     fseek (ifp, c ? off1:off0, SEEK_SET);
    7196. 

  7196.     for (vbits=col=0; col < width; col++) {
    7197. 

  7197.       for (vbits -= bps; vbits < 0; vbits += bite) {
    7198. 

  7198. 	bitbuf <<= bite;
    7199. 

  7199. 	for (i=0; i < bite; i+=8)
    7200. 

  7200. 	  bitbuf |= (unsigned) (fgetc(ifp) << i);
    7201. 

  7201.       }
    7202. 

  7202.       img[c][col] = bitbuf << (64-bps-vbits) >> (64-bps);
    7203. 

  7203.     }
    7204. 

  7204.   }
    7205. 

  7205.   FORC(width-1) {
    7206. 

  7206.     sum[ c & 1] += ABS(img[0][c]-img[1][c+1]);
    7207. 

  7207.     sum[~c & 1] += ABS(img[1][c]-img[0][c+1]);
    7208. 

  7208.   }
    7209. 

  7209.   return 100 * log(sum[0]/sum[1]);
    7210. 

  7210. }
    7211. 

  7211. 

  7212. 

  7213. #ifndef LIBRAW_LIBRARY_BUILD
    7214. 

  7214. void CLASS identify2(unsigned fsize, unsigned flen, char *head);
    7215. 

  7215. #endif
    7216. 

  7216. 

  7217. /*
    7218. 

  7218.    Identify which camera created this file, and set global variables
    7219. 

  7219.    accordingly.
    7220. 

  7220.  */
    7221. 

  7221. void CLASS identify()
    7222. 

  7222. {
    7223. 

  7223.   char head[32], *cp;
    7224. 

  7224.   int hlen, flen, fsize, zero_fsize=1, i, c, is_canon;
    7225. 

  7225.   struct jhead jh;
    7226. 

  7226.   static const struct {
    7227. 

  7227.     int fsize;
    7228. 

  7228.     char t_make[12], t_model[19], withjpeg;
    7229. 

  7229.   } table[] = {
    7230. 

  7230.     {    62464, "Kodak",    "DC20"            ,0 },
    7231. 

  7231.     {   124928, "Kodak",    "DC20"            ,0 },
    7232. 

  7232.     {  1652736, "Kodak",    "DCS200"          ,0 },
    7233. 

  7233.     {  4159302, "Kodak",    "C330"            ,0 },
    7234. 

  7234.     {  4162462, "Kodak",    "C330"            ,0 },
    7235. 

  7235.     {   460800, "Kodak",    "C603v"           ,0 },
    7236. 

  7236.     {   614400, "Kodak",    "C603v"           ,0 },
    7237. 

  7237.     {  6163328, "Kodak",    "C603"            ,0 },
    7238. 

  7238.     {  6166488, "Kodak",    "C603"            ,0 },
    7239. 

  7239.     {  9116448, "Kodak",    "C603y"           ,0 },
    7240. 

  7240.     {   311696, "ST Micro", "STV680 VGA"      ,0 },  /* SPYz */
    7241. 

  7241.     {   787456, "Creative", "PC-CAM 600"      ,0 },
    7242. 

  7242.     {  1138688, "Minolta",  "RD175"           ,0 },
    7243. 

  7243.     {  3840000, "Foculus",  "531C"            ,0 },
    7244. 

  7244.     {   307200, "Generic",  "640x480"         ,0 },
    7245. 

  7245.     {   786432, "AVT",      "F-080C"          ,0 },
    7246. 

  7246.     {  1447680, "AVT",      "F-145C"          ,0 },
    7247. 

  7247.     {  1920000, "AVT",      "F-201C"          ,0 },
    7248. 

  7248.     {  5067304, "AVT",      "F-510C"          ,0 },
    7249. 

  7249.     {  5067316, "AVT",      "F-510C"          ,0 },
    7250. 

  7250.     { 10134608, "AVT",      "F-510C"          ,0 },
    7251. 

  7251.     { 10134620, "AVT",      "F-510C"          ,0 },
    7252. 

  7252.     { 16157136, "AVT",      "F-810C"          ,0 },
    7253. 

  7253.     {  1409024, "Sony",     "XCD-SX910CR"     ,0 },
    7254. 

  7254.     {  2818048, "Sony",     "XCD-SX910CR"     ,0 },
    7255. 

  7255.     {  3884928, "Micron",   "2010"            ,0 },
    7256. 

  7256.     {  6624000, "Pixelink", "A782"            ,0 },
    7257. 

  7257.     { 13248000, "Pixelink", "A782"            ,0 },
    7258. 

  7258.     {  6291456, "RoverShot","3320AF"          ,0 },
    7259. 

  7259.     {  6553440, "Canon",    "PowerShot A460"  ,0 },
    7260. 

  7260.     {  6653280, "Canon",    "PowerShot A530"  ,0 },
    7261. 

  7261.     {  6573120, "Canon",    "PowerShot A610"  ,0 },
    7262. 

  7262.     {  9219600, "Canon",    "PowerShot A620"  ,0 },
    7263. 

  7263.     {  9243240, "Canon",    "PowerShot A470"  ,0 },
    7264. 

  7264.     { 10341600, "Canon",    "PowerShot A720 IS",0 },
    7265. 

  7265.     { 10383120, "Canon",    "PowerShot A630"  ,0 },
    7266. 

  7266.     { 12945240, "Canon",    "PowerShot A640"  ,0 },
    7267. 

  7267.     { 15636240, "Canon",    "PowerShot A650"  ,0 },
    7268. 

  7268.     {  5298000, "Canon",    "PowerShot SD300" ,0 },
    7269. 

  7269.     {  7710960, "Canon",    "PowerShot S3 IS" ,0 },
    7270. 

  7270.     { 15467760, "Canon",    "PowerShot SX110 IS",0 },
    7271. 

  7271.     { 15534576, "Canon",    "PowerShot SX120 IS",0 },
    7272. 

  7272.     { 18653760, "Canon",    "PowerShot SX20 IS",0 },
    7273. 

  7273.     { 19131120, "Canon",    "PowerShot SX220 HS",0 },
    7274. 

  7274.     { 21936096, "Canon",    "PowerShot SX30 IS",0 },
    7275. 

  7275.     {  5939200, "OLYMPUS",  "C770UZ"          ,0 },
    7276. 

  7276.     {  1581060, "NIKON",    "E900"            ,1 },  /* or E900s,E910 */
    7277. 

  7277.     {  2465792, "NIKON",    "E950"            ,1 },  /* or E800,E700 */
    7278. 

  7278.     {  2940928, "NIKON",    "E2100"           ,1 },  /* or E2500 */
    7279. 

  7279.     {  4771840, "NIKON",    "E990"            ,1 },  /* or E995, Oly C3030Z */
    7280. 

  7280.     {  4775936, "NIKON",    "E3700"           ,1 },  /* or Optio 33WR */
    7281. 

  7281.     {  5869568, "NIKON",    "E4300"           ,1 },  /* or DiMAGE Z2 */
    7282. 

  7282.     {  5865472, "NIKON",    "E4500"           ,1 },
    7283. 

  7283.     {  7438336, "NIKON",    "E5000"           ,1 },  /* or E5700 */
    7284. 

  7284.     {  8998912, "NIKON",    "COOLPIX S6"      ,1 },
    7285. 

  7285.     {  1976352, "CASIO",    "QV-2000UX"       ,1 },
    7286. 

  7286.     {  3217760, "CASIO",    "QV-3*00EX"       ,1 },
    7287. 

  7287.     {  6218368, "CASIO",    "QV-5700"         ,1 },
    7288. 

  7288.     {  6054400, "CASIO",    "QV-R41"          ,1 },
    7289. 

  7289.     {  7530816, "CASIO",    "QV-R51"          ,1 },
    7290. 

  7290.     {  7684000, "CASIO",    "QV-4000"         ,1 },
    7291. 

  7291.     {  2937856, "CASIO",    "EX-S20"          ,1 },
    7292. 

  7292.     {  4948608, "CASIO",    "EX-S100"         ,1 },
    7293. 

  7293.     {  7542528, "CASIO",    "EX-Z50"          ,1 },
    7294. 

  7294.     {  7562048, "CASIO",    "EX-Z500"         ,1 },
    7295. 

  7295.     {  7753344, "CASIO",    "EX-Z55"          ,1 },
    7296. 

  7296.     {  7816704, "CASIO",    "EX-Z60"          ,1 },
    7297. 

  7297.     { 10843712, "CASIO",    "EX-Z75"          ,1 },
    7298. 

  7298.     { 10834368, "CASIO",    "EX-Z750"         ,1 },
    7299. 

  7299.     { 12310144, "CASIO",    "EX-Z850"         ,1 },
    7300. 

  7300.     { 12489984, "CASIO",    "EX-Z8"           ,1 },
    7301. 

  7301.     { 15499264, "CASIO",    "EX-Z1050"        ,1 },
    7302. 

  7302.     { 18702336, "CASIO",    "EX-ZR100"        ,1 },
    7303. 

  7303.     {  7426656, "CASIO",    "EX-P505"         ,1 },
    7304. 

  7304.     {  9313536, "CASIO",    "EX-P600"         ,1 },
    7305. 

  7305.     { 10979200, "CASIO",    "EX-P700"         ,1 },
    7306. 

  7306.     {  3178560, "PENTAX",   "Optio S"         ,1 },
    7307. 

  7307.     {  4841984, "PENTAX",   "Optio S"         ,1 },
    7308. 

  7308.     {  6114240, "PENTAX",   "Optio S4"        ,1 },  /* or S4i, CASIO EX-Z4 */
    7309. 

  7309.     { 10702848, "PENTAX",   "Optio 750Z"      ,1 },
    7310. 

  7310.     { 15980544, "AGFAPHOTO","DC-833m"         ,1 },
    7311. 

  7311.     { 16098048, "SAMSUNG",  "S85"             ,1 },
    7312. 

  7312.     { 16215552, "SAMSUNG",  "S85"             ,1 },
    7313. 

  7313.     { 20487168, "SAMSUNG",  "WB550"           ,1 },
    7314. 

  7314.     { 24000000, "SAMSUNG",  "WB550"           ,1 },
    7315. 

  7315.     { 9994240, "ptGrey", "GRAS-50S5C" ,0 }, // KC: SUPPORT GRASSHOPPER
    7316. 

  7316.     { 10075968, "JaiPulnix","BB-500CL" ,0 }, // KC: SUPPORT BB-500CL
    7317. 

  7317.     { 10108896, "JaiPulnix","BB-500GE" ,0 }, // KC: SUPPORT BB-500GE
    7318. 

  7318.     { 10036800, "SVS", "SVS625CL" ,0 }, // KC: SUPPORT SVS625 cameralink
    7319. 

  7319.     { 12582980, "Sinar",    ""                ,0 },
    7320. 

  7320.     { 33292868, "Sinar",    ""                ,0 },
    7321. 

  7321.     { 44390468, "Sinar",    ""                ,0 } };
    7322. 

  7322.   static const char *corp[] =
    7323. 

  7323.     { "Canon", "NIKON", "EPSON", "KODAK", "Kodak", "OLYMPUS", "PENTAX",
    7324. 

  7324.       "MINOLTA", "Minolta", "Konica", "CASIO", "Sinar", "Phase One",
    7325. 

  7325.       "SAMSUNG", "Mamiya", "MOTOROLA", "LEICA" };
    7326. 

  7326. 

  7327. #ifdef LIBRAW_LIBRARY_BUILD
    7328. 

  7328.   RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY,0,2);
    7329. 

  7329. #endif
    7330. 

  7330. 

  7331.   tiff_flip = flip = filters = -1;	/* 0 is valid, so -1 is unknown */
    7332. 

  7332.   raw_height = raw_width = fuji_width = fuji_layout = cr2_slice[0] = 0;
    7333. 

  7333.   maximum = height = width = top_margin = left_margin = 0;
    7334. 

  7334.   cdesc[0] = desc[0] = artist[0] = make[0] = model[0] = model2[0] = 0;
    7335. 

  7335.   iso_speed = shutter = aperture = focal_len = unique_id = 0;
    7336. 

  7336.   tiff_nifds = 0;
    7337. 

  7337.   memset (tiff_ifd, 0, sizeof tiff_ifd);
    7338. 

  7338.   memset (gpsdata, 0, sizeof gpsdata);
    7339. 

  7339.   memset (cblack, 0, sizeof cblack);
    7340. 

  7340.   memset (white, 0, sizeof white);
    7341. 

  7341.   memset (mask, 0, sizeof mask);
    7342. 

  7342.   thumb_offset = thumb_length = thumb_width = thumb_height = 0;
    7343. 

  7343.   load_raw = thumb_load_raw = 0;
    7344. 

  7344.   write_thumb = &CLASS jpeg_thumb;
    7345. 

  7345.   data_offset = meta_length = tiff_bps = tiff_compress = 0;
    7346. 

  7346.   kodak_cbpp = zero_after_ff = dng_version = load_flags = 0;
    7347. 

  7347.   timestamp = shot_order = tiff_samples = black = is_foveon = 0;
    7348. 

  7348.   mix_green = profile_length = data_error = zero_is_bad = 0;
    7349. 

  7349.   pixel_aspect = is_raw = raw_color = 1;
    7350. 

  7350.   tile_width = tile_length = 0;
    7351. 

  7351.   for (i=0; i < 4; i++) {
    7352. 

  7352.     cam_mul[i] = i == 1;
    7353. 

  7353.     pre_mul[i] = i < 3;
    7354. 

  7354.     FORC3 cmatrix[c][i] = 0;
    7355. 

  7355.     FORC3 rgb_cam[c][i] = c == i;
    7356. 

  7356.   }
    7357. 

  7357.   colors = 3;
    7358. 

  7358.   for (i=0; i < 0x10000; i++) curve[i] = i;
    7359. 

  7359. 

  7360.   order = get2();
    7361. 

  7361.   hlen = get4();
    7362. 

  7362.   fseek (ifp, 0, SEEK_SET);
    7363. 

  7363.   fread (head, 1, 32, ifp);
    7364. 

  7364.   fseek (ifp, 0, SEEK_END);
    7365. 

  7365.   flen = fsize = ftell(ifp);
    7366. 

  7366.   if ((cp = (char *) memmem (head, 32, (char*)"MMMM", 4)) ||
    7367. 

  7367.       (cp = (char *) memmem (head, 32, (char*)"IIII", 4))) {
    7368. 

  7368.     parse_phase_one (cp-head);
    7369. 

  7369.     if (cp-head && parse_tiff(0)) apply_tiff();
    7370. 

  7370.   } else if (order == 0x4949 || order == 0x4d4d) {
    7371. 

  7371.     if (!memcmp (head+6,"HEAPCCDR",8)) {
    7372. 

  7372.       data_offset = hlen;
    7373. 

  7373.       parse_ciff (hlen, flen - hlen);
    7374. 

  7374.     } else if (parse_tiff(0)) apply_tiff();
    7375. 

  7375.   } else if (!memcmp (head,"\xff\xd8\xff\xe1",4) &&
    7376. 

  7376. 	     !memcmp (head+6,"Exif",4)) {
    7377. 

  7377.     fseek (ifp, 4, SEEK_SET);
    7378. 

  7378.     data_offset = 4 + get2();
    7379. 

  7379.     fseek (ifp, data_offset, SEEK_SET);
    7380. 

  7380.     if (fgetc(ifp) != 0xff)
    7381. 

  7381.       parse_tiff(12);
    7382. 

  7382.     thumb_offset = 0;
    7383. 

  7383.   } else if (!memcmp (head+25,"ARECOYK",7)) {
    7384. 

  7384.     strcpy (make, "Contax");
    7385. 

  7385.     strcpy (model,"N Digital");
    7386. 

  7386.     fseek (ifp, 33, SEEK_SET);
    7387. 

  7387.     get_timestamp(1);
    7388. 

  7388.     fseek (ifp, 60, SEEK_SET);
    7389. 

  7389.     FORC4 cam_mul[c ^ (c >> 1)] = get4();
    7390. 

  7390.   } else if (!strcmp (head, "PXN")) {
    7391. 

  7391.     strcpy (make, "Logitech");
    7392. 

  7392.     strcpy (model,"Fotoman Pixtura");
    7393. 

  7393.   } else if (!strcmp (head, "qktk")) {
    7394. 

  7394.     strcpy (make, "Apple");
    7395. 

  7395.     strcpy (model,"QuickTake 100");
    7396. 

  7396.     load_raw = &CLASS quicktake_100_load_raw;
    7397. 

  7397.   } else if (!strcmp (head, "qktn")) {
    7398. 

  7398.     strcpy (make, "Apple");
    7399. 

  7399.     strcpy (model,"QuickTake 150");
    7400. 

  7400.     load_raw = &CLASS kodak_radc_load_raw;
    7401. 

  7401.   } else if (!memcmp (head,"FUJIFILM",8)) {
    7402. 

  7402.     fseek (ifp, 84, SEEK_SET);
    7403. 

  7403.     thumb_offset = get4();
    7404. 

  7404.     thumb_length = get4();
    7405. 

  7405.     fseek (ifp, 92, SEEK_SET);
    7406. 

  7406.     parse_fuji (get4());
    7407. 

  7407.     if (thumb_offset > 120) {
    7408. 

  7408.       fseek (ifp, 120, SEEK_SET);
    7409. 

  7409.       is_raw += (i = get4()) && 1;
    7410. 

  7410.       if (is_raw == 2 && shot_select)
    7411. 

  7411. 	parse_fuji (i);
    7412. 

  7412.     }
    7413. 

  7413.     load_raw = &CLASS unpacked_load_raw;
    7414. 

  7414.     fseek (ifp, 100+28*(shot_select > 0), SEEK_SET);
    7415. 

  7415.     parse_tiff (data_offset = get4());
    7416. 

  7416.     parse_tiff (thumb_offset+12);
    7417. 

  7417.     apply_tiff();
    7418. 

  7418.   } else if (!memcmp (head,"RIFF",4)) {
    7419. 

  7419.     fseek (ifp, 0, SEEK_SET);
    7420. 

  7420.     parse_riff();
    7421. 

  7421.   } else if (!memcmp (head,"\0\001\0\001\0@",6)) {
    7422. 

  7422.     fseek (ifp, 6, SEEK_SET);
    7423. 

  7423.     fread (make, 1, 8, ifp);
    7424. 

  7424.     fread (model, 1, 8, ifp);
    7425. 

  7425.     fread (model2, 1, 16, ifp);
    7426. 

  7426.     data_offset = get2();
    7427. 

  7427.     get2();
    7428. 

  7428.     raw_width = get2();
    7429. 

  7429.     raw_height = get2();
    7430. 

  7430.     load_raw = &CLASS nokia_load_raw;
    7431. 

  7431.     filters = 0x61616161;
    7432. 

  7432.   } else if (!memcmp (head,"NOKIARAW",8)) {
    7433. 

  7433.     strcpy (make, "NOKIA");
    7434. 

  7434.     strcpy (model, "X2");
    7435. 

  7435.     order = 0x4949;
    7436. 

  7436.     fseek (ifp, 300, SEEK_SET);
    7437. 

  7437.     data_offset = get4();
    7438. 

  7438.     i = get4();
    7439. 

  7439.     width = get2();
    7440. 

  7440.     height = get2();
    7441. 

  7441.     data_offset += i - width * 5 / 4 * height;
    7442. 

  7442.     load_raw = &CLASS nokia_load_raw;
    7443. 

  7443.     filters = 0x61616161;
    7444. 

  7444.   } else if (!memcmp (head,"ARRI",4)) {
    7445. 

  7445.     order = 0x4949;
    7446. 

  7446.     fseek (ifp, 20, SEEK_SET);
    7447. 

  7447.     width = get4();
    7448. 

  7448.     height = get4();
    7449. 

  7449.     strcpy (make, "ARRI");
    7450. 

  7450.     fseek (ifp, 668, SEEK_SET);
    7451. 

  7451.     fread (model, 1, 64, ifp);
    7452. 

  7452.     data_offset = 4096;
    7453. 

  7453.     load_raw = &CLASS packed_load_raw;
    7454. 

  7454.     load_flags = 88;
    7455. 

  7455.     filters = 0x61616161;
    7456. 

  7456.   } else if (!memcmp (head+4,"RED1",4)) {
    7457. 

  7457.     strcpy (make, "RED");
    7458. 

  7458.     strcpy (model,"ONE");
    7459. 

  7459.     parse_redcine();
    7460. 

  7460.     load_raw = &CLASS redcine_load_raw;
    7461. 

  7461.     gamma_curve (1/2.4, 12.92, 1, 4095);
    7462. 

  7462.     filters = 0x49494949;
    7463. 

  7463.   } else if (!memcmp (head,"DSC-Image",9))
    7464. 

  7464.     parse_rollei();
    7465. 

  7465.   else if (!memcmp (head,"PWAD",4))
    7466. 

  7466.     parse_sinar_ia();
    7467. 

  7467.   else if (!memcmp (head,"\0MRM",4))
    7468. 

  7468.     parse_minolta(0);
    7469. 

  7469. #ifdef LIBRAW_DEMOSAIC_PACK_GPL2
    7470. 

  7470.   else if (!memcmp (head,"FOVb",4))
    7471. 

  7471.     parse_foveon();
    7472. 

  7472. #endif
    7473. 

  7473.   else if (!memcmp (head,"CI",2))
    7474. 

  7474.     parse_cine();
    7475. 

  7475.   else
    7476. 

  7476.     for (zero_fsize=i=0; i < sizeof table / sizeof *table; i++)
    7477. 

  7477.       if (fsize == table[i].fsize) {
    7478. 

  7478. 	strcpy (make,  table[i].t_make );
    7479. 

  7479. 	strcpy (model, table[i].t_model);
    7480. 

  7480. 	if (table[i].withjpeg)
    7481. 

  7481. 	  parse_external_jpeg();
    7482. 

  7482.       }
    7483. 

  7483.   if (zero_fsize) fsize = 0;
    7484. 

  7484.   if (make[0] == 0) parse_smal (0, flen);
    7485. 

  7485.   if (make[0] == 0) {
    7486. 

  7486.     parse_jpeg(0);
    7487. 

  7487.     fseek(ifp,0,SEEK_END);
    7488. 

  7488.     int sz = ftell(ifp);
    7489. 

  7489.     if (!strncmp(model,"ov",2) && sz>=6404096 && !fseek (ifp, -6404096, SEEK_END) &&
    7490. 

  7490. 	fread (head, 1, 32, ifp) && !strcmp(head,"BRCMn")) {
    7491. 

  7491.       strcpy (make, "OmniVision");
    7492. 

  7492.       data_offset = ftell(ifp) + 0x8000-32;
    7493. 

  7493.       width = raw_width;
    7494. 

  7494.       raw_width = 2611;
    7495. 

  7495.       load_raw = &CLASS nokia_load_raw;
    7496. 

  7496.       filters = 0x16161616;
    7497. 

  7497.     } else is_raw = 0;
    7498. 

  7498.   }
    7499. 

  7499. 

  7500.   for (i=0; i < sizeof corp / sizeof *corp; i++)
    7501. 

  7501.     if (strstr (make, corp[i]))		/* Simplify company names */
    7502. 

  7502. 	strcpy (make, corp[i]);
    7503. 

  7503.   if (!strncmp (make,"KODAK",5) &&
    7504. 

  7504. 	((cp = strstr(model," DIGITAL CAMERA")) ||
    7505. 

  7505. 	 (cp = strstr(model," Digital Camera")) ||
    7506. 

  7506. 	 (cp = strstr(model,"FILE VERSION"))))
    7507. 

  7507.      *cp = 0;
    7508. 

  7508.   cp = make + strlen(make);		/* Remove trailing spaces */
    7509. 

  7509.   while (*--cp == ' ') *cp = 0;
    7510. 

  7510.   cp = model + strlen(model);
    7511. 

  7511.   while (*--cp == ' ') *cp = 0;
    7512. 

  7512.   i = strlen(make);			/* Remove make from model */
    7513. 

  7513.   if (!strncasecmp (model, make, i) && model[i++] == ' ')
    7514. 

  7514.     memmove (model, model+i, 64-i);
    7515. 

  7515.   if (!strncmp (model,"FinePix ",8))
    7516. 

  7516.     strcpy (model, model+8);
    7517. 

  7517.   if (!strncmp (model,"Digital Camera ",15))
    7518. 

  7518.     strcpy (model, model+15);
    7519. 

  7519.   desc[511] = artist[63] = make[63] = model[63] = model2[63] = 0;
    7520. 

  7520.   if (!is_raw) goto notraw;
    7521. 

  7521. 

  7522.   if (!height) height = raw_height;
    7523. 

  7523.   if (!width)  width  = raw_width;
    7524. 

  7524.   if (height == 2624 && width == 3936)	/* Pentax K10D and Samsung GX10 */
    7525. 

  7525.     { height  = 2616;   width  = 3896; }
    7526. 

  7526.   if (height == 3136 && width == 4864)  /* Pentax K20D and Samsung GX20 */
    7527. 

  7527.     { height  = 3124;   width  = 4688; filters = 0x16161616; }
    7528. 

  7528.   if (width == 4352 && (!strcmp(model,"K-r") || !strcmp(model,"K-x")))
    7529. 

  7529.     {			width  = 4309; filters = 0x16161616; }
    7530. 

  7530.   if (width >= 4960 && !strncmp(model,"K-5",3))
    7531. 

  7531.     { left_margin = 10; width  = 4950; filters = 0x16161616; }
    7532. 

  7532.   if (width >= 4960 && !strncmp(model,"K-5 II",6))
    7533. 

  7533.     { left_margin = 10; width  = 4948; filters = 0x16161616; }
    7534. 

  7534.   if (width == 4736 && !strcmp(model,"K-7"))
    7535. 

  7535.     { height  = 3122;   width  = 4684; filters = 0x16161616; top_margin = 2; }
    7536. 

  7536.   if (width == 7424 && !strcmp(model,"645D"))
    7537. 

  7537.     { height  = 5502;   width  = 7328; filters = 0x61616161; top_margin = 29;
    7538. 

  7538.       left_margin = 48; }
    7539. 

  7539.   if (height == 3014 && width == 4096)	/* Ricoh GX200 */
    7540. 

  7540. 			width  = 4014;
    7541. 

  7541.   if (dng_version) {
    7542. 

  7542.     if (filters == UINT_MAX) filters = 0;
    7543. 

  7543.     if (filters) is_raw = tiff_samples;
    7544. 

  7544.     else	 colors = tiff_samples;
    7545. 

  7545.     if (tiff_compress == 1)
    7546. 

  7546.       load_raw = &CLASS packed_dng_load_raw;
    7547. 

  7547.     if (tiff_compress == 7)
    7548. 

  7548.       load_raw = &CLASS lossless_dng_load_raw;
    7549. 

  7549.     goto dng_skip;
    7550. 

  7550.   }
    7551. 

  7551.   if ((is_canon = !strcmp(make,"Canon")))
    7552. 

  7552.     load_raw = memcmp (head+6,"HEAPCCDR",8) ?
    7553. 

  7553. 	&CLASS lossless_jpeg_load_raw : &CLASS canon_load_raw;
    7554. 

  7554.   if (!strcmp(make,"NIKON")) {
    7555. 

  7555.     if (!load_raw)
    7556. 

  7556.       load_raw = &CLASS packed_load_raw;
    7557. 

  7557.     if (model[0] == 'E')
    7558. 

  7558.       load_flags |= !data_offset << 2 | 2;
    7559. 

  7559.   }
    7560. 

  7560.   if (!strcmp(make,"CASIO")) {
    7561. 

  7561.     load_raw = &CLASS packed_load_raw;
    7562. 

  7562.     maximum = 0xf7f;
    7563. 

  7563.   }
    7564. 

  7564. 

  7565. /* Set parameters based on camera name (for non-DNG files). */
    7566. 

  7566. 

  7567.   if (is_foveon) {
    7568. 

  7568.     if (height*2 < width) pixel_aspect = 0.5;
    7569. 

  7569.     if (height   > width) pixel_aspect = 2;
    7570. 

  7570.     filters = 0;
    7571. 

  7571.     simple_coeff(0);
    7572. 

  7572.   } else if (is_canon && tiff_bps == 15) {
    7573. 

  7573.     switch (width) {
    7574. 

  7574.       case 3344: width -= 66;
    7575. 

  7575.       case 3872: width -= 6;
    7576. 

  7576.     }
    7577. 

  7577.     if (height > width) SWAP(height,width);
    7578. 

  7578.     filters = 0;
    7579. 

  7579.     load_raw = &CLASS canon_sraw_load_raw;
    7580. 

  7580.   } else if (!strcmp(model,"PowerShot 600")) {
    7581. 

  7581.     height = 613;
    7582. 

  7582.     width  = 854;
    7583. 

  7583.     raw_width = 896;
    7584. 

  7584.     pixel_aspect = 607/628.0;
    7585. 

  7585.     colors = 4;
    7586. 

  7586.     filters = 0xe1e4e1e4;
    7587. 

  7587.     load_raw = &CLASS canon_600_load_raw;
    7588. 

  7588.   } else if (!strcmp(model,"PowerShot A5") ||
    7589. 

  7589. 	     !strcmp(model,"PowerShot A5 Zoom")) {
    7590. 

  7590.     height = 773;
    7591. 

  7591.     width  = 960;
    7592. 

  7592.     raw_width = 992;
    7593. 

  7593.     pixel_aspect = 256/235.0;
    7594. 

  7594.     colors = 4;
    7595. 

  7595.     filters = 0x1e4e1e4e;
    7596. 

  7596.     goto canon_a5;
    7597. 

  7597.   } else if (!strcmp(model,"PowerShot A50")) {
    7598. 

  7598.     height =  968;
    7599. 

  7599.     width  = 1290;
    7600. 

  7600.     raw_width = 1320;
    7601. 

  7601.     colors = 4;
    7602. 

  7602.     filters = 0x1b4e4b1e;
    7603. 

  7603.     goto canon_a5;
    7604. 

  7604.   } else if (!strcmp(model,"PowerShot Pro70")) {
    7605. 

  7605.     height = 1024;
    7606. 

  7606.     width  = 1552;
    7607. 

  7607.     colors = 4;
    7608. 

  7608.     filters = 0x1e4b4e1b;
    7609. 

  7609.     goto canon_a5;
    7610. 

  7610.   } else if (!strcmp(model,"PowerShot SD300")) {
    7611. 

  7611.     height = 1752;
    7612. 

  7612.     width  = 2344;
    7613. 

  7613.     raw_height = 1766;
    7614. 

  7614.     raw_width  = 2400;
    7615. 

  7615.     top_margin  = 12;
    7616. 

  7616.     left_margin = 12;
    7617. 

  7617.     goto canon_a5;
    7618. 

  7618.   } else if (!strcmp(model,"PowerShot A460")) {
    7619. 

  7619.     height = 1960;
    7620. 

  7620.     width  = 2616;
    7621. 

  7621.     raw_height = 1968;
    7622. 

  7622.     raw_width  = 2664;
    7623. 

  7623.     top_margin  = 4;
    7624. 

  7624.     left_margin = 4;
    7625. 

  7625.     goto canon_a5;
    7626. 

  7626.   } else if (!strcmp(model,"PowerShot A530")) {
    7627. 

  7627.     height = 1984;
    7628. 

  7628.     width  = 2620;
    7629. 

  7629.     raw_height = 1992;
    7630. 

  7630.     raw_width  = 2672;
    7631. 

  7631.     top_margin  = 6;
    7632. 

  7632.     left_margin = 10;
    7633. 

  7633.     goto canon_a5;
    7634. 

  7634.   } else if (!strcmp(model,"PowerShot A610")) {
    7635. 

  7635.     if (canon_s2is()) strcpy (model+10, "S2 IS");
    7636. 

  7636.     height = 1960;
    7637. 

  7637.     width  = 2616;
    7638. 

  7638.     raw_height = 1968;
    7639. 

  7639.     raw_width  = 2672;
    7640. 

  7640.     top_margin  = 8;
    7641. 

  7641.     left_margin = 12;
    7642. 

  7642.     goto canon_a5;
    7643. 

  7643.   } else if (!strcmp(model,"PowerShot A620")) {
    7644. 

  7644.     height = 2328;
    7645. 

  7645.     width  = 3112;
    7646. 

  7646.     raw_height = 2340;
    7647. 

  7647.     raw_width  = 3152;
    7648. 

  7648.     top_margin  = 12;
    7649. 

  7649.     left_margin = 36;
    7650. 

  7650.     goto canon_a5;
    7651. 

  7651.   } else if (!strcmp(model,"PowerShot A470")) {
    7652. 

  7652.     height = 2328;
    7653. 

  7653.     width  = 3096;
    7654. 

  7654.     raw_height = 2346;
    7655. 

  7655.     raw_width  = 3152;
    7656. 

  7656.     top_margin  = 6;
    7657. 

  7657.     left_margin = 12;
    7658. 

  7658.     goto canon_a5;
    7659. 

  7659.   } else if (!strcmp(model,"PowerShot A720 IS")) {
    7660. 

  7660.     height = 2472;
    7661. 

  7661.     width  = 3298;
    7662. 

  7662.     raw_height = 2480;
    7663. 

  7663.     raw_width  = 3336;
    7664. 

  7664.     top_margin  = 5;
    7665. 

  7665.     left_margin = 6;
    7666. 

  7666.     goto canon_a5;
    7667. 

  7667.   } else if (!strcmp(model,"PowerShot A630")) {
    7668. 

  7668.     height = 2472;
    7669. 

  7669.     width  = 3288;
    7670. 

  7670.     raw_height = 2484;
    7671. 

  7671.     raw_width  = 3344;
    7672. 

  7672.     top_margin  = 6;
    7673. 

  7673.     left_margin = 12;
    7674. 

  7674.     goto canon_a5;
    7675. 

  7675.   } else if (!strcmp(model,"PowerShot A640")) {
    7676. 

  7676.     height = 2760;
    7677. 

  7677.     width  = 3672;
    7678. 

  7678.     raw_height = 2772;
    7679. 

  7679.     raw_width  = 3736;
    7680. 

  7680.     top_margin  = 6;
    7681. 

  7681.     left_margin = 12;
    7682. 

  7682.     goto canon_a5;
    7683. 

  7683.   } else if (!strcmp(model,"PowerShot A650")) {
    7684. 

  7684.     height = 3024;
    7685. 

  7685.     width  = 4032;
    7686. 

  7686.     raw_height = 3048;
    7687. 

  7687.     raw_width  = 4104;
    7688. 

  7688.     top_margin  = 12;
    7689. 

  7689.     left_margin = 48;
    7690. 

  7690.     goto canon_a5;
    7691. 

  7691.   } else if (!strcmp(model,"PowerShot S3 IS")) {
    7692. 

  7692.     height = 2128;
    7693. 

  7693.     width  = 2840;
    7694. 

  7694.     raw_height = 2136;
    7695. 

  7695.     raw_width  = 2888;
    7696. 

  7696.     top_margin  = 8;
    7697. 

  7697.     left_margin = 44;
    7698. 

  7698. canon_a5:
    7699. 

  7699.     tiff_bps = 10;
    7700. 

  7700.     load_raw = &CLASS packed_load_raw;
    7701. 

  7701.     load_flags = 40;
    7702. 

  7702.     if (raw_width > 1600) zero_is_bad = 1;
    7703. 

  7703.   } else if (!strcmp(model,"PowerShot SX110 IS")) {
    7704. 

  7704.     height = 2760;
    7705. 

  7705.     width  = 3684;
    7706. 

  7706.     raw_height = 2772;
    7707. 

  7707.     raw_width  = 3720;
    7708. 

  7708.     top_margin  = 12;
    7709. 

  7709.     left_margin = 6;
    7710. 

  7710.     load_raw = &CLASS packed_load_raw;
    7711. 

  7711.     load_flags = 40;
    7712. 

  7712.     zero_is_bad = 1;
    7713. 

  7713.   } else if (!strcmp(model,"PowerShot SX120 IS")) {
    7714. 

  7714.     height = 2742;
    7715. 

  7715.     width  = 3664;
    7716. 

  7716.     raw_height = 2778;
    7717. 

  7717.     raw_width  = 3728;
    7718. 

  7718.     top_margin  = 18;
    7719. 

  7719.     left_margin = 16;
    7720. 

  7720.     filters = 0x49494949;
    7721. 

  7721.     load_raw = &CLASS packed_load_raw;
    7722. 

  7722.     load_flags = 40;
    7723. 

  7723.     zero_is_bad = 1;
    7724. 

  7724.   } else if (!strcmp(model,"PowerShot SX20 IS")) {
    7725. 

  7725.     height = 3024;
    7726. 

  7726.     width  = 4032;
    7727. 

  7727.     raw_height = 3048;
    7728. 

  7728.     raw_width  = 4080;
    7729. 

  7729.     top_margin  = 12;
    7730. 

  7730.     left_margin = 24;
    7731. 

  7731.     load_raw = &CLASS packed_load_raw;
    7732. 

  7732.     load_flags = 40;
    7733. 

  7733.     zero_is_bad = 1;
    7734. 

  7734.   } else if (!strcmp(model,"PowerShot SX220 HS")) {
    7735. 

  7735.     height = 3043;
    7736. 

  7736.     width  = 4072;
    7737. 

  7737.     raw_height = 3060;
    7738. 

  7738.     raw_width  = 4168;
    7739. 

  7739.     mask[0][0] = top_margin = 16;
    7740. 

  7740.     mask[0][2] = top_margin + height;
    7741. 

  7741.     mask[0][3] = left_margin = 92;
    7742. 

  7742.     load_raw = &CLASS packed_load_raw;
    7743. 

  7743.     load_flags = 8;
    7744. 

  7744.     zero_is_bad = 1;
    7745. 

  7745.   } else if (!strcmp(model,"PowerShot SX50 HS")) {
    7746. 

  7746.     top_margin=16;
    7747. 

  7747.     left_margin=94;
    7748. 

  7748.     height = 3043;
    7749. 

  7749.     width  = 4072;
    7750. 

  7750.   } else if (!strcmp(model,"PowerShot SX30 IS")) {
    7751. 

  7751.     height = 3254;
    7752. 

  7752.     width  = 4366;
    7753. 

  7753.     raw_height = 3276;
    7754. 

  7754.     raw_width  = 4464;
    7755. 

  7755.     top_margin  = 10;
    7756. 

  7756.     left_margin = 25;
    7757. 

  7757.     filters = 0x16161616;
    7758. 

  7758.     load_raw = &CLASS packed_load_raw;
    7759. 

  7759.     load_flags = 40;
    7760. 

  7760.     zero_is_bad = 1;
    7761. 

  7761.   } else if (!strcmp(model,"PowerShot Pro90 IS")) {
    7762. 

  7762.     width  = 1896;
    7763. 

  7763.     colors = 4;
    7764. 

  7764.     filters = 0xb4b4b4b4;
    7765. 

  7765.   } else if (is_canon && raw_width == 2144) {
    7766. 

  7766.     height = 1550;
    7767. 

  7767.     width  = 2088;
    7768. 

  7768.     top_margin  = 8;
    7769. 

  7769.     left_margin = 4;
    7770. 

  7770.     if (!strcmp(model,"PowerShot G1")) {
    7771. 

  7771.       colors = 4;
    7772. 

  7772.       filters = 0xb4b4b4b4;
    7773. 

  7773.     }
    7774. 

  7774.   } else if (is_canon && raw_width == 2224) {
    7775. 

  7775.     height = 1448;
    7776. 

  7776.     width  = 2176;
    7777. 

  7777.     top_margin  = 6;
    7778. 

  7778.     left_margin = 48;
    7779. 

  7779.   } else if (is_canon && raw_width == 2376) {
    7780. 

  7780.     height = 1720;
    7781. 

  7781.     width  = 2312;
    7782. 

  7782.     top_margin  = 6;
    7783. 

  7783.     left_margin = 12;
    7784. 

  7784.   } else if (is_canon && raw_width == 2672) {
    7785. 

  7785.     height = 1960;
    7786. 

  7786.     width  = 2616;
    7787. 

  7787.     top_margin  = 6;
    7788. 

  7788.     left_margin = 12;
    7789. 

  7789.   } else if (is_canon && raw_width == 3152) {
    7790. 

  7790.     height = 2056;
    7791. 

  7791.     width  = 3088;
    7792. 

  7792.     top_margin  = 12;
    7793. 

  7793.     left_margin = 64;
    7794. 

  7794.     if (unique_id == 0x80000170)
    7795. 

  7795.       adobe_coeff ("Canon","EOS 300D");
    7796. 

  7796.   } else if (is_canon && raw_width == 3160) {
    7797. 

  7797.     height = 2328;
    7798. 

  7798.     width  = 3112;
    7799. 

  7799.     top_margin  = 12;
    7800. 

  7800.     left_margin = 44;
    7801. 

  7801.   } else if (is_canon && raw_width == 3344) {
    7802. 

  7802.     height = 2472;
    7803. 

  7803.     width  = 3288;
    7804. 

  7804.     top_margin  = 6;
    7805. 

  7805.     left_margin = 4;
    7806. 

  7806.   } else if (!strcmp(model,"EOS D2000C")) {
    7807. 

  7807.     filters = 0x61616161;
    7808. 

  7808.     black = curve[200];
    7809. 

  7809.   } else if (is_canon && raw_width == 3516) {
    7810. 

  7810.     top_margin  = 14;
    7811. 

  7811.     left_margin = 42;
    7812. 

  7812.     if (unique_id == 0x80000189)
    7813. 

  7813.       adobe_coeff ("Canon","EOS 350D");
    7814. 

  7814.     goto canon_cr2;
    7815. 

  7815.   } else if (is_canon && raw_width == 3596) {
    7816. 

  7816.     top_margin  = 12;
    7817. 

  7817.     left_margin = 74;
    7818. 

  7818.     goto canon_cr2;
    7819. 

  7819.   } else if (is_canon && raw_width == 3744) {
    7820. 

  7820.     height = 2760;
    7821. 

  7821.     width  = 3684;
    7822. 

  7822.     top_margin  = 16;
    7823. 

  7823.     left_margin = 8;
    7824. 

  7824.     if (unique_id > 0x2720000) {
    7825. 

  7825.       top_margin  = 12;
    7826. 

  7826.       left_margin = 52;
    7827. 

  7827.     }
    7828. 

  7828.   } else if (is_canon && raw_width == 3944) {
    7829. 

  7829.     height = 2602;
    7830. 

  7830.     width  = 3908;
    7831. 

  7831.     top_margin  = 18;
    7832. 

  7832.     left_margin = 30;
    7833. 

  7833.   } else if (is_canon && raw_width == 3948) {
    7834. 

  7834.     top_margin  = 18;
    7835. 

  7835.     left_margin = 42;
    7836. 

  7836.     height -= 2;
    7837. 

  7837.     if (unique_id == 0x80000236)
    7838. 

  7838.       adobe_coeff ("Canon","EOS 400D");
    7839. 

  7839.     if (unique_id == 0x80000254)
    7840. 

  7840.       adobe_coeff ("Canon","EOS 1000D");
    7841. 

  7841.     goto canon_cr2;
    7842. 

  7842.   } else if (is_canon && raw_width == 3984) {
    7843. 

  7843.     top_margin  = 20;
    7844. 

  7844.     left_margin = 76;
    7845. 

  7845.     height -= 2;
    7846. 

  7846.     goto canon_cr2;
    7847. 

  7847.   } else if (is_canon && raw_width == 4104) {
    7848. 

  7848.     height = 3024;
    7849. 

  7849.     width  = 4032;
    7850. 

  7850.     top_margin  = 12;
    7851. 

  7851.     left_margin = 48;
    7852. 

  7852.   } else if (is_canon && raw_width == 4152) {
    7853. 

  7853.     top_margin  = 12;
    7854. 

  7854.     left_margin = 192;
    7855. 

  7855.     goto canon_cr2;
    7856. 

  7856.   } else if (is_canon && raw_width == 4160) {
    7857. 

  7857.     height = 3048;
    7858. 

  7858.     width  = 4048;
    7859. 

  7859.     top_margin  = 11;
    7860. 

  7860.     left_margin = 104;
    7861. 

  7861.   } else if (is_canon && raw_width == 4176) {
    7862. 

  7862.     height = 3045;
    7863. 

  7863.     width  = 4072;
    7864. 

  7864.     left_margin = 96;
    7865. 

  7865.     mask[0][0] = top_margin = 17;
    7866. 

  7866.     mask[0][2] = raw_height;
    7867. 

  7867.     mask[0][3] = 80;
    7868. 

  7868.     filters = 0x49494949;
    7869. 

  7869.   } else if (is_canon && raw_width == 4312) {
    7870. 

  7870.     top_margin  = 18;
    7871. 

  7871.     left_margin = 22;
    7872. 

  7872.     height -= 2;
    7873. 

  7873.     if (unique_id == 0x80000176)
    7874. 

  7874.       adobe_coeff ("Canon","EOS 450D");
    7875. 

  7875.     goto canon_cr2;
    7876. 

  7876.   } else if (is_canon && raw_width == 4352) {
    7877. 

  7877.     top_margin  = 18;
    7878. 

  7878.     left_margin = 62;
    7879. 

  7879.     if (unique_id == 0x80000288)
    7880. 

  7880.       adobe_coeff ("Canon","EOS 1100D");
    7881. 

  7881.     goto canon_cr2;
    7882. 

  7882.   } else if (is_canon && raw_width == 4476) {
    7883. 

  7883.     top_margin  = 34;
    7884. 

  7884.     left_margin = 90;
    7885. 

  7885.     goto canon_cr2;
    7886. 

  7886.   } else if (is_canon && raw_width == 4480) {
    7887. 

  7887.     height = 3326;
    7888. 

  7888.     width  = 4432;
    7889. 

  7889.     top_margin  = 10;
    7890. 

  7890.     left_margin = 12;
    7891. 

  7891.     filters = 0x49494949;
    7892. 

  7892.   } else if (is_canon && raw_width == 4496) {
    7893. 

  7893.     height = 3316;
    7894. 

  7894.     width  = 4404;
    7895. 

  7895.     top_margin  = 50;
    7896. 

  7896.     left_margin = 80;
    7897. 

  7897.   } else if (is_canon && raw_width == 4832) {
    7898. 

  7898.     top_margin = unique_id == 0x80000261 ? 51:26;
    7899. 

  7899.     left_margin = 62;
    7900. 

  7900.     if (unique_id == 0x80000252)
    7901. 

  7901.       adobe_coeff ("Canon","EOS 500D");
    7902. 

  7902.     goto canon_cr2;
    7903. 

  7903.   } else if (is_canon && raw_width == 5108) {
    7904. 

  7904.     top_margin  = 13;
    7905. 

  7905.     left_margin = 98;
    7906. 

  7906.     goto canon_cr2;
    7907. 

  7907.   } else if (is_canon && raw_width == 5120) {
    7908. 

  7908.     height -= top_margin = 45;
    7909. 

  7909.     left_margin = 142;
    7910. 

  7910.     width = 4916;
    7911. 

  7911.   } else if (is_canon && raw_width == 5280) {
    7912. 

  7912.     top_margin  = 52;
    7913. 

  7913.     left_margin = 72;
    7914. 

  7914.     if (unique_id == 0x80000301)
    7915. 

  7915.       adobe_coeff ("Canon","EOS 650D");
    7916. 

  7916.     goto canon_cr2;
    7917. 

  7917.   } else if (is_canon && raw_width == 5344) {
    7918. 

  7918.     top_margin = 51;
    7919. 

  7919.     left_margin = 142;
    7920. 

  7920.     if (unique_id == 0x80000269) {
    7921. 

  7921.       top_margin = 100;
    7922. 

  7922.       left_margin = 126;
    7923. 

  7923.       height -= 2;
    7924. 

  7924.       adobe_coeff ("Canon","EOS-1D X");
    7925. 

  7925.     }
    7926. 

  7926.     if (unique_id == 0x80000270)
    7927. 

  7927.       adobe_coeff ("Canon","EOS 550D");
    7928. 

  7928.     if (unique_id == 0x80000286)
    7929. 

  7929.       adobe_coeff ("Canon","EOS 600D");
    7930. 

  7930.     goto canon_cr2;
    7931. 

  7931.   } else if (is_canon && raw_width == 5360) {
    7932. 

  7932.     top_margin = 51;
    7933. 

  7933.     left_margin = 158;
    7934. 

  7934.     goto canon_cr2;
    7935. 

  7935.   } else if (is_canon && raw_width == 5568) {
    7936. 

  7936.     top_margin = 38;
    7937. 

  7937.     left_margin = 72;
    7938. 

  7938.     goto canon_cr2;
    7939. 

  7939.   } else if (is_canon && raw_width == 5712) {
    7940. 

  7940.     height = 3752;
    7941. 

  7941.     width  = 5640;
    7942. 

  7942.     top_margin  = 20;
    7943. 

  7943.     left_margin = 62;
    7944. 

  7944.   } else if (is_canon && raw_width == 5792) {
    7945. 

  7945.     top_margin  = 51;
    7946. 

  7946.     left_margin = 158;
    7947. 

  7947. canon_cr2:
    7948. 

  7948.     height -= top_margin;
    7949. 

  7949.     width  -= left_margin;
    7950. 

  7950.   } else if (is_canon && raw_width == 5920) {
    7951. 

  7951.     height = 3870;
    7952. 

  7952.     width  = 5796;
    7953. 

  7953.     top_margin  = 80;
    7954. 

  7954.     left_margin = 122;
    7955. 

  7955.   } else if (!strcmp(model,"D1")) {
    7956. 

  7956.     cam_mul[0] *= 256/527.0;
    7957. 

  7957.     cam_mul[2] *= 256/317.0;
    7958. 

  7958.   } else if (!strcmp(model,"D1X")) {
    7959. 

  7959.     width -= 4;
    7960. 

  7960.     pixel_aspect = 0.5;
    7961. 

  7961.   } else if (!strcmp(model,"D40X") ||
    7962. 

  7962. 	     !strcmp(model,"D60")  ||
    7963. 

  7963. 	     !strcmp(model,"D80")  ||
    7964. 

  7964. 	     !strcmp(model,"D3000")) {
    7965. 

  7965.     height -= 3;
    7966. 

  7966.     width  -= 4;
    7967. 

  7967.   } else if (!strcmp(model,"D3")   ||
    7968. 

  7968. 	     !strcmp(model,"D3S")  ||
    7969. 

  7969. 	     !strcmp(model,"D700")) {
    7970. 

  7970.     width -= 4;
    7971. 

  7971.     left_margin = 2;
    7972. 

  7972.   } else if (!strcmp(model,"D3100")) {
    7973. 

  7973.     width -= 28;
    7974. 

  7974.     left_margin = 6;
    7975. 

  7975.   } else if (!strcmp(model,"D5000") ||
    7976. 

  7976. 	     !strcmp(model,"D90")) {
    7977. 

  7977.     width -= 42;
    7978. 

  7978.   } else if (!strcmp(model,"D5100") ||
    7979. 

  7979. 	     !strcmp(model,"D7000")) {
    7980. 

  7980.     width -= 44;
    7981. 

  7981.   } else if (!strcmp(model,"D3200") ||
    7982. 

  7982. 	     !strcmp(model,"D800E") ||
    7983. 

  7983. 	     !strcmp(model,"D600")  ||
    7984. 

  7984. 	     !strcmp(model,"D800")) {
    7985. 

  7985.     width -= 46;
    7986. 

  7986.   } else if (!strcmp(model,"D4")) {
    7987. 

  7987.     width -= 52;
    7988. 

  7988.     left_margin = 2;
    7989. 

  7989.   } else if (!strcmp(model,"D600")) {
    7990. 

  7990.     width -= 48;
    7991. 

  7991.   } else if (!strncmp(model,"D40",3) ||
    7992. 

  7992. 	     !strncmp(model,"D50",3) ||
    7993. 

  7993. 	     !strncmp(model,"D70",3)) {
    7994. 

  7994.     width--;
    7995. 

  7995.   } else if (!strcmp(model,"D100")) {
    7996. 

  7996.     if (load_flags)
    7997. 

  7997.       raw_width = (width += 3) + 3;
    7998. 

  7998.   } else if (!strcmp(model,"D200")) {
    7999. 

  7999.     left_margin = 1;
    8000. 

  8000.     width -= 4;
    8001. 

  8001.     filters = 0x94949494;
    8002. 

  8002.   } else if (!strncmp(model,"D2H",3)) {
    8003. 

  8003.     left_margin = 6;
    8004. 

  8004.     width -= 14;
    8005. 

  8005.   } else if (!strncmp(model,"D2X",3)) {
    8006. 

  8006.     if (width == 3264) width -= 32;
    8007. 

  8007.     else width -= 8;
    8008. 

  8008.   } else if (!strncmp(model,"D300",4)) {
    8009. 

  8009.     width -= 32;
    8010. 

  8010.   } else if (!strcmp(make,"NIKON") && raw_width == 4032) {
    8011. 

  8011.     adobe_coeff ("NIKON","COOLPIX P7700");
    8012. 

  8012.   } else if (!strncmp(model,"COOLPIX P",9)) {
    8013. 

  8013.     load_flags = 24;
    8014. 

  8014.     filters = 0x94949494;
    8015. 

  8015.     if (model[9] == '7' && iso_speed >= 400)
    8016. 

  8016.       black = 255;
    8017. 

  8017.   } else if (!strncmp(model,"COOLPIX A",9) && raw_width == 4992) {
    8018. 

  8018. 	  width = 4948;
    8019. 

  8019.   } else if (!strncmp(model,"1 ",2)) {
    8020. 

  8020.     height -= 2;
    8021. 

  8021.   } else if (fsize == 1581060) {
    8022. 

  8022.     height = 963;
    8023. 

  8023.     width = 1287;
    8024. 

  8024.     raw_width = 1632;
    8025. 

  8025.     maximum = 0x3f4;
    8026. 

  8026.     colors = 4;
    8027. 

  8027.     filters = 0x1e1e1e1e;
    8028. 

  8028.     simple_coeff(3);
    8029. 

  8029.     pre_mul[0] = 1.2085;
    8030. 

  8030.     pre_mul[1] = 1.0943;
    8031. 

  8031.     pre_mul[3] = 1.1103;
    8032. 

  8032.     goto e900;
    8033. 

  8033.   } else if (fsize == 2465792) {
    8034. 

  8034.     height = 1203;
    8035. 

  8035.     width  = 1616;
    8036. 

  8036.     raw_width = 2048;
    8037. 

  8037.     colors = 4;
    8038. 

  8038.     filters = 0x4b4b4b4b;
    8039. 

  8039.     adobe_coeff ("NIKON","E950");
    8040. 

  8040. e900:
    8041. 

  8041.     tiff_bps = 10;
    8042. 

  8042.     load_raw = &CLASS packed_load_raw;
    8043. 

  8043.     load_flags = 6;
    8044. 

  8044.   } else if (fsize == 4771840) {
    8045. 

  8045.     height = 1540;
    8046. 

  8046.     width  = 2064;
    8047. 

  8047.     colors = 4;
    8048. 

  8048.     filters = 0xe1e1e1e1;
    8049. 

  8049.     load_raw = &CLASS packed_load_raw;
    8050. 

  8050.     load_flags = 6;
    8051. 

  8051.     if (!timestamp && nikon_e995())
    8052. 

  8052.       strcpy (model, "E995");
    8053. 

  8053.     if (strcmp(model,"E995")) {
    8054. 

  8054.       filters = 0xb4b4b4b4;
    8055. 

  8055.       simple_coeff(3);
    8056. 

  8056.       pre_mul[0] = 1.196;
    8057. 

  8057.       pre_mul[1] = 1.246;
    8058. 

  8058.       pre_mul[2] = 1.018;
    8059. 

  8059.     }
    8060. 

  8060.   } else if (!strcmp(model,"E2100")) {
    8061. 

  8061.     if (!timestamp && !nikon_e2100()) goto cp_e2500;
    8062. 

  8062.     height = 1206;
    8063. 

  8063.     width  = 1616;
    8064. 

  8064.     load_flags = 30;
    8065. 

  8065.   } else if (!strcmp(model,"E2500")) {
    8066. 

  8066. cp_e2500:
    8067. 

  8067.     strcpy (model, "E2500");
    8068. 

  8068.     height = 1204;
    8069. 

  8069.     width  = 1616;
    8070. 

  8070.     colors = 4;
    8071. 

  8071.     filters = 0x4b4b4b4b;
    8072. 

  8072.   } else if (fsize == 4775936) {
    8073. 

  8073.     height = 1542;
    8074. 

  8074.     width  = 2064;
    8075. 

  8075.     load_raw = &CLASS packed_load_raw;
    8076. 

  8076.     load_flags = 30;
    8077. 

  8077.     if (!timestamp) nikon_3700();
    8078. 

  8078.     if (model[0] == 'E' && atoi(model+1) < 3700)
    8079. 

  8079.       filters = 0x49494949;
    8080. 

  8080.     if (!strcmp(model,"Optio 33WR")) {
    8081. 

  8081.       flip = 1;
    8082. 

  8082.       filters = 0x16161616;
    8083. 

  8083.     }
    8084. 

  8084.     if (make[0] == 'O') {
    8085. 

  8085.       i = find_green (12, 32, 1188864, 3576832);
    8086. 

  8086.       c = find_green (12, 32, 2383920, 2387016);
    8087. 

  8087.       if (abs(i) < abs(c)) {
    8088. 

  8088. 	SWAP(i,c);
    8089. 

  8089. 	load_flags = 24;
    8090. 

  8090.       }
    8091. 

  8091.       if (i < 0) filters = 0x61616161;
    8092. 

  8092.     }
    8093. 

  8093.   } else if (fsize == 5869568) {
    8094. 

  8094.     height = 1710;
    8095. 

  8095.     width  = 2288;
    8096. 

  8096.     filters = 0x16161616;
    8097. 

  8097.     if (!timestamp && minolta_z2()) {
    8098. 

  8098.       strcpy (make, "Minolta");
    8099. 

  8099.       strcpy (model,"DiMAGE Z2");
    8100. 

  8100.     }
    8101. 

  8101.     load_raw = &CLASS packed_load_raw;
    8102. 

  8102.     load_flags = 6 + 24*(make[0] == 'M');
    8103. 

  8103.   } else if (!strcmp(model,"E4500")) {
    8104. 

  8104.     height = 1708;
    8105. 

  8105.     width  = 2288;
    8106. 

  8106.     colors = 4;
    8107. 

  8107.     filters = 0xb4b4b4b4;
    8108. 

  8108.   } else if (fsize == 7438336) {
    8109. 

  8109.     height = 1924;
    8110. 

  8110.     width  = 2576;
    8111. 

  8111.     colors = 4;
    8112. 

  8112.     filters = 0xb4b4b4b4;
    8113. 

  8113.   } else if (fsize == 8998912) {
    8114. 

  8114.     height = 2118;
    8115. 

  8115.     width  = 2832;
    8116. 

  8116.     maximum = 0xf83;
    8117. 

  8117.     load_raw = &CLASS packed_load_raw;
    8118. 

  8118.     load_flags = 30;
    8119. 

  8119.   } else if (!strcmp(make,"FUJIFILM")) {
    8120. 

  8120.     if (!strcmp(model+7,"S2Pro")) {
    8121. 

  8121.       strcpy (model,"S2Pro");
    8122. 

  8122.       height = 2144;
    8123. 

  8123.       width  = 2880;
    8124. 

  8124.       flip = 6;
    8125. 

  8125.     } else if (load_raw != &CLASS packed_load_raw)
    8126. 

  8126.       maximum = (is_raw == 2 && shot_select) ? 0x2f00 : 0x3e00;
    8127. 

  8127.     top_margin = (raw_height - height) >> 2 << 1;
    8128. 

  8128.     left_margin = (raw_width - width ) >> 2 << 1;
    8129. 

  8129.     if (width == 2848) filters = 0x16161616;
    8130. 

  8130.     if (width == 3328) {
    8131. 

  8131.       width = 3262;
    8132. 

  8132.       left_margin = 34;
    8133. 

  8133.     }
    8134. 

  8134.     if (width == 4952) {
    8135. 

  8135.       left_margin = 0;
    8136. 

  8136.       filters = 2;
    8137. 

  8137.     }
    8138. 

  8138. 	if(!strcmp(model,"HS50EXR"))
    8139. 

  8139. 	{
    8140. 

  8140. 		filters = 0x1e1e1e1e;
    8141. 

  8141. 		width=3230;
    8142. 

  8142. 	}
    8143. 

  8143. 	if(!strcmp(model,"X20"))
    8144. 

  8144. 	{
    8145. 

  8145. 		left_margin = 2;
    8146. 

  8146. 		top_margin=2;
    8147. 

  8147. 		width = 4030;
    8148. 

  8148. 		height = 3010;
    8149. 

  8149. 		raw_height = 3012;
    8150. 

  8150. 		filters = 2;
    8151. 

  8151. 	}
    8152. 

  8152. 	if(!strcmp(model,"X100S"))
    8153. 

  8153. 	{
    8154. 

  8154. 		left_margin = 2;
    8155. 

  8155. 		top_margin = 1;
    8156. 

  8156. 		width = 4934;
    8157. 

  8157. 		height = 3290;
    8158. 

  8158. 		raw_height = 3295;
    8159. 

  8159. 		filters = 2;
    8160. 

  8160. 		data_offset +=8;
    8161. 

  8161. 		load_raw = &CLASS unpacked_load_raw;
    8162. 

  8162. 		load_flags = 0;
    8163. 

  8163. 		maximum = 16383;
    8164. 

  8164. 	}
    8165. 

  8165.     if (fuji_layout) raw_width *= is_raw;
    8166. 

  8166.   } else if (!strcmp(model,"RD175")) {
    8167. 

  8167.     height = 986;
    8168. 

  8168.     width = 1534;
    8169. 

  8169.     data_offset = 513;
    8170. 

  8170.     filters = 0x61616161;
    8171. 

  8171.     load_raw = &CLASS minolta_rd175_load_raw;
    8172. 

  8172.   } else if (!strcmp(model,"KD-400Z")) {
    8173. 

  8173.     height = 1712;
    8174. 

  8174.     width  = 2312;
    8175. 

  8175.     raw_width = 2336;
    8176. 

  8176.     goto konica_400z;
    8177. 

  8177.   } else if (!strcmp(model,"KD-510Z")) {
    8178. 

  8178.     goto konica_510z;
    8179. 

  8179.   } else if (!strcasecmp(make,"MINOLTA")) {
    8180. 

  8180.     load_raw = &CLASS unpacked_load_raw;
    8181. 

  8181.     maximum = 0xfff;
    8182. 

  8182.     if (!strncmp(model,"DiMAGE A",8)) {
    8183. 

  8183.       if (!strcmp(model,"DiMAGE A200"))
    8184. 

  8184. 	filters = 0x49494949;
    8185. 

  8185.       tiff_bps = 12;
    8186. 

  8186.       load_raw = &CLASS packed_load_raw;
    8187. 

  8187.     } else if (!strncmp(model,"ALPHA",5) ||
    8188. 

  8188. 	       !strncmp(model,"DYNAX",5) ||
    8189. 

  8189. 	       !strncmp(model,"MAXXUM",6)) {
    8190. 

  8190.       sprintf (model+20, "DYNAX %-10s", model+6+(model[0]=='M'));
    8191. 

  8191.       adobe_coeff (make, model+20);
    8192. 

  8192.       load_raw = &CLASS packed_load_raw;
    8193. 

  8193.     } else if (!strncmp(model,"DiMAGE G",8)) {
    8194. 

  8194.       if (model[8] == '4') {
    8195. 

  8195. 	height = 1716;
    8196. 

  8196. 	width  = 2304;
    8197. 

  8197.       } else if (model[8] == '5') {
    8198. 

  8198. konica_510z:
    8199. 

  8199. 	height = 1956;
    8200. 

  8200. 	width  = 2607;
    8201. 

  8201. 	raw_width = 2624;
    8202. 

  8202.       } else if (model[8] == '6') {
    8203. 

  8203. 	height = 2136;
    8204. 

  8204. 	width  = 2848;
    8205. 

  8205.       }
    8206. 

  8206.       data_offset += 14;
    8207. 

  8207.       filters = 0x61616161;
    8208. 

  8208. konica_400z:
    8209. 

  8209.       load_raw = &CLASS unpacked_load_raw;
    8210. 

  8210.       maximum = 0x3df;
    8211. 

  8211.       order = 0x4d4d;
    8212. 

  8212.     }
    8213. 

  8213.   } else if (!strcmp(model,"*ist D")) {
    8214. 

  8214.     load_raw = &CLASS unpacked_load_raw;
    8215. 

  8215.     data_error = -1;
    8216. 

  8216.   } else if (!strcmp(model,"*ist DS")) {
    8217. 

  8217.     height -= 2;
    8218. 

  8218.   } else if (!strcmp(model,"Optio S")) {
    8219. 

  8219.     if (fsize == 3178560) {
    8220. 

  8220.       height = 1540;
    8221. 

  8221.       width  = 2064;
    8222. 

  8222.       load_raw = &CLASS eight_bit_load_raw;
    8223. 

  8223.       cam_mul[0] *= 4;
    8224. 

  8224.       cam_mul[2] *= 4;
    8225. 

  8225.     } else {
    8226. 

  8226.       height = 1544;
    8227. 

  8227.       width  = 2068;
    8228. 

  8228.       raw_width = 3136;
    8229. 

  8229.       load_raw = &CLASS packed_load_raw;
    8230. 

  8230.       maximum = 0xf7c;
    8231. 

  8231.     }
    8232. 

  8232.   } else if (fsize == 6114240) {
    8233. 

  8233.     height = 1737;
    8234. 

  8234.     width  = 2324;
    8235. 

  8235.     raw_width = 3520;
    8236. 

  8236.     load_raw = &CLASS packed_load_raw;
    8237. 

  8237.     maximum = 0xf7a;
    8238. 

  8238.   } else if (!strcmp(model,"Optio 750Z")) {
    8239. 

  8239.     height = 2302;
    8240. 

  8240.     width  = 3072;
    8241. 

  8241.     load_raw = &CLASS packed_load_raw;
    8242. 

  8242.     load_flags = 30;
    8243. 

  8243.   } else if (!strcmp(model,"DC-833m")) {
    8244. 

  8244.     height = 2448;
    8245. 

  8245.     width  = 3264;
    8246. 

  8246.     order = 0x4949;
    8247. 

  8247.     filters = 0x61616161;
    8248. 

  8248.     load_raw = &CLASS unpacked_load_raw;
    8249. 

  8249.     maximum = 0xfc00;
    8250. 

  8250.   } else if (!strncmp(model,"S85",3)) {
    8251. 

  8251.     height = 2448;
    8252. 

  8252.     width  = 3264;
    8253. 

  8253.     raw_width = fsize/height/2;
    8254. 

  8254.     order = 0x4d4d;
    8255. 

  8255.     load_raw = &CLASS unpacked_load_raw;
    8256. 

  8256.   } else if (!strcmp(make,"SAMSUNG") && raw_width == 4704) {
    8257. 

  8257.     height -= top_margin = 8;
    8258. 

  8258.     width -= 2 * (left_margin = 8);
    8259. 

  8259.     load_flags = 32;
    8260. 

  8260.   } else if (!strcmp(make,"SAMSUNG") && raw_width == 5632) {
    8261. 

  8261.     order = 0x4949;
    8262. 

  8262.     height = 3694;
    8263. 

  8263.     top_margin = 2;
    8264. 

  8264.     width  = 5574 - (left_margin = 32 + tiff_bps);
    8265. 

  8265.     if (tiff_bps == 12) load_flags = 80;
    8266. 

  8266.   } else if (!strcmp(make,"SAMSUNG") && !strcmp(model,"NX300")) {
    8267. 

  8267. 	  is_raw =0;
    8268. 

  8268.   } else if (!strcmp(model,"EX1")) {
    8269. 

  8269.     order = 0x4949;
    8270. 

  8270.     height -= 20;
    8271. 

  8271.     top_margin = 2;
    8272. 

  8272.     if ((width -= 6) > 3682) {
    8273. 

  8273.       height -= 10;
    8274. 

  8274.       width  -= 46;
    8275. 

  8275.       top_margin = 8;
    8276. 

  8276.     }
    8277. 

  8277.   } else if (!strcmp(model,"WB2000")) {
    8278. 

  8278.     order = 0x4949;
    8279. 

  8279.     height -= 3;
    8280. 

  8280.     top_margin = 2;
    8281. 

  8281.     if ((width -= 10) > 3718) {
    8282. 

  8282.       height -= 28;
    8283. 

  8283.       width  -= 56;
    8284. 

  8284.       top_margin = 8;
    8285. 

  8285.     }
    8286. 

  8286.   } else if (fsize == 20487168) {
    8287. 

  8287.     height = 2808;
    8288. 

  8288.     width  = 3648;
    8289. 

  8289.     goto wb550;
    8290. 

  8290.   } else if (fsize == 24000000) {
    8291. 

  8291.     height = 3000;
    8292. 

  8292.     width  = 4000;
    8293. 

  8293. wb550:
    8294. 

  8294.     strcpy (model, "WB550");
    8295. 

  8295.     order = 0x4d4d;
    8296. 

  8296.     load_raw = &CLASS unpacked_load_raw;
    8297. 

  8297.     load_flags = 6;
    8298. 

  8298.     maximum = 0x3df;
    8299. 

  8299.   } else if (!strcmp(model,"EX2F")) {
    8300. 

  8300.     height = 3045;
    8301. 

  8301.     width  = 4070;
    8302. 

  8302.     top_margin = 3;
    8303. 

  8303.     order = 0x4949;
    8304. 

  8304.     filters = 0x49494949;
    8305. 

  8305.     load_raw = &CLASS unpacked_load_raw;
    8306. 

  8306.   } else if (!strcmp(model,"STV680 VGA")) {
    8307. 

  8307.     height = 484;
    8308. 

  8308.     width  = 644;
    8309. 

  8309.     load_raw = &CLASS eight_bit_load_raw;
    8310. 

  8310.     flip = 2;
    8311. 

  8311.     filters = 0x16161616;
    8312. 

  8312.     black = 16;
    8313. 

  8313.   }  else
    8314. 

  8314.       identify2(fsize,flen,head); /* Avoid MS VS 2008/2010 bug */
    8315. 

  8315. 

  8316.   if (!model[0])
    8317. 

  8317.     sprintf (model, "%dx%d", width, height);
    8318. 

  8318.   if (filters == UINT_MAX) filters = 0x94949494;
    8319. 

  8319.   if (raw_color) adobe_coeff (make, model);
    8320. 

  8320.   if (load_raw == &CLASS kodak_radc_load_raw)
    8321. 

  8321.     if (raw_color) adobe_coeff ("Apple","Quicktake");
    8322. 

  8322.   if (thumb_offset && !thumb_height) {
    8323. 

  8323.     fseek (ifp, thumb_offset, SEEK_SET);
    8324. 

  8324.     if (ljpeg_start (&jh, 1)) {
    8325. 

  8325.       thumb_width  = jh.wide;
    8326. 

  8326.       thumb_height = jh.high;
    8327. 

  8327.     }
    8328. 

  8328.   }
    8329. 

  8329. dng_skip:
    8330. 

  8330.   if (fuji_width) {
    8331. 

  8331.     fuji_width = width >> !fuji_layout;
    8332. 

  8332.     if (~fuji_width & 1) filters = 0x49494949;
    8333. 

  8333.     width = (height >> fuji_layout) + fuji_width;
    8334. 

  8334.     height = width - 1;
    8335. 

  8335.     pixel_aspect = 1;
    8336. 

  8336.   } else {
    8337. 

  8337.     if (raw_height < height) raw_height = height;
    8338. 

  8338.     if (raw_width  < width ) raw_width  = width;
    8339. 

  8339.   }
    8340. 

  8340.   if (!tiff_bps) tiff_bps = 12;
    8341. 

  8341.   if (!maximum) maximum = (1 << tiff_bps) - 1;
    8342. 

  8342.   if (!load_raw || height < 22) is_raw = 0;
    8343. 

  8343. #ifdef NO_JASPER
    8344. 

  8344.   if (load_raw == &CLASS redcine_load_raw) {
    8345. 

  8345. #ifdef DCRAW_VERBOSE
    8346. 

  8346.     fprintf (stderr,_("%s: You must link dcraw with %s!!\n"),
    8347. 

  8347. 	ifname, "libjasper");
    8348. 

  8348. #endif
    8349. 

  8349.     is_raw = 0;
    8350. 

  8350. #ifdef LIBRAW_LIBRARY_BUILD
    8351. 

  8351.     imgdata.process_warnings |= LIBRAW_WARN_NO_JASPER;
    8352. 

  8352. #endif
    8353. 

  8353.   }
    8354. 

  8354. #endif
    8355. 

  8355. #ifdef NO_JPEG
    8356. 

  8356.   if (load_raw == &CLASS kodak_jpeg_load_raw ||
    8357. 

  8357.       load_raw == &CLASS lossy_dng_load_raw) {
    8358. 

  8358. #ifdef DCRAW_VERBOSE
    8359. 

  8359.     fprintf (stderr,_("%s: You must link dcraw with %s!!\n"),
    8360. 

  8360. 	ifname, "libjpeg");
    8361. 

  8361. #endif
    8362. 

  8362.     is_raw = 0;
    8363. 

  8363. #ifdef LIBRAW_LIBRARY_BUILD
    8364. 

  8364.     imgdata.process_warnings |= LIBRAW_WARN_NO_JPEGLIB;
    8365. 

  8365. #endif
    8366. 

  8366.   }
    8367. 

  8367. #endif
    8368. 

  8368.   if (!cdesc[0])
    8369. 

  8369.     strcpy (cdesc, colors == 3 ? "RGBG":"GMCY");
    8370. 

  8370.   if (!raw_height) raw_height = height;
    8371. 

  8371.   if (!raw_width ) raw_width  = width;
    8372. 

  8372.   if (filters && colors == 3)
    8373. 

  8373.     filters |= ((filters >> 2 & 0x22222222) |
    8374. 

  8374. 		(filters << 2 & 0x88888888)) & filters << 1;
    8375. 

  8375. notraw:
    8376. 

  8376.   if (flip == -1) flip = tiff_flip;
    8377. 

  8377.   if (flip == -1) flip = 0;
    8378. 

  8378. #ifdef LIBRAW_LIBRARY_BUILD
    8379. 

  8379.   RUN_CALLBACK(LIBRAW_PROGRESS_IDENTIFY,1,2);
    8380. 

  8380. #endif
    8381. 

  8381. }
    8382. 

  8382. 

  8383. void CLASS identify2(unsigned fsize, unsigned flen, char *head)
    8384. 

  8384. {
    8385. 

  8385.   short pana[][6] = {
    8386. 

  8386.     { 3130, 1743,  4,  0, -6,  0 },
    8387. 

  8387.     { 3130, 2055,  4,  0, -6,  0 },
    8388. 

  8388.     { 3130, 2319,  4,  0, -6,  0 },
    8389. 

  8389.     { 3170, 2103, 18,  0,-42, 20 },
    8390. 

  8390.     { 3170, 2367, 18, 13,-42,-21 },
    8391. 

  8391.     { 3177, 2367,  0,  0, -1,  0 },
    8392. 

  8392.     { 3304, 2458,  0,  0, -1,  0 },
    8393. 

  8393.     { 3330, 2463,  9,  0, -5,  0 },
    8394. 

  8394.     { 3330, 2479,  9,  0,-17,  4 },
    8395. 

  8395.     { 3370, 1899, 15,  0,-44, 20 },
    8396. 

  8396.     { 3370, 2235, 15,  0,-44, 20 },
    8397. 

  8397.     { 3370, 2511, 15, 10,-44,-21 },
    8398. 

  8398.     { 3690, 2751,  3,  0, -8, -3 },
    8399. 

  8399.     { 3710, 2751,  0,  0, -3,  0 },
    8400. 

  8400.     { 3724, 2450,  0,  0,  0, -2 },
    8401. 

  8401.     { 3770, 2487, 17,  0,-44, 19 },
    8402. 

  8402.     { 3770, 2799, 17, 15,-44,-19 },
    8403. 

  8403.     { 3880, 2170,  6,  0, -6,  0 },
    8404. 

  8404.     { 4060, 3018,  0,  0,  0, -2 },
    8405. 

  8405.     { 4290, 2391,  3,  0, -8, -1 },
    8406. 

  8406.     { 4330, 2439, 17, 15,-44,-19 },
    8407. 

  8407.     { 4508, 2962,  0,  0, -3, -4 },
    8408. 

  8408.     { 4508, 3330,  0,  0, -3, -6 } };
    8409. 

  8409. 

  8410. 

  8411.   struct jhead jh;
    8412. 

  8412.   int i;
    8413. 

  8413.  if (!strcmp(model,"N95")) {
    8414. 

  8414.     height = raw_height - (top_margin = 2);
    8415. 

  8415.   } else if (!strcmp(model,"531C")) {
    8416. 

  8416.     height = 1200;
    8417. 

  8417.     width  = 1600;
    8418. 

  8418.     load_raw = &CLASS unpacked_load_raw;
    8419. 

  8419.     filters = 0x49494949;
    8420. 

  8420.   } else if (!strcmp(model,"640x480")) {
    8421. 

  8421.     height = 480;
    8422. 

  8422.     width  = 640;
    8423. 

  8423.     load_raw = &CLASS eight_bit_load_raw;
    8424. 

  8424.     gamma_curve (0.45, 4.5, 1, 255);
    8425. 

  8425.   } else if (!strcmp(model,"F-080C")) {
    8426. 

  8426.     height = 768;
    8427. 

  8427.     width  = 1024;
    8428. 

  8428.     load_raw = &CLASS eight_bit_load_raw;
    8429. 

  8429.   } else if (!strcmp(model,"F-145C")) {
    8430. 

  8430.     height = 1040;
    8431. 

  8431.     width  = 1392;
    8432. 

  8432.     load_raw = &CLASS eight_bit_load_raw;
    8433. 

  8433.   } else if (!strcmp(model,"F-201C")) {
    8434. 

  8434.     height = 1200;
    8435. 

  8435.     width  = 1600;
    8436. 

  8436.     load_raw = &CLASS eight_bit_load_raw;
    8437. 

  8437.   } else if (!strcmp(model,"F-510C")) {
    8438. 

  8438.     height = 1958;
    8439. 

  8439.     width  = 2588;
    8440. 

  8440.     load_raw = fsize < 7500000 ?
    8441. 

  8441. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8442. 

  8442.     data_offset = fsize - width*height*(fsize >> 22);
    8443. 

  8443.     maximum = 0xfff0;
    8444. 

  8444.   } else if (!strcmp(model,"F-810C")) {
    8445. 

  8445.     height = 2469;
    8446. 

  8446.     width  = 3272;
    8447. 

  8447.     load_raw = &CLASS unpacked_load_raw;
    8448. 

  8448.     maximum = 0xfff0;
    8449. 

  8449.   } else if (!strcmp(model,"XCD-SX910CR")) {
    8450. 

  8450.     height = 1024;
    8451. 

  8451.     width  = 1375;
    8452. 

  8452.     raw_width = 1376;
    8453. 

  8453.     filters = 0x49494949;
    8454. 

  8454.     maximum = 0x3ff;
    8455. 

  8455.     load_raw = fsize < 2000000 ?
    8456. 

  8456. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8457. 

  8457.   } else if (!strcmp(model,"2010")) {
    8458. 

  8458.     height = 1207;
    8459. 

  8459.     width  = 1608;
    8460. 

  8460.     order = 0x4949;
    8461. 

  8461.     filters = 0x16161616;
    8462. 

  8462.     data_offset = 3212;
    8463. 

  8463.     maximum = 0x3ff;
    8464. 

  8464.     load_raw = &CLASS unpacked_load_raw;
    8465. 

  8465.   } else if (!strcmp(model,"A782")) {
    8466. 

  8466.     height = 3000;
    8467. 

  8467.     width  = 2208;
    8468. 

  8468.     filters = 0x61616161;
    8469. 

  8469.     load_raw = fsize < 10000000 ?
    8470. 

  8470. 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
    8471. 

  8471.     maximum = 0xffc0;
    8472. 

  8472.   } else if (!strcmp(model,"3320AF")) {
    8473. 

  8473.     height = 1536;
    8474. 

  8474.     raw_width = width = 2048;
    8475. 

  8475.     filters = 0x61616161;
    8476. 

  8476.     load_raw = &CLASS unpacked_load_raw;
    8477. 

  8477.     maximum = 0x3ff;
    8478. 

  8478.     fseek (ifp, 0x300000, SEEK_SET);
    8479. 

  8479.     if ((order = guess_byte_order(0x10000)) == 0x4d4d) {
    8480. 

  8480.       height -= (top_margin = 16);
    8481. 

  8481.       width -= (left_margin = 28);
    8482. 

  8482.       maximum = 0xf5c0;
    8483. 

  8483.       strcpy (make, "ISG");
    8484. 

  8484.       model[0] = 0;
    8485. 

  8485.     }
    8486. 

  8486.   } else if (!strcmp(make,"Hasselblad")) {
    8487. 

  8487.     if (load_raw == &CLASS lossless_jpeg_load_raw)
    8488. 

  8488.       load_raw = &CLASS hasselblad_load_raw;
    8489. 

  8489.     if (raw_width == 7262) {
    8490. 

  8490.       height = 5444;
    8491. 

  8491.       width  = 7248;
    8492. 

  8492.       top_margin  = 4;
    8493. 

  8493.       left_margin = 7;
    8494. 

  8494.       filters = 0x61616161;
    8495. 

  8495.     } else if (raw_width == 7410) {
    8496. 

  8496.       height = 5502;
    8497. 

  8497.       width  = 7328;
    8498. 

  8498.       top_margin  = 4;
    8499. 

  8499.       left_margin = 41;
    8500. 

  8500.       filters = 0x61616161;
    8501. 

  8501.     } else if (raw_width == 9044) {
    8502. 

  8502.       height = 6716;
    8503. 

  8503.       width  = 8964;
    8504. 

  8504.       top_margin  = 8;
    8505. 

  8505.       left_margin = 40;
    8506. 

  8506.       black += load_flags = 256;
    8507. 

  8507.       maximum = 0x8101;
    8508. 

  8508.     } else if (raw_width == 4090) {
    8509. 

  8509.       strcpy (model, "V96C");
    8510. 

  8510.       height -= (top_margin = 6);
    8511. 

  8511.       width -= (left_margin = 3) + 7;
    8512. 

  8512.       filters = 0x61616161;
    8513. 

  8513.     }
    8514. 

  8514.   } else if (!strcmp(make,"Sinar")) {
    8515. 

  8515.     if (!memcmp(head,"8BPS",4)) {
    8516. 

  8516.       fseek (ifp, 14, SEEK_SET);
    8517. 

  8517.       height = get4();
    8518. 

  8518.       width  = get4();
    8519. 

  8519.       filters = 0x61616161;
    8520. 

  8520.       data_offset = 68;
    8521. 

  8521.     }
    8522. 

  8522.     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
    8523. 

  8523.     maximum = 0x3fff;
    8524. 

  8524.   } else if (!strcmp(make,"Leaf")) {
    8525. 

  8525.     maximum = 0x3fff;
    8526. 

  8526.     fseek (ifp, data_offset, SEEK_SET);
    8527. 

  8527.     if (ljpeg_start (&jh, 1) && jh.bits == 15)
    8528. 

  8528.       maximum = 0x1fff;
    8529. 

  8529.     if (tiff_samples > 1) filters = 0;
    8530. 

  8530.     if (tiff_samples > 1 || tile_length < raw_height) {
    8531. 

  8531.       load_raw = &CLASS leaf_hdr_load_raw;
    8532. 

  8532.       raw_width = tile_width;
    8533. 

  8533.     }
    8534. 

  8534.     if ((width | height) == 2048) {
    8535. 

  8535.       if (tiff_samples == 1) {
    8536. 

  8536. 	filters = 1;
    8537. 

  8537. 	strcpy (cdesc, "RBTG");
    8538. 

  8538. 	strcpy (model, "CatchLight");
    8539. 

  8539. 	top_margin =  8; left_margin = 18; height = 2032; width = 2016;
    8540. 

  8540.       } else {
    8541. 

  8541. 	strcpy (model, "DCB2");
    8542. 

  8542. 	top_margin = 10; left_margin = 16; height = 2028; width = 2022;
    8543. 

  8543.       }
    8544. 

  8544.     } else if (width+height == 3144+2060) {
    8545. 

  8545.       if (!model[0]) strcpy (model, "Cantare");
    8546. 

  8546.       if (width > height) {
    8547. 

  8547. 	 top_margin = 6; left_margin = 32; height = 2048;  width = 3072;
    8548. 

  8548. 	filters = 0x61616161;
    8549. 

  8549.       } else {
    8550. 

  8550. 	left_margin = 6;  top_margin = 32;  width = 2048; height = 3072;
    8551. 

  8551. 	filters = 0x16161616;
    8552. 

  8552.       }
    8553. 

  8553.       if (!cam_mul[0] || model[0] == 'V') filters = 0;
    8554. 

  8554.       else is_raw = tiff_samples;
    8555. 

  8555.     } else if (width == 2116) {
    8556. 

  8556.       strcpy (model, "Valeo 6");
    8557. 

  8557.       height -= 2 * (top_margin = 30);
    8558. 

  8558.       width -= 2 * (left_margin = 55);
    8559. 

  8559.       filters = 0x49494949;
    8560. 

  8560.     } else if (width == 3171) {
    8561. 

  8561.       strcpy (model, "Valeo 6");
    8562. 

  8562.       height -= 2 * (top_margin = 24);
    8563. 

  8563.       width -= 2 * (left_margin = 24);
    8564. 

  8564.       filters = 0x16161616;
    8565. 

  8565.     }
    8566. 

  8566.   } else if (!strcmp(make,"LEICA") || !strcmp(make,"Panasonic")) {
    8567. 

  8567.     if ((flen - data_offset) / (raw_width*8/7) == raw_height)
    8568. 

  8568.       load_raw = &CLASS panasonic_load_raw;
    8569. 

  8569.     if (!load_raw) {
    8570. 

  8570.       load_raw = &CLASS unpacked_load_raw;
    8571. 

  8571.       load_flags = 4;
    8572. 

  8572.     }
    8573. 

  8573.     zero_is_bad = 1;
    8574. 

  8574.     if ((height += 12) > raw_height) height = raw_height;
    8575. 

  8575.     for (i=0; i < sizeof pana / sizeof *pana; i++)
    8576. 

  8576.       if (raw_width == pana[i][0] && raw_height == pana[i][1]) {
    8577. 

  8577. 	left_margin = pana[i][2];
    8578. 

  8578. 	 top_margin = pana[i][3];
    8579. 

  8579. 	     width += pana[i][4];
    8580. 

  8580. 	    height += pana[i][5];
    8581. 

  8581.       }
    8582. 

  8582.     filters = 0x01010101 * (uchar) "\x94\x61\x49\x16"
    8583. 

  8583. 	[((filters-1) ^ (left_margin & 1) ^ (top_margin << 1)) & 3];
    8584. 

  8584.   } else if (!strcmp(model,"C770UZ")) {
    8585. 

  8585.     height = 1718;
    8586. 

  8586.     width  = 2304;
    8587. 

  8587.     filters = 0x16161616;
    8588. 

  8588.     load_raw = &CLASS packed_load_raw;
    8589. 

  8589.     load_flags = 30;
    8590. 

  8590.   } else if (!strcmp(make,"OLYMPUS")) {
    8591. 

  8591.     height += height & 1;
    8592. 

  8592.     filters = exif_cfa;
    8593. 

  8593.     if (width == 4100) width -= 4;
    8594. 

  8594.     if (width == 4080) width -= 24;
    8595. 

  8595.     if (load_raw == &CLASS unpacked_load_raw)
    8596. 

  8596.       load_flags = 4;
    8597. 

  8597.     tiff_bps = 12;
    8598. 

  8598.     if (!strcmp(model,"E-300") ||
    8599. 

  8599. 	!strcmp(model,"E-500")) {
    8600. 

  8600.       width -= 20;
    8601. 

  8601.       if (load_raw == &CLASS unpacked_load_raw) {
    8602. 

  8602. 	maximum = 0xfc3;
    8603. 

  8603. 	memset (cblack, 0, sizeof cblack);
    8604. 

  8604.       }
    8605. 

  8605.     } else if (!strcmp(model,"E-330")) {
    8606. 

  8606.       width -= 30;
    8607. 

  8607.       if (load_raw == &CLASS unpacked_load_raw)
    8608. 

  8608. 	maximum = 0xf79;
    8609. 

  8609.     } else if (!strcmp(model,"SP550UZ")) {
    8610. 

  8610.       thumb_length = flen - (thumb_offset = 0xa39800);
    8611. 

  8611.       thumb_height = 480;
    8612. 

  8612.       thumb_width  = 640;
    8613. 

  8613.     } else if (!strcmp(model,"XZ-2")) {
    8614. 

  8614.       load_raw = &CLASS packed_load_raw;
    8615. 

  8615.       load_flags = 24;
    8616. 

  8616.     } else if (!strcmp(model,"XZ-10")) {
    8617. 

  8617.       load_raw = &CLASS packed_load_raw;
    8618. 

  8618.       load_flags = 24;
    8619. 

  8619.     }
    8620. 

  8620.   } else if (!strcmp(model,"N Digital")) {
    8621. 

  8621.     height = 2047;
    8622. 

  8622.     width  = 3072;
    8623. 

  8623.     filters = 0x61616161;
    8624. 

  8624.     data_offset = 0x1a00;
    8625. 

  8625.     load_raw = &CLASS packed_load_raw;
    8626. 

  8626.   } else if (!strcmp(model,"DSC-F828")) {
    8627. 

  8627.     width = 3288;
    8628. 

  8628.     left_margin = 5;
    8629. 

  8629.     mask[1][3] = -17;
    8630. 

  8630.     data_offset = 862144;
    8631. 

  8631.     load_raw = &CLASS sony_load_raw;
    8632. 

  8632.     filters = 0x9c9c9c9c;
    8633. 

  8633.     colors = 4;
    8634. 

  8634.     strcpy (cdesc, "RGBE");
    8635. 

  8635.   } else if (!strcmp(model,"DSC-V3")) {
    8636. 

  8636.     width = 3109;
    8637. 

  8637.     left_margin = 59;
    8638. 

  8638.     mask[0][1] = 9;
    8639. 

  8639.     data_offset = 787392;
    8640. 

  8640.     load_raw = &CLASS sony_load_raw;
    8641. 

  8641.   } else if (!strcmp(make,"SONY") && raw_width == 3984) {
    8642. 

  8642.     adobe_coeff ("SONY","DSC-R1");
    8643. 

  8643.     width = 3925;
    8644. 

  8644.     order = 0x4d4d;
    8645. 

  8645.   } else if (!strcmp(make,"SONY") && raw_width == 5504) {
    8646. 

  8646.     width -= 8;
    8647. 

  8647.   } else if (!strcmp(make,"SONY") && raw_width == 6048) {
    8648. 

  8648.     width -= 24;
    8649. 

  8649.   } else if (!strcmp(model,"DSLR-A100")) {
    8650. 

  8650.     if (width == 3880) {
    8651. 

  8651.       height--;
    8652. 

  8652.       width = ++raw_width;
    8653. 

  8653.     } else {
    8654. 

  8654.       order = 0x4d4d;
    8655. 

  8655.       load_flags = 2;
    8656. 

  8656.     }
    8657. 

  8657.     filters = 0x61616161;
    8658. 

  8658.   } else if (!strcmp(model,"DSLR-A350")) {
    8659. 

  8659.     height -= 4;
    8660. 

  8660.   } else if (!strcmp(model,"PIXL")) {
    8661. 

  8661.     height -= top_margin = 4;
    8662. 

  8662.     width -= left_margin = 32;
    8663. 

  8663.     gamma_curve (0, 7, 1, 255);
    8664. 

  8664.   } else if (!strcmp(model,"C603v")) {
    8665. 

  8665.     height = 480;
    8666. 

  8666.     width  = 640;
    8667. 

  8667.     if (fsize < 614400 || find_green (16, 16, 3840, 5120) < 25) goto c603v;
    8668. 

  8668.     strcpy (model,"KAI-0340");
    8669. 

  8669.     height -= 3;
    8670. 

  8670.     data_offset = 3840;
    8671. 

  8671.     order = 0x4949;
    8672. 

  8672.     load_raw = &CLASS unpacked_load_raw;
    8673. 

  8673.   } else if (!strcmp(model,"C603y")) {
    8674. 

  8674.     height = 2134;
    8675. 

  8675.     width  = 2848;
    8676. 

  8676. c603v:
    8677. 

  8677.     filters = 0;
    8678. 

  8678.     load_raw = &CLASS kodak_yrgb_load_raw;
    8679. 

  8679.     gamma_curve (0, 3.875, 1, 255);
    8680. 

  8680.   } else if (!strcmp(model,"C603")) {
    8681. 

  8681.     raw_height = height = 2152;
    8682. 

  8682.     raw_width  = width  = 2864;
    8683. 

  8683.     goto c603;
    8684. 

  8684.   } else if (!strcmp(model,"C330")) {
    8685. 

  8685.     height = 1744;
    8686. 

  8686.     width  = 2336;
    8687. 

  8687.     raw_height = 1779;
    8688. 

  8688.     raw_width  = 2338;
    8689. 

  8689.     top_margin = 33;
    8690. 

  8690.     left_margin = 1;
    8691. 

  8691. c603:
    8692. 

  8692.     order = 0x4949;
    8693. 

  8693.     if ((data_offset = fsize - raw_height*raw_width)) {
    8694. 

  8694.       fseek (ifp, 168, SEEK_SET);
    8695. 

  8695.       read_shorts (curve, 256);
    8696. 

  8696.     } else gamma_curve (0, 3.875, 1, 255);
    8697. 

  8697.     load_raw = &CLASS eight_bit_load_raw;
    8698. 

  8698.   } else if (!strncasecmp(model,"EasyShare",9)) {
    8699. 

  8699.     data_offset = data_offset < 0x15000 ? 0x15000 : 0x17000;
    8700. 

  8700.     load_raw = &CLASS packed_load_raw;
    8701. 

  8701.   } else if (!strcasecmp(make,"KODAK")) {
    8702. 

  8702.     if (filters == UINT_MAX) filters = 0x61616161;
    8703. 

  8703.     if (!strncmp(model,"NC2000",6)) {
    8704. 

  8704.       width -= 4;
    8705. 

  8705.       left_margin = 2;
    8706. 

  8706.     } else if (!strcmp(model,"EOSDCS3B")) {
    8707. 

  8707.       width -= 4;
    8708. 

  8708.       left_margin = 2;
    8709. 

  8709.     } else if (!strcmp(model,"EOSDCS1")) {
    8710. 

  8710.       width -= 4;
    8711. 

  8711.       left_margin = 2;
    8712. 

  8712.     } else if (!strcmp(model,"DCS420")) {
    8713. 

  8713.       width -= 4;
    8714. 

  8714.       left_margin = 2;
    8715. 

  8715.     } else if (!strncmp(model,"DCS460 ",7)) {
    8716. 

  8716.       model[6] = 0;
    8717. 

  8717.       width -= 4;
    8718. 

  8718.       left_margin = 2;
    8719. 

  8719.     } else if (!strcmp(model,"DCS460A")) {
    8720. 

  8720.       width -= 4;
    8721. 

  8721.       left_margin = 2;
    8722. 

  8722.       colors = 1;
    8723. 

  8723.       filters = 0;
    8724. 

  8724.     } else if (!strcmp(model,"DCS660M")) {
    8725. 

  8725.       black = 214;
    8726. 

  8726.       colors = 1;
    8727. 

  8727.       filters = 0;
    8728. 

  8728.     } else if (!strcmp(model,"DCS760M")) {
    8729. 

  8729.       colors = 1;
    8730. 

  8730.       filters = 0;
    8731. 

  8731.     }
    8732. 

  8732.     if (!strcmp(model+4,"20X"))
    8733. 

  8733.       strcpy (cdesc, "MYCY");
    8734. 

  8734.     if (strstr(model,"DC25")) {
    8735. 

  8735.       strcpy (model, "DC25");
    8736. 

  8736.       data_offset = 15424;
    8737. 

  8737.     }
    8738. 

  8738.     if (!strncmp(model,"DC2",3)) {
    8739. 

  8739.       raw_height = height = 242;
    8740. 

  8740.       if (flen < 100000) {
    8741. 

  8741. 	raw_width = 256; width = 249;
    8742. 

  8742. 	pixel_aspect = (4.0*height) / (3.0*width);
    8743. 

  8743.       } else {
    8744. 

  8744. 	raw_width = 512; width = 501;
    8745. 

  8745. 	pixel_aspect = (493.0*height) / (373.0*width);
    8746. 

  8746.       }
    8747. 

  8747.       data_offset += raw_width + 1;
    8748. 

  8748.       colors = 4;
    8749. 

  8749.       filters = 0x8d8d8d8d;
    8750. 

  8750.       simple_coeff(1);
    8751. 

  8751.       pre_mul[1] = 1.179;
    8752. 

  8752.       pre_mul[2] = 1.209;
    8753. 

  8753.       pre_mul[3] = 1.036;
    8754. 

  8754.       load_raw = &CLASS eight_bit_load_raw;
    8755. 

  8755.     } else if (!strcmp(model,"40")) {
    8756. 

  8756.       strcpy (model, "DC40");
    8757. 

  8757.       height = 512;
    8758. 

  8758.       width  = 768;
    8759. 

  8759.       data_offset = 1152;
    8760. 

  8760.       load_raw = &CLASS kodak_radc_load_raw;
    8761. 

  8761.     } else if (strstr(model,"DC50")) {
    8762. 

  8762.       strcpy (model, "DC50");
    8763. 

  8763.       height = 512;
    8764. 

  8764.       width  = 768;
    8765. 

  8765.       data_offset = 19712;
    8766. 

  8766.       load_raw = &CLASS kodak_radc_load_raw;
    8767. 

  8767.     } else if (strstr(model,"DC120")) {
    8768. 

  8768.       strcpy (model, "DC120");
    8769. 

  8769.       height = 976;
    8770. 

  8770.       width  = 848;
    8771. 

  8771.       pixel_aspect = height/0.75/width;
    8772. 

  8772.       load_raw = tiff_compress == 7 ?
    8773. 

  8773. 	&CLASS kodak_jpeg_load_raw : &CLASS kodak_dc120_load_raw;
    8774. 

  8774.     } else if (!strcmp(model,"DCS200")) {
    8775. 

  8775.       thumb_height = 128;
    8776. 

  8776.       thumb_width  = 192;
    8777. 

  8777.       thumb_offset = 6144;
    8778. 

  8778.       thumb_misc   = 360;
    8779. 

  8779.       write_thumb = &CLASS layer_thumb;
    8780. 

  8780.       height = 1024;
    8781. 

  8781.       width  = 1536;
    8782. 

  8782.       data_offset = 79872;
    8783. 

  8783.       load_raw = &CLASS eight_bit_load_raw;
    8784. 

  8784.       black = 17;
    8785. 

  8785.     }
    8786. 

  8786.   } else if (!strcmp(model,"Fotoman Pixtura")) {
    8787. 

  8787.     height = 512;
    8788. 

  8788.     width  = 768;
    8789. 

  8789.     data_offset = 3632;
    8790. 

  8790.     load_raw = &CLASS kodak_radc_load_raw;
    8791. 

  8791.     filters = 0x61616161;
    8792. 

  8792.     simple_coeff(2);
    8793. 

  8793.   } else if (!strncmp(model,"QuickTake",9)) {
    8794. 

  8794.     if (head[5]) strcpy (model+10, "200");
    8795. 

  8795.     fseek (ifp, 544, SEEK_SET);
    8796. 

  8796.     height = get2();
    8797. 

  8797.     width  = get2();
    8798. 

  8798.     data_offset = (get4(),get2()) == 30 ? 738:736;
    8799. 

  8799.     if (height > width) {
    8800. 

  8800.       SWAP(height,width);
    8801. 

  8801.       fseek (ifp, data_offset-6, SEEK_SET);
    8802. 

  8802.       flip = ~get2() & 3 ? 5:6;
    8803. 

  8803.     }
    8804. 

  8804.     filters = 0x61616161;
    8805. 

  8805.   } else if (!strcmp(make,"Rollei") && !load_raw) {
    8806. 

  8806.     switch (raw_width) {
    8807. 

  8807.       case 1316:
    8808. 

  8808. 	height = 1030;
    8809. 

  8809. 	width  = 1300;
    8810. 

  8810. 	top_margin  = 1;
    8811. 

  8811. 	left_margin = 6;
    8812. 

  8812. 	break;
    8813. 

  8813.       case 2568:
    8814. 

  8814. 	height = 1960;
    8815. 

  8815. 	width  = 2560;
    8816. 

  8816. 	top_margin  = 2;
    8817. 

  8817. 	left_margin = 8;
    8818. 

  8818.     }
    8819. 

  8819.     filters = 0x16161616;
    8820. 

  8820.     load_raw = &CLASS rollei_load_raw;
    8821. 

  8821.   } else if (!strcmp(model,"PC-CAM 600")) {
    8822. 

  8822.     height = 768;
    8823. 

  8823.     data_offset = width = 1024;
    8824. 

  8824.     filters = 0x49494949;
    8825. 

  8825.     load_raw = &CLASS eight_bit_load_raw;
    8826. 

  8826.   } else if (!strcmp(model,"QV-2000UX")) {
    8827. 

  8827.     height = 1208;
    8828. 

  8828.     width  = 1632;
    8829. 

  8829.     data_offset = width * 2;
    8830. 

  8830.     load_raw = &CLASS eight_bit_load_raw;
    8831. 

  8831.   } else if (fsize == 3217760) {
    8832. 

  8832.     height = 1546;
    8833. 

  8833.     width  = 2070;
    8834. 

  8834.     raw_width = 2080;
    8835. 

  8835.     load_raw = &CLASS eight_bit_load_raw;
    8836. 

  8836.   } else if (!strcmp(model,"QV-4000")) {
    8837. 

  8837.     height = 1700;
    8838. 

  8838.     width  = 2260;
    8839. 

  8839.     load_raw = &CLASS unpacked_load_raw;
    8840. 

  8840.     maximum = 0xffff;
    8841. 

  8841.   } else if (!strcmp(model,"QV-5700")) {
    8842. 

  8842.     height = 1924;
    8843. 

  8843.     width  = 2576;
    8844. 

  8844.     raw_width = 3232;
    8845. 

  8845.     tiff_bps = 10;
    8846. 

  8846.   } else if (!strcmp(model,"QV-R41")) {
    8847. 

  8847.     height = 1720;
    8848. 

  8848.     width  = 2312;
    8849. 

  8849.     raw_width = 3520;
    8850. 

  8850.     left_margin = 2;
    8851. 

  8851.   } else if (!strcmp(model,"QV-R51")) {
    8852. 

  8852.     height = 1926;
    8853. 

  8853.     width  = 2580;
    8854. 

  8854.     raw_width = 3904;
    8855. 

  8855.   } else if (!strcmp(model,"EX-S20")) {
    8856. 

  8856.     height = 1208;
    8857. 

  8857.     width  = 1620;
    8858. 

  8858.     raw_width = 2432;
    8859. 

  8859.     flip = 3;
    8860. 

  8860.   } else if (!strcmp(model,"EX-S100")) {
    8861. 

  8861.     height = 1544;
    8862. 

  8862.     width  = 2058;
    8863. 

  8863.     raw_width = 3136;
    8864. 

  8864.   } else if (!strcmp(model,"EX-Z50")) {
    8865. 

  8865.     height = 1931;
    8866. 

  8866.     width  = 2570;
    8867. 

  8867.     raw_width = 3904;
    8868. 

  8868.   } else if (!strcmp(model,"EX-Z500")) {
    8869. 

  8869.     height = 1937;
    8870. 

  8870.     width  = 2577;
    8871. 

  8871.     raw_width = 3904;
    8872. 

  8872.     filters = 0x16161616;
    8873. 

  8873.   } else if (!strcmp(model,"EX-Z55")) {
    8874. 

  8874.     height = 1960;
    8875. 

  8875.     width  = 2570;
    8876. 

  8876.     raw_width = 3904;
    8877. 

  8877.   } else if (!strcmp(model,"EX-Z60")) {
    8878. 

  8878.     height = 2145;
    8879. 

  8879.     width  = 2833;
    8880. 

  8880.     raw_width = 3584;
    8881. 

  8881.     filters = 0x16161616;
    8882. 

  8882.     tiff_bps = 10;
    8883. 

  8883.   } else if (!strcmp(model,"EX-Z75")) {
    8884. 

  8884.     height = 2321;
    8885. 

  8885.     width  = 3089;
    8886. 

  8886.     raw_width = 4672;
    8887. 

  8887.     maximum = 0xfff;
    8888. 

  8888.   } else if (!strcmp(model,"EX-Z750")) {
    8889. 

  8889.     height = 2319;
    8890. 

  8890.     width  = 3087;
    8891. 

  8891.     raw_width = 4672;
    8892. 

  8892.     maximum = 0xfff;
    8893. 

  8893.   } else if (!strcmp(model,"EX-Z850")) {
    8894. 

  8894.     height = 2468;
    8895. 

  8895.     width  = 3279;
    8896. 

  8896.     raw_width = 4928;
    8897. 

  8897.     maximum = 0xfff;
    8898. 

  8898.   } else if (!strcmp(model,"EX-Z8")) {
    8899. 

  8899.     height = 2467;
    8900. 

  8900.     width  = 3281;
    8901. 

  8901.     raw_height = 2502;
    8902. 

  8902.     raw_width  = 4992;
    8903. 

  8903.     maximum = 0xfff;
    8904. 

  8904.   } else if (fsize == 15499264) {	/* EX-Z1050 or EX-Z1080 */
    8905. 

  8905.     height = 2752;
    8906. 

  8906.     width  = 3672;
    8907. 

  8907.     raw_width = 5632;
    8908. 

  8908.   } else if (!strcmp(model,"EX-ZR100")) {
    8909. 

  8909.     height = 3044;
    8910. 

  8910.     width  = 4072;
    8911. 

  8911.     raw_width = 4096;
    8912. 

  8912.     load_flags = 80;
    8913. 

  8913.   } else if (!strcmp(model,"EX-P505")) {
    8914. 

  8914.     height = 1928;
    8915. 

  8915.     width  = 2568;
    8916. 

  8916.     raw_width = 3852;
    8917. 

  8917.     maximum = 0xfff;
    8918. 

  8918.   } else if (fsize == 9313536) {	/* EX-P600 or QV-R61 */
    8919. 

  8919.     height = 2142;
    8920. 

  8920.     width  = 2844;
    8921. 

  8921.     raw_width = 4288;
    8922. 

  8922.   } else if (!strcmp(model,"EX-P700")) {
    8923. 

  8923.     height = 2318;
    8924. 

  8924.     width  = 3082;
    8925. 

  8925.     raw_width = 4672;
    8926. 

  8926.   }
    8927. 

  8927.   else if (!strcmp(model,"GRAS-50S5C")) {
    8928. 

  8928.    height = 2048;
    8929. 

  8929.    width = 2440;
    8930. 

  8930.    load_raw = &CLASS unpacked_load_raw;
    8931. 

  8931.    data_offset = 0;
    8932. 

  8932.    filters = 0x49494949;
    8933. 

  8933.    order = 0x4949;
    8934. 

  8934.    maximum = 0xfffC;
    8935. 

  8935.   } else if (!strcmp(model,"BB-500CL")) {
    8936. 

  8936.    height = 2058;
    8937. 

  8937.    width = 2448;
    8938. 

  8938.    load_raw = &CLASS unpacked_load_raw;
    8939. 

  8939.    data_offset = 0;
    8940. 

  8940.    filters = 0x94949494;
    8941. 

  8941.    order = 0x4949;
    8942. 

  8942.    maximum = 0x3fff;
    8943. 

  8943.   } else if (!strcmp(model,"BB-500GE")) {
    8944. 

  8944.    height = 2058;
    8945. 

  8945.    width = 2456;
    8946. 

  8946.    load_raw = &CLASS unpacked_load_raw;
    8947. 

  8947.    data_offset = 0;
    8948. 

  8948.    filters = 0x94949494;
    8949. 

  8949.    order = 0x4949;
    8950. 

  8950.    maximum = 0x3fff;
    8951. 

  8951.   } else if (!strcmp(model,"SVS625CL")) {
    8952. 

  8952.    height = 2050;
    8953. 

  8953.    width = 2448;
    8954. 

  8954.    load_raw = &CLASS unpacked_load_raw;
    8955. 

  8955.    data_offset = 0;
    8956. 

  8956.    filters = 0x94949494;
    8957. 

  8957.    order = 0x4949;
    8958. 

  8958.    maximum = 0x0fff;
    8959. 

  8959.   }
    8960. 

  8960. }
    8961. 

  8961. 

  8962. 

  8963. void CLASS convert_to_rgb()
    8964. 

  8964. {
    8965. 

  8965. #ifndef LIBRAW_LIBRARY_BUILD
    8966. 

  8966.   int row, col, c;
    8967. 

  8967. #endif
    8968. 

  8968.   int  i, j, k;
    8969. 

  8969. #ifndef LIBRAW_LIBRARY_BUILD
    8970. 

  8970.   ushort *img;
    8971. 

  8971.   float out[3];
    8972. 

  8972. #endif
    8973. 

  8973.   float out_cam[3][4];
    8974. 

  8974.   double num, inverse[3][3];
    8975. 

  8975.   static const double xyzd50_srgb[3][3] =
    8976. 

  8976.   { { 0.436083, 0.385083, 0.143055 },
    8977. 

  8977.     { 0.222507, 0.716888, 0.060608 },
    8978. 

  8978.     { 0.013930, 0.097097, 0.714022 } };
    8979. 

  8979.   static const double rgb_rgb[3][3] =
    8980. 

  8980.   { { 1,0,0 }, { 0,1,0 }, { 0,0,1 } };
    8981. 

  8981.   static const double adobe_rgb[3][3] =
    8982. 

  8982.   { { 0.715146, 0.284856, 0.000000 },
    8983. 

  8983.     { 0.000000, 1.000000, 0.000000 },
    8984. 

  8984.     { 0.000000, 0.041166, 0.958839 } };
    8985. 

  8985.   static const double wide_rgb[3][3] =
    8986. 

  8986.   { { 0.593087, 0.404710, 0.002206 },
    8987. 

  8987.     { 0.095413, 0.843149, 0.061439 },
    8988. 

  8988.     { 0.011621, 0.069091, 0.919288 } };
    8989. 

  8989.   static const double prophoto_rgb[3][3] =
    8990. 

  8990.   { { 0.529317, 0.330092, 0.140588 },
    8991. 

  8991.     { 0.098368, 0.873465, 0.028169 },
    8992. 

  8992.     { 0.016879, 0.117663, 0.865457 } };
    8993. 

  8993.   static const double (*out_rgb[])[3] =
    8994. 

  8994.   { rgb_rgb, adobe_rgb, wide_rgb, prophoto_rgb, xyz_rgb };
    8995. 

  8995.   static const char *name[] =
    8996. 

  8996.   { "sRGB", "Adobe RGB (1998)", "WideGamut D65", "ProPhoto D65", "XYZ" };
    8997. 

  8997.   static const unsigned phead[] =
    8998. 

  8998.   { 1024, 0, 0x2100000, 0x6d6e7472, 0x52474220, 0x58595a20, 0, 0, 0,
    8999. 

  8999.     0x61637370, 0, 0, 0x6e6f6e65, 0, 0, 0, 0, 0xf6d6, 0x10000, 0xd32d };
    9000. 

  9000.   unsigned pbody[] =
    9001. 

  9001.   { 10, 0x63707274, 0, 36,	/* cprt */
    9002. 

  9002. 	0x64657363, 0, 40,	/* desc */
    9003. 

  9003. 	0x77747074, 0, 20,	/* wtpt */
    9004. 

  9004. 	0x626b7074, 0, 20,	/* bkpt */
    9005. 

  9005. 	0x72545243, 0, 14,	/* rTRC */
    9006. 

  9006. 	0x67545243, 0, 14,	/* gTRC */
    9007. 

  9007. 	0x62545243, 0, 14,	/* bTRC */
    9008. 

  9008. 	0x7258595a, 0, 20,	/* rXYZ */
    9009. 

  9009. 	0x6758595a, 0, 20,	/* gXYZ */
    9010. 

  9010. 	0x6258595a, 0, 20 };	/* bXYZ */
    9011. 

  9011.   static const unsigned pwhite[] = { 0xf351, 0x10000, 0x116cc };
    9012. 

  9012.   unsigned pcurve[] = { 0x63757276, 0, 1, 0x1000000 };
    9013. 

  9013. 

  9014. #ifdef LIBRAW_LIBRARY_BUILD
    9015. 

  9015.   RUN_CALLBACK(LIBRAW_PROGRESS_CONVERT_RGB,0,2);
    9016. 

  9016. #endif
    9017. 

  9017.   gamma_curve (gamm[0], gamm[1], 0, 0);
    9018. 

  9018.   memcpy (out_cam, rgb_cam, sizeof out_cam);
    9019. 

  9019. #ifndef LIBRAW_LIBRARY_BUILD
    9020. 

  9020.   raw_color |= colors == 1 || document_mode ||
    9021. 

  9021. 		output_color < 1 || output_color > 5;
    9022. 

  9022. #else
    9023. 

  9023.   raw_color |= colors == 1 || 
    9024. 

  9024. 		output_color < 1 || output_color > 5;
    9025. 

  9025. #endif
    9026. 

  9026.   if (!raw_color) {
    9027. 

  9027.     oprof = (unsigned *) calloc (phead[0], 1);
    9028. 

  9028.     merror (oprof, "convert_to_rgb()");
    9029. 

  9029.     memcpy (oprof, phead, sizeof phead);
    9030. 

  9030.     if (output_color == 5) oprof[4] = oprof[5];
    9031. 

  9031.     oprof[0] = 132 + 12*pbody[0];
    9032. 

  9032.     for (i=0; i < pbody[0]; i++) {
    9033. 

  9033.       oprof[oprof[0]/4] = i ? (i > 1 ? 0x58595a20 : 0x64657363) : 0x74657874;
    9034. 

  9034.       pbody[i*3+2] = oprof[0];
    9035. 

  9035.       oprof[0] += (pbody[i*3+3] + 3) & -4;
    9036. 

  9036.     }
    9037. 

  9037.     memcpy (oprof+32, pbody, sizeof pbody);
    9038. 

  9038.     oprof[pbody[5]/4+2] = strlen(name[output_color-1]) + 1;
    9039. 

  9039.     memcpy ((char *)oprof+pbody[8]+8, pwhite, sizeof pwhite);
    9040. 

  9040.     pcurve[3] = (short)(256/gamm[5]+0.5) << 16;
    9041. 

  9041.     for (i=4; i < 7; i++)
    9042. 

  9042.       memcpy ((char *)oprof+pbody[i*3+2], pcurve, sizeof pcurve);
    9043. 

  9043.     pseudoinverse ((double (*)[3]) out_rgb[output_color-1], inverse, 3);
    9044. 

  9044.     for (i=0; i < 3; i++)
    9045. 

  9045.       for (j=0; j < 3; j++) {
    9046. 

  9046. 	for (num = k=0; k < 3; k++)
    9047. 

  9047. 	  num += xyzd50_srgb[i][k] * inverse[j][k];
    9048. 

  9048. 	oprof[pbody[j*3+23]/4+i+2] = num * 0x10000 + 0.5;
    9049. 

  9049.       }
    9050. 

  9050.     for (i=0; i < phead[0]/4; i++)
    9051. 

  9051.       oprof[i] = htonl(oprof[i]);
    9052. 

  9052.     strcpy ((char *)oprof+pbody[2]+8, "auto-generated by dcraw");
    9053. 

  9053.     strcpy ((char *)oprof+pbody[5]+12, name[output_color-1]);
    9054. 

  9054.     for (i=0; i < 3; i++)
    9055. 

  9055.       for (j=0; j < colors; j++)
    9056. 

  9056. 	for (out_cam[i][j] = k=0; k < 3; k++)
    9057. 

  9057. 	  out_cam[i][j] += out_rgb[output_color-1][i][k] * rgb_cam[k][j];
    9058. 

  9058.   }
    9059. 

  9059. #ifdef DCRAW_VERBOSE
    9060. 

  9060.   if (verbose)
    9061. 

  9061.     fprintf (stderr, raw_color ? _("Building histograms...\n") :
    9062. 

  9062. 	_("Converting to %s colorspace...\n"), name[output_color-1]);
    9063. 

  9063. #endif
    9064. 

  9064. #ifdef LIBRAW_LIBRARY_BUILD
    9065. 

  9065.   convert_to_rgb_loop(out_cam);
    9066. 

  9066. #else
    9067. 

  9067.   memset (histogram, 0, sizeof histogram);
    9068. 

  9068.   for (img=image[0], row=0; row < height; row++)
    9069. 

  9069.     for (col=0; col < width; col++, img+=4) {
    9070. 

  9070.       if (!raw_color) {
    9071. 

  9071. 	out[0] = out[1] = out[2] = 0;
    9072. 

  9072. 	FORCC {
    9073. 

  9073. 	  out[0] += out_cam[0][c] * img[c];
    9074. 

  9074. 	  out[1] += out_cam[1][c] * img[c];
    9075. 

  9075. 	  out[2] += out_cam[2][c] * img[c];
    9076. 

  9076. 	}
    9077. 

  9077. 	FORC3 img[c] = CLIP((int) out[c]);
    9078. 

  9078.       }
    9079. 

  9079.       else if (document_mode)
    9080. 

  9080. 	img[0] = img[fcol(row,col)];
    9081. 

  9081.       FORCC histogram[c][img[c] >> 3]++;
    9082. 

  9082.     }
    9083. 

  9083. #endif
    9084. 

  9084.   if (colors == 4 && output_color) colors = 3;
    9085. 

  9085. #ifndef LIBRAW_LIBRARY_BUILD
    9086. 

  9086.   if (document_mode && filters) colors = 1;
    9087. 

  9087. #endif
    9088. 

  9088. #ifdef LIBRAW_LIBRARY_BUILD
    9089. 

  9089.   RUN_CALLBACK(LIBRAW_PROGRESS_CONVERT_RGB,1,2);
    9090. 

  9090. #endif
    9091. 

  9091. }
    9092. 

  9092. 

  9093. void CLASS fuji_rotate()
    9094. 

  9094. {
    9095. 

  9095.   int i, row, col;
    9096. 

  9096.   double step;
    9097. 

  9097.   float r, c, fr, fc;
    9098. 

  9098.   unsigned ur, uc;
    9099. 

  9099.   ushort wide, high, (*img)[4], (*pix)[4];
    9100. 

  9100. 

  9101.   if (!fuji_width) return;
    9102. 

  9102. #ifdef DCRAW_VERBOSE
    9103. 

  9103.   if (verbose)
    9104. 

  9104.     fprintf (stderr,_("Rotating image 45 degrees...\n"));
    9105. 

  9105. #endif
    9106. 

  9106.   fuji_width = (fuji_width - 1 + shrink) >> shrink;
    9107. 

  9107.   step = sqrt(0.5);
    9108. 

  9108.   wide = fuji_width / step;
    9109. 

  9109.   high = (height - fuji_width) / step;
    9110. 

  9110.   img = (ushort (*)[4]) calloc (wide*high, sizeof *img);
    9111. 

  9111.   merror (img, "fuji_rotate()");
    9112. 

  9112. 

  9113. #ifdef LIBRAW_LIBRARY_BUILD
    9114. 

  9114.   RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE,0,2);
    9115. 

  9115. #endif
    9116. 

  9116. 

  9117.   for (row=0; row < high; row++)
    9118. 

  9118.     for (col=0; col < wide; col++) {
    9119. 

  9119.       ur = r = fuji_width + (row-col)*step;
    9120. 

  9120.       uc = c = (row+col)*step;
    9121. 

  9121.       if (ur > height-2 || uc > width-2) continue;
    9122. 

  9122.       fr = r - ur;
    9123. 

  9123.       fc = c - uc;
    9124. 

  9124.       pix = image + ur*width + uc;
    9125. 

  9125.       for (i=0; i < colors; i++)
    9126. 

  9126. 	img[row*wide+col][i] =
    9127. 

  9127. 	  (pix[    0][i]*(1-fc) + pix[      1][i]*fc) * (1-fr) +
    9128. 

  9128. 	  (pix[width][i]*(1-fc) + pix[width+1][i]*fc) * fr;
    9129. 

  9129.     }
    9130. 

  9130. 

  9131.   free (image);
    9132. 

  9132.   width  = wide;
    9133. 

  9133.   height = high;
    9134. 

  9134.   image  = img;
    9135. 

  9135.   fuji_width = 0;
    9136. 

  9136. #ifdef LIBRAW_LIBRARY_BUILD
    9137. 

  9137.   RUN_CALLBACK(LIBRAW_PROGRESS_FUJI_ROTATE,1,2);
    9138. 

  9138. #endif
    9139. 

  9139. }
    9140. 

  9140. 

  9141. void CLASS stretch()
    9142. 

  9142. {
    9143. 

  9143.   ushort newdim, (*img)[4], *pix0, *pix1;
    9144. 

  9144.   int row, col, c;
    9145. 

  9145.   double rc, frac;
    9146. 

  9146. 

  9147.   if (pixel_aspect == 1) return;
    9148. 

  9148. #ifdef LIBRAW_LIBRARY_BUILD
    9149. 

  9149.   RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH,0,2);
    9150. 

  9150. #endif
    9151. 

  9151. #ifdef DCRAW_VERBOSE
    9152. 

  9152.   if (verbose) fprintf (stderr,_("Stretching the image...\n"));
    9153. 

  9153. #endif
    9154. 

  9154.   if (pixel_aspect < 1) {
    9155. 

  9155.     newdim = height / pixel_aspect + 0.5;
    9156. 

  9156.     img = (ushort (*)[4]) calloc (width*newdim, sizeof *img);
    9157. 

  9157.     merror (img, "stretch()");
    9158. 

  9158.     for (rc=row=0; row < newdim; row++, rc+=pixel_aspect) {
    9159. 

  9159.       frac = rc - (c = rc);
    9160. 

  9160.       pix0 = pix1 = image[c*width];
    9161. 

  9161.       if (c+1 < height) pix1 += width*4;
    9162. 

  9162.       for (col=0; col < width; col++, pix0+=4, pix1+=4)
    9163. 

  9163. 	FORCC img[row*width+col][c] = pix0[c]*(1-frac) + pix1[c]*frac + 0.5;
    9164. 

  9164.     }
    9165. 

  9165.     height = newdim;
    9166. 

  9166.   } else {
    9167. 

  9167.     newdim = width * pixel_aspect + 0.5;
    9168. 

  9168.     img = (ushort (*)[4]) calloc (height*newdim, sizeof *img);
    9169. 

  9169.     merror (img, "stretch()");
    9170. 

  9170.     for (rc=col=0; col < newdim; col++, rc+=1/pixel_aspect) {
    9171. 

  9171.       frac = rc - (c = rc);
    9172. 

  9172.       pix0 = pix1 = image[c];
    9173. 

  9173.       if (c+1 < width) pix1 += 4;
    9174. 

  9174.       for (row=0; row < height; row++, pix0+=width*4, pix1+=width*4)
    9175. 

  9175. 	FORCC img[row*newdim+col][c] = pix0[c]*(1-frac) + pix1[c]*frac + 0.5;
    9176. 

  9176.     }
    9177. 

  9177.     width = newdim;
    9178. 

  9178.   }
    9179. 

  9179.   free (image);
    9180. 

  9180.   image = img;
    9181. 

  9181. #ifdef LIBRAW_LIBRARY_BUILD
    9182. 

  9182.   RUN_CALLBACK(LIBRAW_PROGRESS_STRETCH,1,2);
    9183. 

  9183. #endif
    9184. 

  9184. }
    9185. 

  9185. 

  9186. int CLASS flip_index (int row, int col)
    9187. 

  9187. {
    9188. 

  9188.   if (flip & 4) SWAP(row,col);
    9189. 

  9189.   if (flip & 2) row = iheight - 1 - row;
    9190. 

  9190.   if (flip & 1) col = iwidth  - 1 - col;
    9191. 

  9191.   return row * iwidth + col;
    9192. 

  9192. }
    9193. 

  9193. void CLASS tiff_set (ushort *ntag,
    9194. 

  9194. 	ushort tag, ushort type, int count, int val)
    9195. 

  9195. {
    9196. 

  9196.   struct tiff_tag *tt;
    9197. 

  9197.   int c;
    9198. 

  9198. 

  9199.   tt = (struct tiff_tag *)(ntag+1) + (*ntag)++;
    9200. 

  9200.   tt->tag = tag;
    9201. 

  9201.   tt->type = type;
    9202. 

  9202.   tt->count = count;
    9203. 

  9203.   if (type < 3 && count <= 4)
    9204. 

  9204.     FORC(4) tt->val.c[c] = val >> (c << 3);
    9205. 

  9205.   else if (type == 3 && count <= 2)
    9206. 

  9206.     FORC(2) tt->val.s[c] = val >> (c << 4);
    9207. 

  9207.   else tt->val.i = val;
    9208. 

  9208. }
    9209. 

  9209. 

  9210. #define TOFF(ptr) ((char *)(&(ptr)) - (char *)th)
    9211. 

  9211. 

  9212. void CLASS tiff_head (struct tiff_hdr *th, int full)
    9213. 

  9213. {
    9214. 

  9214.   int c, psize=0;
    9215. 

  9215.   struct tm *t;
    9216. 

  9216. 

  9217.   memset (th, 0, sizeof *th);
    9218. 

  9218.   th->t_order = htonl(0x4d4d4949) >> 16;
    9219. 

  9219.   th->magic = 42;
    9220. 

  9220.   th->ifd = 10;
    9221. 

  9221.   if (full) {
    9222. 

  9222.     tiff_set (&th->ntag, 254, 4, 1, 0);
    9223. 

  9223.     tiff_set (&th->ntag, 256, 4, 1, width);
    9224. 

  9224.     tiff_set (&th->ntag, 257, 4, 1, height);
    9225. 

  9225.     tiff_set (&th->ntag, 258, 3, colors, output_bps);
    9226. 

  9226.     if (colors > 2)
    9227. 

  9227.       th->tag[th->ntag-1].val.i = TOFF(th->bps);
    9228. 

  9228.     FORC4 th->bps[c] = output_bps;
    9229. 

  9229.     tiff_set (&th->ntag, 259, 3, 1, 1);
    9230. 

  9230.     tiff_set (&th->ntag, 262, 3, 1, 1 + (colors > 1));
    9231. 

  9231.   }
    9232. 

  9232.   tiff_set (&th->ntag, 270, 2, 512, TOFF(th->t_desc));
    9233. 

  9233.   tiff_set (&th->ntag, 271, 2, 64, TOFF(th->t_make));
    9234. 

  9234.   tiff_set (&th->ntag, 272, 2, 64, TOFF(th->t_model));
    9235. 

  9235.   if (full) {
    9236. 

  9236.     if (oprof) psize = ntohl(oprof[0]);
    9237. 

  9237.     tiff_set (&th->ntag, 273, 4, 1, sizeof *th + psize);
    9238. 

  9238.     tiff_set (&th->ntag, 277, 3, 1, colors);
    9239. 

  9239.     tiff_set (&th->ntag, 278, 4, 1, height);
    9240. 

  9240.     tiff_set (&th->ntag, 279, 4, 1, height*width*colors*output_bps/8);
    9241. 

  9241.   } else
    9242. 

  9242.     tiff_set (&th->ntag, 274, 3, 1, "12435867"[flip]-'0');
    9243. 

  9243.   tiff_set (&th->ntag, 282, 5, 1, TOFF(th->rat[0]));
    9244. 

  9244.   tiff_set (&th->ntag, 283, 5, 1, TOFF(th->rat[2]));
    9245. 

  9245.   tiff_set (&th->ntag, 284, 3, 1, 1);
    9246. 

  9246.   tiff_set (&th->ntag, 296, 3, 1, 2);
    9247. 

  9247.   tiff_set (&th->ntag, 305, 2, 32, TOFF(th->soft));
    9248. 

  9248.   tiff_set (&th->ntag, 306, 2, 20, TOFF(th->date));
    9249. 

  9249.   tiff_set (&th->ntag, 315, 2, 64, TOFF(th->t_artist));
    9250. 

  9250.   tiff_set (&th->ntag, 34665, 4, 1, TOFF(th->nexif));
    9251. 

  9251.   if (psize) tiff_set (&th->ntag, 34675, 7, psize, sizeof *th);
    9252. 

  9252.   tiff_set (&th->nexif, 33434, 5, 1, TOFF(th->rat[4]));
    9253. 

  9253.   tiff_set (&th->nexif, 33437, 5, 1, TOFF(th->rat[6]));
    9254. 

  9254.   tiff_set (&th->nexif, 34855, 3, 1, iso_speed);
    9255. 

  9255.   tiff_set (&th->nexif, 37386, 5, 1, TOFF(th->rat[8]));
    9256. 

  9256.   if (gpsdata[1]) {
    9257. 

  9257.     tiff_set (&th->ntag, 34853, 4, 1, TOFF(th->ngps));
    9258. 

  9258.     tiff_set (&th->ngps,  0, 1,  4, 0x202);
    9259. 

  9259.     tiff_set (&th->ngps,  1, 2,  2, gpsdata[29]);
    9260. 

  9260.     tiff_set (&th->ngps,  2, 5,  3, TOFF(th->gps[0]));
    9261. 

  9261.     tiff_set (&th->ngps,  3, 2,  2, gpsdata[30]);
    9262. 

  9262.     tiff_set (&th->ngps,  4, 5,  3, TOFF(th->gps[6]));
    9263. 

  9263.     tiff_set (&th->ngps,  5, 1,  1, gpsdata[31]);
    9264. 

  9264.     tiff_set (&th->ngps,  6, 5,  1, TOFF(th->gps[18]));
    9265. 

  9265.     tiff_set (&th->ngps,  7, 5,  3, TOFF(th->gps[12]));
    9266. 

  9266.     tiff_set (&th->ngps, 18, 2, 12, TOFF(th->gps[20]));
    9267. 

  9267.     tiff_set (&th->ngps, 29, 2, 12, TOFF(th->gps[23]));
    9268. 

  9268.     memcpy (th->gps, gpsdata, sizeof th->gps);
    9269. 

  9269.   }
    9270. 

  9270.   th->rat[0] = th->rat[2] = 300;
    9271. 

  9271.   th->rat[1] = th->rat[3] = 1;
    9272. 

  9272.   FORC(6) th->rat[4+c] = 1000000;
    9273. 

  9273.   th->rat[4] *= shutter;
    9274. 

  9274.   th->rat[6] *= aperture;
    9275. 

  9275.   th->rat[8] *= focal_len;
    9276. 

  9276.   strncpy (th->t_desc, desc, 512);
    9277. 

  9277.   strncpy (th->t_make, make, 64);
    9278. 

  9278.   strncpy (th->t_model, model, 64);
    9279. 

  9279.   strcpy (th->soft, "dcraw v"DCRAW_VERSION);
    9280. 

  9280.   t = localtime (&timestamp);
    9281. 

  9281.   sprintf (th->date, "%04d:%02d:%02d %02d:%02d:%02d",
    9282. 

  9282.       t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec);
    9283. 

  9283.   strncpy (th->t_artist, artist, 64);
    9284. 

  9284. }
    9285. 

  9285. 

  9286. #ifdef LIBRAW_LIBRARY_BUILD
    9287. 

  9287. void CLASS jpeg_thumb_writer (FILE *tfp,char *t_humb,int t_humb_length)
    9288. 

  9288. {
    9289. 

  9289.   ushort exif[5];
    9290. 

  9290.   struct tiff_hdr th;
    9291. 

  9291.   fputc (0xff, tfp);
    9292. 

  9292.   fputc (0xd8, tfp);
    9293. 

  9293.   if (strcmp (t_humb+6, "Exif")) {
    9294. 

  9294.     memcpy (exif, "\xff\xe1  Exif\0\0", 10);
    9295. 

  9295.     exif[1] = htons (8 + sizeof th);
    9296. 

  9296.     fwrite (exif, 1, sizeof exif, tfp);
    9297. 

  9297.     tiff_head (&th, 0);
    9298. 

  9298.     fwrite (&th, 1, sizeof th, tfp);
    9299. 

  9299.   }
    9300. 

  9300.   fwrite (t_humb+2, 1, t_humb_length-2, tfp);
    9301. 

  9301. }
    9302. 

  9302. 

  9303. void CLASS jpeg_thumb()
    9304. 

  9304. {
    9305. 

  9305.   char *thumb;
    9306. 

  9306. 

  9307.   thumb = (char *) malloc (thumb_length);
    9308. 

  9308.   merror (thumb, "jpeg_thumb()");
    9309. 

  9309.   fread (thumb, 1, thumb_length, ifp);
    9310. 

  9310.   jpeg_thumb_writer(ofp,thumb,thumb_length);
    9311. 

  9311.   free (thumb);
    9312. 

  9312. }
    9313. 

  9313. #else
    9314. 

  9314. void CLASS jpeg_thumb()
    9315. 

  9315. {
    9316. 

  9316.   char *thumb;
    9317. 

  9317.   ushort exif[5];
    9318. 

  9318.   struct tiff_hdr th;
    9319. 

  9319. 

  9320.   thumb = (char *) malloc (thumb_length);
    9321. 

  9321.   merror (thumb, "jpeg_thumb()");
    9322. 

  9322.   fread (thumb, 1, thumb_length, ifp);
    9323. 

  9323.   fputc (0xff, ofp);
    9324. 

  9324.   fputc (0xd8, ofp);
    9325. 

  9325.   if (strcmp (thumb+6, "Exif")) {
    9326. 

  9326.     memcpy (exif, "\xff\xe1  Exif\0\0", 10);
    9327. 

  9327.     exif[1] = htons (8 + sizeof th);
    9328. 

  9328.     fwrite (exif, 1, sizeof exif, ofp);
    9329. 

  9329.     tiff_head (&th, 0);
    9330. 

  9330.     fwrite (&th, 1, sizeof th, ofp);
    9331. 

  9331.   }
    9332. 

  9332.   fwrite (thumb+2, 1, thumb_length-2, ofp);
    9333. 

  9333.   free (thumb);
    9334. 

  9334. }
    9335. 

  9335. #endif
    9336. 

  9336. 

  9337. void CLASS write_ppm_tiff()
    9338. 

  9338. {
    9339. 

  9339.   struct tiff_hdr th;
    9340. 

  9340.   uchar *ppm;
    9341. 

  9341.   ushort *ppm2;
    9342. 

  9342.   int c, row, col, soff, rstep, cstep;
    9343. 

  9343.   int perc, val, total, t_white=0x2000;
    9344. 

  9344. 

  9345.   perc = width * height * 0.01;		/* 99th percentile white level */
    9346. 

  9346.   if (fuji_width) perc /= 2;
    9347. 

  9347.   if (!((highlight & ~2) || no_auto_bright))
    9348. 

  9348.     for (t_white=c=0; c < colors; c++) {
    9349. 

  9349.       for (val=0x2000, total=0; --val > 32; )
    9350. 

  9350. 	if ((total += histogram[c][val]) > perc) break;
    9351. 

  9351.       if (t_white < val) t_white = val;
    9352. 

  9352.     }
    9353. 

  9353.   gamma_curve (gamm[0], gamm[1], 2, (t_white << 3)/bright);
    9354. 

  9354.   iheight = height;
    9355. 

  9355.   iwidth  = width;
    9356. 

  9356.   if (flip & 4) SWAP(height,width);
    9357. 

  9357.   ppm = (uchar *) calloc (width, colors*output_bps/8);
    9358. 

  9358.   ppm2 = (ushort *) ppm;
    9359. 

  9359.   merror (ppm, "write_ppm_tiff()");
    9360. 

  9360.   if (output_tiff) {
    9361. 

  9361.     tiff_head (&th, 1);
    9362. 

  9362.     fwrite (&th, sizeof th, 1, ofp);
    9363. 

  9363.     if (oprof)
    9364. 

  9364.       fwrite (oprof, ntohl(oprof[0]), 1, ofp);
    9365. 

  9365.   } else if (colors > 3)
    9366. 

  9366.     fprintf (ofp,
    9367. 

  9367.       "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLTYPE %s\nENDHDR\n",
    9368. 

  9368. 	width, height, colors, (1 << output_bps)-1, cdesc);
    9369. 

  9369.   else
    9370. 

  9370.     fprintf (ofp, "P%d\n%d %d\n%d\n",
    9371. 

  9371. 	colors/2+5, width, height, (1 << output_bps)-1);
    9372. 

  9372.   soff  = flip_index (0, 0);
    9373. 

  9373.   cstep = flip_index (0, 1) - soff;
    9374. 

  9374.   rstep = flip_index (1, 0) - flip_index (0, width);
    9375. 

  9375.   for (row=0; row < height; row++, soff += rstep) {
    9376. 

  9376.     for (col=0; col < width; col++, soff += cstep)
    9377. 

  9377.       if (output_bps == 8)
    9378. 

  9378. 	   FORCC ppm [col*colors+c] = curve[image[soff][c]] >> 8;
    9379. 

  9379.       else FORCC ppm2[col*colors+c] = curve[image[soff][c]];
    9380. 

  9380.     if (output_bps == 16 && !output_tiff && htons(0x55aa) != 0x55aa)
    9381. 

  9381.       swab ((char*)ppm2, (char*)ppm2, width*colors*2);
    9382. 

  9382.     fwrite (ppm, colors*output_bps/8, width, ofp);
    9383. 

  9383.   }
    9384. 

  9384.   free (ppm);
    9385. 

  9385. }
    9386. 

  9386.