PageRenderTime 71ms CodeModel.GetById 20ms RepoModel.GetById 0ms 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

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

    

  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 = (us…
    1737.

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