summaryrefslogtreecommitdiff
path: root/dcraw
diff options
context:
space:
mode:
authorHubert Figuière <hub@figuiere.net>2017-03-05 22:31:54 -0500
committerHubert Figuière <hub@figuiere.net>2017-03-05 22:31:54 -0500
commit80e20d3520c6a11b1869b0817e6e6d35a455a0b1 (patch)
treef77471bed5a1133caf39bbcedfb37b81ede7d41b /dcraw
parent8b4c9c605f3f029c76c5741913a6ac8a1bd6be92 (diff)
dcraw: update to 1.477
Diffstat (limited to 'dcraw')
-rw-r--r--dcraw/dcraw.c,v1441
1 files changed, 1209 insertions, 232 deletions
diff --git a/dcraw/dcraw.c,v b/dcraw/dcraw.c,v
index 4303438..dabb56f 100644
--- a/dcraw/dcraw.c,v
+++ b/dcraw/dcraw.c,v
@@ -1,10 +1,55 @@
-head 1.468;
+head 1.477;
access;
symbols;
locks; strict;
comment @ * @;
+1.477
+date 2016.05.10.21.30.43; author dcoffin; state Exp;
+branches;
+next 1.476;
+
+1.476
+date 2015.05.25.02.29.14; author dcoffin; state Exp;
+branches;
+next 1.475;
+
+1.475
+date 2015.04.11.00.08.36; author dcoffin; state Exp;
+branches;
+next 1.474;
+
+1.474
+date 2015.04.10.20.54.50; author dcoffin; state Exp;
+branches;
+next 1.473;
+
+1.473
+date 2015.02.25.18.18.18; author dcoffin; state Exp;
+branches;
+next 1.472;
+
+1.472
+date 2015.02.23.23.15.48; author dcoffin; state Exp;
+branches;
+next 1.471;
+
+1.471
+date 2015.02.23.03.53.34; author dcoffin; state Exp;
+branches;
+next 1.470;
+
+1.470
+date 2015.02.13.03.48.53; author dcoffin; state Exp;
+branches;
+next 1.469;
+
+1.469
+date 2015.02.10.23.02.37; author dcoffin; state Exp;
+branches;
+next 1.468;
+
1.468
date 2015.01.30.05.02.56; author dcoffin; state Exp;
branches;
@@ -2373,20 +2418,16 @@ desc
@
-1.468
+1.477
log
-@Copied color matrices from DNG Converter 8.7.1.
-Support pre-release Sonys and Canons that lack a proper model name.
-Support the Samsung NX1 (yet another compression algorithm).
-Read camera white balance in all professional Kodak cameras.
-Reduced zippering in Fuji X-Trans interpolation.
-Support YCbCr files from the Kodak C330.
-Support Hasselblad multi-shot files.
+@Added "-o 6" for ACES colorspace.
+Copied color matrices from DNG Converter 9.5.1.
+Support the Canon EOS 80D & IXUS 160, Fuji X-E2 & X-E2S & X-Pro2
@
text
@/*
dcraw.c -- Dave Coffin's raw photo decoder
- Copyright 1997-2015 by Dave Coffin, dcoffin a cybercom o net
+ Copyright 1997-2016 by Dave Coffin, dcoffin a cybercom o net
This is a command-line ANSI C program to convert raw photos from
any digital camera on any computer running any operating system.
@@ -2409,7 +2450,7 @@ text
$Date$
*/
-#define DCRAW_VERSION "9.23"
+#define DCRAW_VERSION "9.27"
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
@@ -2475,15 +2516,6 @@ typedef unsigned long long UINT64;
#define _(String) (String)
#endif
-#ifdef LJPEG_DECODE
-#error Please compile dcraw.c by itself.
-#error Do not link it with ljpeg_decode.
-#endif
-
-#ifndef LONG_BIT
-#define LONG_BIT (8 * sizeof (long))
-#endif
-
#if !defined(uchar)
#define uchar unsigned char
#endif
@@ -2544,6 +2576,7 @@ struct decode {
struct tiff_ifd {
int width, height, bps, comp, phint, offset, flip, samples, bytes;
int tile_width, tile_length;
+ float shutter;
} tiff_ifd[10];
struct ph1 {
@@ -2565,7 +2598,7 @@ struct ph1 {
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define LIM(x,min,max) MAX(min,MIN(x,max))
#define ULIM(x,y,z) ((y) < (z) ? LIM(x,y,z) : LIM(x,z,y))
-#define CLIP(x) LIM(x,0,65535)
+#define CLIP(x) LIM((int)(x),0,65535)
#define SWAP(a,b) { a=a+b; b=a-b; a=a-b; }
/*
@@ -3199,27 +3232,22 @@ void CLASS canon_load_raw()
FORC(2) free (huff[c]);
}
-/*
- Not a full implementation of Lossless JPEG, just
- enough to decode Canon, Kodak and Adobe DNG images.
- */
struct jhead {
- int bits, high, wide, clrs, sraw, psv, restart, vpred[6];
- ushort *huff[6], *free[4], *row;
+ int algo, bits, high, wide, clrs, sraw, psv, restart, vpred[6];
+ ushort quant[64], idct[64], *huff[20], *free[20], *row;
};
int CLASS ljpeg_start (struct jhead *jh, int info_only)
{
- int c, tag, len;
+ ushort c, tag, len;
uchar data[0x10000];
const uchar *dp;
memset (jh, 0, sizeof *jh);
jh->restart = INT_MAX;
- fread (data, 2, 1, ifp);
- if (data[1] != 0xd8) return 0;
+ if ((fgetc(ifp),fgetc(ifp)) != 0xd8) return 0;
do {
- fread (data, 2, 2, ifp);
+ if (!fread (data, 2, 2, ifp)) return 0;
tag = data[0] << 8 | data[1];
len = (data[2] << 8 | data[3]) - 2;
if (tag <= 0xff00) return 0;
@@ -3227,7 +3255,9 @@ int CLASS ljpeg_start (struct jhead *jh, int info_only)
switch (tag) {
case 0xffc3:
jh->sraw = ((data[7] >> 4) * (data[7] & 15) - 1) & 3;
+ case 0xffc1:
case 0xffc0:
+ jh->algo = tag & 0xff;
jh->bits = data[0];
jh->high = data[1] << 8 | data[2];
jh->wide = data[3] << 8 | data[4];
@@ -3236,20 +3266,25 @@ int CLASS ljpeg_start (struct jhead *jh, int info_only)
break;
case 0xffc4:
if (info_only) break;
- for (dp = data; dp < data+len && (c = *dp++) < 4; )
+ for (dp = data; dp < data+len && !((c = *dp++) & -20); )
jh->free[c] = jh->huff[c] = make_decoder_ref (&dp);
break;
case 0xffda:
jh->psv = data[1+data[0]*2];
jh->bits -= data[3+data[0]*2] & 15;
break;
+ case 0xffdb:
+ FORC(64) jh->quant[c] = data[c*2+1] << 8 | data[c*2+2];
+ break;
case 0xffdd:
jh->restart = data[0] << 8 | data[1];
}
} while (tag != 0xffda);
+ if (jh->bits > 16 || jh->clrs > 6 ||
+ !jh->bits || !jh->high || !jh->wide || !jh->clrs) return 0;
if (info_only) return 1;
- if (jh->clrs > 6 || !jh->huff[0]) return 0;
- FORC(5) if (!jh->huff[c+1]) jh->huff[c+1] = jh->huff[c];
+ if (!jh->huff[0]) return 0;
+ FORC(19) if (!jh->huff[c+1]) jh->huff[c+1] = jh->huff[c];
if (jh->sraw) {
FORC(4) jh->huff[2+c] = jh->huff[1];
FORC(jh->sraw) jh->huff[1+c] = jh->huff[0];
@@ -3335,10 +3370,10 @@ void CLASS lossless_jpeg_load_raw()
val = curve[*rp++];
if (cr2_slice[0]) {
jidx = jrow*jwide + jcol;
- i = jidx / (cr2_slice[1]*jh.high);
+ i = jidx / (cr2_slice[1]*raw_height);
if ((j = i >= cr2_slice[0]))
i = cr2_slice[0];
- jidx -= i * (cr2_slice[1]*jh.high);
+ jidx -= i * (cr2_slice[1]*raw_height);
row = jidx / cr2_slice[1+j];
col = jidx % cr2_slice[1+j] + i*cr2_slice[1];
}
@@ -3428,23 +3463,59 @@ void CLASS adobe_copy_pixel (unsigned row, unsigned col, ushort **rp)
{
int c;
- if (is_raw == 2 && shot_select) (*rp)++;
+ if (tiff_samples == 2 && shot_select) (*rp)++;
if (raw_image) {
if (row < raw_height && col < raw_width)
RAW(row,col) = curve[**rp];
- *rp += is_raw;
+ *rp += tiff_samples;
} else {
if (row < height && col < width)
FORC(tiff_samples)
image[row*width+col][c] = curve[(*rp)[c]];
*rp += tiff_samples;
}
- if (is_raw == 2 && shot_select) (*rp)--;
+ if (tiff_samples == 2 && shot_select) (*rp)--;
+}
+
+void CLASS ljpeg_idct (struct jhead *jh)
+{
+ int c, i, j, len, skip, coef;
+ float work[3][8][8];
+ static float cs[106] = { 0 };
+ static const uchar zigzag[80] =
+ { 0, 1, 8,16, 9, 2, 3,10,17,24,32,25,18,11, 4, 5,12,19,26,33,
+ 40,48,41,34,27,20,13, 6, 7,14,21,28,35,42,49,56,57,50,43,36,
+ 29,22,15,23,30,37,44,51,58,59,52,45,38,31,39,46,53,60,61,54,
+ 47,55,62,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63 };
+
+ if (!cs[0])
+ FORC(106) cs[c] = cos((c & 31)*M_PI/16)/2;
+ memset (work, 0, sizeof work);
+ work[0][0][0] = jh->vpred[0] += ljpeg_diff (jh->huff[0]) * jh->quant[0];
+ for (i=1; i < 64; i++ ) {
+ len = gethuff (jh->huff[16]);
+ i += skip = len >> 4;
+ if (!(len &= 15) && skip < 15) break;
+ coef = getbits(len);
+ if ((coef & (1 << (len-1))) == 0)
+ coef -= (1 << len) - 1;
+ ((float *)work)[zigzag[i]] = coef * jh->quant[i];
+ }
+ FORC(8) work[0][0][c] *= M_SQRT1_2;
+ FORC(8) work[0][c][0] *= M_SQRT1_2;
+ for (i=0; i < 8; i++)
+ for (j=0; j < 8; j++)
+ FORC(8) work[1][i][j] += work[0][i][c] * cs[(j*2+1)*c];
+ for (i=0; i < 8; i++)
+ for (j=0; j < 8; j++)
+ FORC(8) work[2][i][j] += work[1][c][j] * cs[(i*2+1)*c];
+
+ FORC(64) jh->idct[c] = CLIP(((float *)work[2])[c]+0.5);
}
void CLASS lossless_dng_load_raw()
{
- unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col;
+ unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col, i, j;
struct jhead jh;
ushort *rp;
@@ -3455,14 +3526,32 @@ void CLASS lossless_dng_load_raw()
if (!ljpeg_start (&jh, 0)) break;
jwide = jh.wide;
if (filters) jwide *= jh.clrs;
- jwide /= is_raw;
- for (row=col=jrow=0; jrow < jh.high; jrow++) {
- rp = ljpeg_row (jrow, &jh);
- for (jcol=0; jcol < jwide; jcol++) {
- adobe_copy_pixel (trow+row, tcol+col, &rp);
- if (++col >= tile_width || col >= raw_width)
- row += 1 + (col = 0);
- }
+ jwide /= MIN (is_raw, tiff_samples);
+ switch (jh.algo) {
+ case 0xc1:
+ jh.vpred[0] = 16384;
+ getbits(-1);
+ for (jrow=0; jrow+7 < jh.high; jrow += 8) {
+ for (jcol=0; jcol+7 < jh.wide; jcol += 8) {
+ ljpeg_idct (&jh);
+ rp = jh.idct;
+ row = trow + jcol/tile_width + jrow*2;
+ col = tcol + jcol%tile_width;
+ for (i=0; i < 16; i+=2)
+ for (j=0; j < 8; j++)
+ adobe_copy_pixel (row+i, col+j, &rp);
+ }
+ }
+ break;
+ case 0xc3:
+ for (row=col=jrow=0; jrow < jh.high; jrow++) {
+ rp = ljpeg_row (jrow, &jh);
+ for (jcol=0; jcol < jwide; jcol++) {
+ adobe_copy_pixel (trow+row, tcol+col, &rp);
+ if (++col >= tile_width || col >= raw_width)
+ row += 1 + (col = 0);
+ }
+ }
}
fseek (ifp, save+4, SEEK_SET);
if ((tcol += tile_width) >= raw_width)
@@ -3584,6 +3673,25 @@ void CLASS nikon_load_raw()
free (huff);
}
+void CLASS nikon_yuv_load_raw()
+{
+ int row, col, yuv[4], rgb[3], b, c;
+ UINT64 bitbuf=0;
+
+ for (row=0; row < raw_height; row++)
+ for (col=0; col < raw_width; col++) {
+ if (!(b = col & 1)) {
+ bitbuf = 0;
+ FORC(6) bitbuf |= (UINT64) fgetc(ifp) << c*8;
+ FORC(4) yuv[c] = (bitbuf >> c*12 & 0xfff) - (c >> 1 << 11);
+ }
+ rgb[0] = yuv[b] + 1.370705*yuv[3];
+ rgb[1] = yuv[b] - 0.337633*yuv[2] - 0.698001*yuv[3];
+ rgb[2] = yuv[b] + 1.732446*yuv[2];
+ FORC3 image[row*width+col][c] = curve[LIM(rgb[c],0,0xfff)] / cam_mul[c];
+ }
+}
+
/*
Returns 1 for a Coolpix 995, 0 for anything else.
*/
@@ -3892,7 +4000,7 @@ void CLASS phase_one_correct()
for (qr = 0; qr < 2; qr++)
for (qc = 0; qc < 2; qc++)
for (i = 0; i < 16; i++)
- lc[qr][qc][i] = (ushort)get4();
+ lc[qr][qc][i] = get4();
for (i = 0; i < 16; i++) {
int v = 0;
for (qr = 0; qr < 2; qr++)
@@ -3902,15 +4010,15 @@ void CLASS phase_one_correct()
}
for (qr = 0; qr < 2; qr++) {
for (qc = 0; qc < 2; qc++) {
- int cx[18], cf[18];
+ int cx[19], cf[19];
for (i = 0; i < 16; i++) {
cx[1+i] = lc[qr][qc][i];
cf[1+i] = ref[i];
}
cx[0] = cf[0] = 0;
- cx[17] = cf[17] = ((unsigned int)ref[15] * 65535) / lc[qr][qc][15];
- cubic_spline(cx, cf, 18);
-
+ cx[17] = cf[17] = ((unsigned) ref[15] * 65535) / lc[qr][qc][15];
+ cx[18] = cf[18] = 65535;
+ cubic_spline(cx, cf, 19);
for (row = (qr ? ph1.split_row : 0);
row < (qr ? raw_height : ph1.split_row); row++)
for (col = (qc ? ph1.split_col : 0);
@@ -3939,17 +4047,17 @@ void CLASS phase_one_correct()
ushort lc[2][2][7], ref[7];
int qr, qc;
for (i = 0; i < 7; i++)
- ref[i] = (ushort)get4();
+ ref[i] = get4();
for (qr = 0; qr < 2; qr++)
for (qc = 0; qc < 2; qc++)
for (i = 0; i < 7; i++)
- lc[qr][qc][i] = (ushort)get4();
+ lc[qr][qc][i] = get4();
for (qr = 0; qr < 2; qr++) {
for (qc = 0; qc < 2; qc++) {
int cx[9], cf[9];
for (i = 0; i < 7; i++) {
cx[1+i] = ref[i];
- cf[1+i] = ((unsigned int)ref[i] * lc[qr][qc][i]) / 10000;
+ cf[1+i] = ((unsigned) ref[i] * lc[qr][qc][i]) / 10000;
}
cx[0] = cf[0] = 0;
cx[8] = cf[8] = 65535;
@@ -4088,7 +4196,7 @@ void CLASS phase_one_load_raw_c()
pixel[col] = curve[pixel[col]];
}
for (col=0; col < raw_width; col++) {
- i = (pixel[col] << 2) - ph1.black
+ i = (pixel[col] << 2*(ph1.format != 8)) - ph1.black
+ cblack[row][col >= ph1.split_col]
+ rblack[col][row >= ph1.split_row];
if (i > 0) RAW(row,col) = i;
@@ -4267,8 +4375,8 @@ void CLASS packed_load_raw()
}
val = bitbuf << (64-tiff_bps-vbits) >> (64-tiff_bps);
RAW(row,col ^ (load_flags >> 6 & 1)) = val;
- if (load_flags & 1 && (col % 10) == 9 &&
- fgetc(ifp) && col < width+left_margin) derror();
+ if (load_flags & 1 && (col % 10) == 9 && fgetc(ifp) &&
+ row < height+top_margin && col < width+left_margin) derror();
}
vbits -= rbits;
}
@@ -4278,6 +4386,7 @@ void CLASS nokia_load_raw()
{
uchar *data, *dp;
int rev, dwide, row, col, c;
+ double sum[]={0,0};
rev = 3 * (order == 0x4949);
dwide = (raw_width * 5 + 1) / 4;
@@ -4291,6 +4400,13 @@ void CLASS nokia_load_raw()
}
free (data);
maximum = 0x3ff;
+ if (strcmp(make,"OmniVision")) return;
+ row = raw_height/2;
+ FORC(width-1) {
+ sum[ c & 1] += SQR(RAW(row,c)-RAW(row+1,c+1));
+ sum[~c & 1] += SQR(RAW(row+1,c)-RAW(row,c+1));
+ }
+ if (sum[1] > sum[0]) filters = 0x4b4b4b4b;
}
void CLASS canon_rmf_load_raw()
@@ -4531,12 +4647,12 @@ void CLASS kodak_radc_load_raw()
(c-pt[i-2]) / (pt[i]-pt[i-2]) * (pt[i+1]-pt[i-1]) + pt[i-1] + 0.5;
for (s=i=0; i < sizeof src; i+=2)
FORC(256 >> src[i])
- huff[0][s++] = src[i] << 8 | (uchar) src[i+1];
+ ((ushort *)huff)[s++] = src[i] << 8 | (uchar) src[i+1];
s = kodak_cbpp == 243 ? 2 : 3;
FORC(256) huff[18][c] = (8-s) << 8 | c >> s << s | 1 << (s-1);
getbits(-1);
for (i=0; i < sizeof(buf)/sizeof(short); i++)
- buf[0][0][i] = 2048;
+ ((short *)buf)[i] = 2048;
for (row=0; row < height; row+=4) {
FORC3 mul[c] = getbits(6);
FORC3 {
@@ -4545,7 +4661,7 @@ void CLASS kodak_radc_load_raw()
x = ~(-1 << (s-1));
val <<= 12-s;
for (i=0; i < sizeof(buf[0])/sizeof(short); i++)
- buf[c][0][i] = (buf[c][0][i] * val + x) >> s;
+ ((short *)buf[c])[i] = (((short *)buf[c])[i] * val + x) >> s;
last[c] = mul[c];
for (r=0; r <= !c; r++) {
buf[c][1][width/2] = buf[c][2][width/2] = mul[c] << 7;
@@ -4988,14 +5104,14 @@ void CLASS sony_load_raw()
key = get4();
fseek (ifp, 164600, SEEK_SET);
fread (head, 1, 40, ifp);
- sony_decrypt ((unsigned int *) head, 10, 1, key);
+ sony_decrypt ((unsigned *) head, 10, 1, key);
for (i=26; i-- > 22; )
key = key << 8 | head[i];
fseek (ifp, data_offset, SEEK_SET);
for (row=0; row < raw_height; row++) {
pixel = raw_image + row*raw_width;
if (fread (pixel, 2, raw_width, ifp) < raw_width) derror();
- sony_decrypt ((unsigned int *) pixel, raw_width/2, !row, key);
+ sony_decrypt ((unsigned *) pixel, raw_width/2, !row, key);
for (col=0; col < raw_width; col++)
if ((pixel[col] = ntohs(pixel[col])) >> 14) derror();
}
@@ -5120,7 +5236,7 @@ void CLASS samsung3_load_raw()
fseek (ifp, (data_offset-ftell(ifp)) & 15, SEEK_CUR);
ph1_bits(-1);
mag = 0; pmode = 7;
- FORC(6) lent[0][c] = row < 2 ? 7:4;
+ FORC(6) ((ushort *)lent)[c] = row < 2 ? 7:4;
prow[ row & 1] = &RAW(row-1,1-((row & 1) << 1)); // green
prow[~row & 1] = &RAW(row-2,0); // red and blue
for (tab=0; tab+15 < raw_width; tab+=16) {
@@ -5172,6 +5288,8 @@ void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
fseek (ifp, seg[0][1]+1, SEEK_SET);
getbits(-1);
+ if (seg[1][0] > raw_width*raw_height)
+ seg[1][0] = raw_width*raw_height;
for (pix=seg[0][0]; pix < seg[1][0]; pix++) {
for (s=0; s < 3; s++) {
data = data << nbits | getbits(nbits);
@@ -5277,10 +5395,10 @@ void CLASS smal_v9_load_raw()
fseek (ifp, 67, SEEK_SET);
offset = get4();
- nseg = fgetc(ifp);
+ nseg = (uchar) fgetc(ifp);
fseek (ifp, offset, SEEK_SET);
for (i=0; i < nseg*2; i++)
- seg[0][i] = get4() + data_offset*(i & 1);
+ ((unsigned *)seg)[i] = get4() + data_offset*(i & 1);
fseek (ifp, 78, SEEK_SET);
holes = fgetc(ifp);
fseek (ifp, 88, SEEK_SET);
@@ -5743,8 +5861,8 @@ void CLASS foveon_interpolate()
black = (float (*)[3]) calloc (height, sizeof *black);
for (row=0; row < height; row++) {
for (i=0; i < 6; i++)
- ddft[0][0][i] = ddft[1][0][i] +
- row / (height-1.0) * (ddft[2][0][i] - ddft[1][0][i]);
+ ((float *)ddft[0])[i] = ((float *)ddft[1])[i] +
+ row / (height-1.0) * (((float *)ddft[2])[i] - ((float *)ddft[1])[i]);
FORC3 black[row][c] =
( foveon_avg (image[row*width]+c, dscr[0], cfilt) +
foveon_avg (image[row*width]+c, dscr[1], cfilt) * 3
@@ -5789,8 +5907,8 @@ void CLASS foveon_interpolate()
for (row=0; row < height; row++) {
for (i=0; i < 6; i++)
- ddft[0][0][i] = ddft[1][0][i] +
- row / (height-1.0) * (ddft[2][0][i] - ddft[1][0][i]);
+ ((float *)ddft[0])[i] = ((float *)ddft[1])[i] +
+ row / (height-1.0) * (((float *)ddft[2])[i] - ((float *)ddft[1])[i]);
pix = image[row*width];
memcpy (prev, pix, sizeof prev);
frow = row / (height-1.0) * (dim[2]-1);
@@ -5829,7 +5947,7 @@ void CLASS foveon_interpolate()
free (sgrow);
free (sgain);
- if ((badpix = (unsigned int *) foveon_camf_matrix (dim, "BadPixels"))) {
+ if ((badpix = (unsigned *) foveon_camf_matrix (dim, "BadPixels"))) {
for (i=0; i < dim[0]; i++) {
col = (badpix[i] >> 8 & 0xfff) - keep[0];
row = (badpix[i] >> 20 ) - keep[1];
@@ -6570,13 +6688,13 @@ skip_block: ;
}
size = iheight*iwidth;
for (i=0; i < size*4; i++) {
- if (!(val = image[0][i])) continue;
+ if (!(val = ((ushort *)image)[i])) continue;
if (cblack[4] && cblack[5])
val -= cblack[6 + i/4 / iwidth % cblack[4] * cblack[5] +
i/4 % iwidth % cblack[5]];
val -= cblack[i & 3];
val *= scale_mul[i & 3];
- image[0][i] = CLIP(val);
+ ((ushort *)image)[i] = CLIP(val);
}
if ((aber[0] != 1 || aber[2] != 1) && colors == 3) {
if (verbose)
@@ -6965,7 +7083,6 @@ void CLASS xtrans_interpolate (int passes)
fprintf (stderr,_("%d-pass X-Trans interpolation...\n"), passes);
cielab (0,0);
- border_interpolate(6);
ndir = 4 << (passes > 1);
buffer = (char *) malloc (TS*TS*(ndir*11+6));
merror (buffer, "xtrans_interpolate()");
@@ -7170,6 +7287,7 @@ void CLASS xtrans_interpolate (int passes)
}
}
free(buffer);
+ border_interpolate(8);
}
#undef fcol
@@ -7614,6 +7732,13 @@ nf: order = 0x4949;
if (tag == 0x1d)
while ((c = fgetc(ifp)) && c != EOF)
serial = serial*10 + (isdigit(c) ? c - '0' : c % 10);
+ if (tag == 0x29 && type == 1) {
+ c = wbi < 18 ? "012347800000005896"[wbi]-'0' : 0;
+ fseek (ifp, 8 + c*32, SEEK_CUR);
+ FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get4();
+ }
+ if (tag == 0x3d && type == 3 && len == 4)
+ FORC4 cblack[c ^ c >> 1] = get2() >> (14-tiff_bps);
if (tag == 0x81 && type == 4) {
data_offset = get4();
fseek (ifp, data_offset + 41, SEEK_SET);
@@ -7621,11 +7746,6 @@ nf: order = 0x4949;
raw_width = get2();
filters = 0x61616161;
}
- if (tag == 0x29 && type == 1) {
- c = wbi < 18 ? "012347800000005896"[wbi]-'0' : 0;
- fseek (ifp, 8 + c*32, SEEK_CUR);
- FORC4 cam_mul[c ^ (c >> 1) ^ 1] = get4();
- }
if ((tag == 0x81 && type == 7) ||
(tag == 0x100 && type == 7) ||
(tag == 0x280 && type == 1)) {
@@ -7648,7 +7768,8 @@ nf: order = 0x4949;
break;
case 102:
fseek (ifp, 6, SEEK_CUR);
- goto get2_rggb;
+ FORC4 cam_mul[c ^ (c >> 1)] = get2();
+ break;
case 103:
fseek (ifp, 16, SEEK_CUR);
FORC4 cam_mul[c] = get2();
@@ -7682,7 +7803,7 @@ nf: order = 0x4949;
if (tag == 0x200 && len == 4)
FORC4 cblack[c ^ c >> 1] = get2();
if (tag == 0x201 && len == 4)
- goto get2_rggb;
+ FORC4 cam_mul[c ^ (c >> 1)] = get2();
if (tag == 0x220 && type == 7)
meta_offset = ftell(ifp);
if (tag == 0x401 && type == 4 && len == 4)
@@ -7728,7 +7849,7 @@ get2_256:
}
if ((tag | 0x70) == 0x2070 && (type == 4 || type == 13))
fseek (ifp, get4()+base, SEEK_SET);
- if (tag == 0x2020)
+ if (tag == 0x2020 && !strncmp(buf,"OLYMP",5))
parse_thumb_note (base, 257, 258);
if (tag == 0x2040)
parse_makernote (base, 0x2040);
@@ -7739,12 +7860,15 @@ get2_256:
if (tag == 0x4001 && len > 500) {
i = len == 582 ? 50 : len == 653 ? 68 : len == 5120 ? 142 : 126;
fseek (ifp, i, SEEK_CUR);
-get2_rggb:
FORC4 cam_mul[c ^ (c >> 1)] = get2();
- i = len >> 3 == 164 || len == 1506 ? 112:22;
- fseek (ifp, i, SEEK_CUR);
- FORC4 sraw_mul[c ^ (c >> 1)] = get2();
+ for (i+=18; i <= len; i+=10) {
+ get2();
+ FORC4 sraw_mul[c ^ (c >> 1)] = get2();
+ if (sraw_mul[1] == 1170) break;
+ }
}
+ if (tag == 0x4021 && get4() && get4())
+ FORC4 cam_mul[c] = 1024;
if (tag == 0xa021)
FORC4 cam_mul[c ^ (c >> 1)] = get4();
if (tag == 0xa028)
@@ -7794,12 +7918,14 @@ void CLASS parse_exif (int base)
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
switch (tag) {
- case 33434: shutter = getreal(type); break;
+ case 33434: tiff_ifd[tiff_nifds-1].shutter =
+ shutter = getreal(type); break;
case 33437: aperture = getreal(type); break;
case 34855: iso_speed = get2(); break;
case 36867:
case 36868: get_timestamp(0); break;
case 37377: if ((expo = -getreal(type)) < 128)
+ tiff_ifd[tiff_nifds-1].shutter =
shutter = pow (2, expo); break;
case 37378: aperture = pow (2, getreal(type)/2); break;
case 37386: focal_len = getreal(type); break;
@@ -7858,7 +7984,7 @@ void CLASS parse_mos (int offset)
{ "","DCB2","Volare","Cantare","CMost","Valeo 6","Valeo 11","Valeo 22",
"Valeo 11p","Valeo 17","","Aptus 17","Aptus 22","Aptus 75","Aptus 65",
"Aptus 54S","Aptus 65S","Aptus 75S","AFi 5","AFi 6","AFi 7",
- "Aptus-II 7","","","Aptus-II 6","","","Aptus-II 10","Aptus-II 5",
+ "AFi-II 7","Aptus-II 7","","Aptus-II 6","","","Aptus-II 10","Aptus-II 5",
"","","","","Aptus-II 10R","Aptus-II 8","","Aptus-II 12","","AFi-II 12" };
float romm_cam[3][3];
@@ -7884,12 +8010,12 @@ void CLASS parse_mos (int offset)
}
if (!strcmp(data,"icc_camera_to_tone_matrix")) {
for (i=0; i < 9; i++)
- romm_cam[0][i] = int_to_float(get4());
+ ((float *)romm_cam)[i] = int_to_float(get4());
romm_coeff (romm_cam);
}
if (!strcmp(data,"CaptProf_color_matrix")) {
for (i=0; i < 9; i++)
- fscanf (ifp, "%f", &romm_cam[0][i]);
+ fscanf (ifp, "%f", (float *)romm_cam + i);
romm_coeff (romm_cam);
}
if (!strcmp(data,"CaptProf_number_of_planes"))
@@ -8037,6 +8163,8 @@ int CLASS parse_tiff_ifd (int base)
case 61443:
tiff_ifd[ifd].samples = len & 7;
tiff_ifd[ifd].bps = getint(type);
+ if (tiff_bps < tiff_ifd[ifd].bps)
+ tiff_bps = tiff_ifd[ifd].bps;
break;
case 61446:
raw_height = 0;
@@ -8077,6 +8205,10 @@ int CLASS parse_tiff_ifd (int base)
tiff_ifd[ifd].samples = jh.clrs;
if (!(jh.sraw || (jh.clrs & 1)))
tiff_ifd[ifd].width *= jh.clrs;
+ if ((tiff_ifd[ifd].width > 4*tiff_ifd[ifd].height) & ~jh.clrs) {
+ tiff_ifd[ifd].width /= 2;
+ tiff_ifd[ifd].height *= 2;
+ }
i = order;
parse_tiff (tiff_ifd[ifd].offset + 12);
order = i;
@@ -8175,7 +8307,7 @@ int CLASS parse_tiff_ifd (int base)
break;
case 33422: /* CFAPattern */
if (filters == 9) {
- FORC(36) xtrans[0][c] = fgetc(ifp) & 3;
+ FORC(36) ((char *)xtrans)[c] = fgetc(ifp) & 3;
break;
}
case 64777: /* Kodak P-series */
@@ -8194,7 +8326,7 @@ int CLASS parse_tiff_ifd (int base)
parse_kodak_ifd (base);
break;
case 33434: /* ExposureTime */
- shutter = getreal(type);
+ tiff_ifd[ifd].shutter = shutter = getreal(type);
break;
case 33437: /* FNumber */
aperture = getreal(type);
@@ -8322,6 +8454,14 @@ int CLASS parse_tiff_ifd (int base)
if (!make[0]) strcpy (make, "DNG");
is_raw = 1;
break;
+ case 50708: /* UniqueCameraModel */
+ if (model[0]) break;
+ fgets (make, 64, ifp);
+ if ((cp = strchr(make,' '))) {
+ strcpy(model,cp+1);
+ *cp = 0;
+ }
+ break;
case 50710: /* CFAPlaneColor */
if (filters == 9) break;
if (len > 4) len = 4;
@@ -8335,10 +8475,7 @@ guess_cfa_pc:
filters -= !filters;
break;
case 50711: /* CFALayout */
- if (get2() == 2) {
- fuji_width = 1;
- filters = 0x49494949;
- }
+ if (get2() == 2) fuji_width = 1;
break;
case 291:
case 50712: /* LinearizationTable */
@@ -8361,7 +8498,7 @@ guess_cfa_pc:
break;
case 50715: /* BlackLevelDeltaH */
case 50716: /* BlackLevelDeltaV */
- for (num=i=0; i < len; i++)
+ for (num=i=0; i < (len & 0xffff); i++)
num += getreal(type);
black += num/len + 0.5;
break;
@@ -8412,7 +8549,7 @@ guess_cfa_pc:
break;
case 50830: /* MaskedAreas */
for (i=0; i < len && i < 32; i++)
- mask[0][i] = getint(type);
+ ((int *)mask)[i] = getint(type);
black = 0;
break;
case 51009: /* OpcodeList2 */
@@ -8479,7 +8616,7 @@ int CLASS parse_tiff (int base)
void CLASS apply_tiff()
{
- int max_samp=0, raw=-1, thm=-1, i;
+ int max_samp=0, ties=0, os, ns, raw=-1, thm=-1, i;
struct jhead jh;
thumb_misc = 16;
@@ -8491,13 +8628,25 @@ void CLASS apply_tiff()
thumb_height = jh.high;
}
}
+ for (i=tiff_nifds; i--; ) {
+ if (tiff_ifd[i].shutter)
+ shutter = tiff_ifd[i].shutter;
+ tiff_ifd[i].shutter = shutter;
+ }
for (i=0; i < tiff_nifds; i++) {
if (max_samp < tiff_ifd[i].samples)
max_samp = tiff_ifd[i].samples;
if (max_samp > 3) max_samp = 3;
+ os = raw_width*raw_height;
+ ns = tiff_ifd[i].width*tiff_ifd[i].height;
+ if (tiff_bps) {
+ os *= tiff_bps;
+ ns *= tiff_ifd[i].bps;
+ }
if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3) &&
(tiff_ifd[i].width | tiff_ifd[i].height) < 0x10000 &&
- tiff_ifd[i].width*tiff_ifd[i].height > raw_width*raw_height) {
+ ns && ((ns > os && (ties = 1)) ||
+ (ns == os && shot_select == ties++))) {
raw_width = tiff_ifd[i].width;
raw_height = tiff_ifd[i].height;
tiff_bps = tiff_ifd[i].bps;
@@ -8507,9 +8656,11 @@ void CLASS apply_tiff()
tiff_samples = tiff_ifd[i].samples;
tile_width = tiff_ifd[i].tile_width;
tile_length = tiff_ifd[i].tile_length;
+ shutter = tiff_ifd[i].shutter;
raw = i;
}
}
+ if (is_raw == 1 && ties) is_raw = ties;
if (!tile_width ) tile_width = INT_MAX;
if (!tile_length) tile_length = INT_MAX;
for (i=tiff_nifds; i--; )
@@ -8560,6 +8711,12 @@ void CLASS apply_tiff()
load_flags = 1;
} else if (raw_width*raw_height*3 == tiff_ifd[raw].bytes*2) {
load_raw = &CLASS packed_load_raw;
+ if (model[0] == 'N') load_flags = 80;
+ } else if (raw_width*raw_height*3 == tiff_ifd[raw].bytes) {
+ load_raw = &CLASS nikon_yuv_load_raw;
+ gamma_curve (1/2.4, 12.92, 1, 4095);
+ memset (cblack, 0, sizeof cblack);
+ filters = 0;
} else if (raw_width*raw_height*2 == tiff_ifd[raw].bytes) {
load_raw = &CLASS unpacked_load_raw;
load_flags = 4;
@@ -8580,8 +8737,8 @@ void CLASS apply_tiff()
if (!dng_version)
if ( (tiff_samples == 3 && tiff_ifd[raw].bytes && tiff_bps != 14 &&
(tiff_compress & -16) != 32768)
- || (tiff_bps == 8 && !strcasestr(make,"Kodak") &&
- !strstr(model2,"DEBUG RAW")))
+ || (tiff_bps == 8 && strncmp(make,"Phase",5) &&
+ !strcasestr(make,"Kodak") && !strstr(model2,"DEBUG RAW")))
is_raw = 0;
for (i=0; i < tiff_nifds; i++)
if (i != raw && tiff_ifd[i].samples == max_samp &&
@@ -8722,9 +8879,7 @@ void CLASS ciff_block_1030()
bitbuf = bitbuf << 16 | (get2() ^ key[i++ & 1]);
vbits += 16;
}
- white[row][col] =
- bitbuf << (LONG_BIT - vbits) >> (LONG_BIT - bpp);
- vbits -= bpp;
+ white[row][col] = bitbuf >> (vbits -= bpp) & ~(-1 << bpp);
}
}
@@ -8930,7 +9085,7 @@ void CLASS parse_phase_one (int base)
case 0x100: flip = "0653"[data & 3]-'0'; break;
case 0x106:
for (i=0; i < 9; i++)
- romm_cam[0][i] = getreal(11);
+ ((float *)romm_cam)[i] = getreal(11);
romm_coeff (romm_cam);
break;
case 0x107:
@@ -9003,7 +9158,7 @@ void CLASS parse_fuji (int offset)
} else if (tag == 0xc000) {
c = order;
order = 0x4949;
- if ((tag = get4()) > 10000) tag = get4();
+ while ((tag = get4()) > raw_width);
width = tag;
height = get4();
order = c;
@@ -9025,7 +9180,7 @@ int CLASS parse_jpeg (int offset)
order = 0x4d4d;
len = get2() - 2;
save = ftell(ifp);
- if (mark == 0xc0 || mark == 0xc3) {
+ if (mark == 0xc0 || mark == 0xc3 || mark == 0xc9) {
fgetc(ifp);
raw_height = get2();
raw_width = get2();
@@ -9269,7 +9424,7 @@ void CLASS parse_foveon()
off += pent*8 + 24;
if ((unsigned) pent > 256) pent=256;
for (i=0; i < pent*2; i++)
- poff[0][i] = off + get4()*2;
+ ((int *)poff)[i] = off + get4()*2;
for (i=0; i < pent; i++) {
foveon_gets (poff[i][0], name, 64);
foveon_gets (poff[i][1], value, 64);
@@ -9319,6 +9474,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 9805,-2689,-1312,-5803,13064,3068,-2438,3075,8775 } },
{ "Canon EOS D60", 0, 0xfa0,
{ 6188,-1341,-890,-7168,14489,2937,-2640,3228,8483 } },
+ { "Canon EOS 5DS", 0, 0x3c96,
+ { 6250,-711,-808,-5153,12794,2636,-1249,2198,5610 } },
{ "Canon EOS 5D Mark III", 0, 0x3c80,
{ 6722,-635,-963,-4287,12460,2028,-908,2162,5668 } },
{ "Canon EOS 5D Mark II", 0, 0x3cf0,
@@ -9347,6 +9504,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 6719,-994,-925,-4408,12426,2211,-887,2129,6051 } },
{ "Canon EOS 70D", 0, 0x3bc7,
{ 7034,-804,-1014,-4420,12564,2058,-851,1994,5758 } },
+ { "Canon EOS 80D", 0, 0,
+ { 7457,-671,-937,-4849,12495,2643,-1213,2354,5492 } },
{ "Canon EOS 100D", 0, 0x350f,
{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
{ "Canon EOS 300D", 0, 0xfa0,
@@ -9367,12 +9526,22 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
{ "Canon EOS 700D", 0, 0x3c00,
{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
+ { "Canon EOS 750D", 0, 0x368e,
+ { 6362,-823,-847,-4426,12109,2616,-743,1857,5635 } },
+ { "Canon EOS 760D", 0, 0x350f,
+ { 6362,-823,-847,-4426,12109,2616,-743,1857,5635 } },
{ "Canon EOS 1000D", 0, 0xe43,
{ 6771,-1139,-977,-7818,15123,2928,-1244,1437,7533 } },
{ "Canon EOS 1100D", 0, 0x3510,
{ 6444,-904,-893,-4563,12308,2535,-903,2016,6728 } },
{ "Canon EOS 1200D", 0, 0x37c2,
{ 6461,-907,-882,-4300,12184,2378,-819,1944,5931 } },
+ { "Canon EOS 1300D", 0, 0x3510,
+ { 6939,-1016,-866,-4428,12473,2177,-1175,2178,6162 } },
+ { "Canon EOS M3", 0, 0,
+ { 6362,-823,-847,-4426,12109,2616,-743,1857,5635 } },
+ { "Canon EOS M10", 0, 0,
+ { 6400,-480,-888,-5294,13416,2047,-1296,2203,6137 } },
{ "Canon EOS M", 0, 0,
{ 6602,-841,-939,-4472,12458,2247,-975,2039,6148 } },
{ "Canon EOS-1Ds Mark III", 0, 0x3bb0,
@@ -9391,6 +9560,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 4374,3631,-1743,-7520,15212,2472,-2892,3632,8161 } },
{ "Canon EOS-1D C", 0, 0x3c4e,
{ 6847,-614,-1014,-4669,12737,2139,-1197,2488,6846 } },
+ { "Canon EOS-1D X Mark II", 0, 0,
+ { 7596,-978,-967,-4808,12571,2503,-1398,2567,5752 } },
{ "Canon EOS-1D X", 0, 0x3c4e,
{ 6847,-614,-1014,-4669,12737,2139,-1197,2488,6846 } },
{ "Canon EOS-1D", 0, 0xe20,
@@ -9419,14 +9590,20 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ -4778,9467,2172,4743,-1141,4344,-5146,9908,6077,-1566,11051,557 } },
{ "Canon PowerShot G2", 0, 0,
{ 9087,-2693,-1049,-6715,14382,2537,-2291,2819,7790 } },
+ { "Canon PowerShot G3 X", 0, 0,
+ { 9701,-3857,-921,-3149,11537,1817,-786,1817,5147 } },
{ "Canon PowerShot G3", 0, 0,
{ 9212,-2781,-1073,-6573,14189,2605,-2300,2844,7664 } },
+ { "Canon PowerShot G5 X", 0, 0,
+ { 9602,-3823,-937,-2984,11495,1675,-407,1415,5049 } },
{ "Canon PowerShot G5", 0, 0,
{ 9757,-2872,-933,-5972,13861,2301,-1622,2328,7212 } },
{ "Canon PowerShot G6", 0, 0,
{ 9877,-3775,-871,-7613,14807,3072,-1448,1305,7485 } },
{ "Canon PowerShot G7 X", 0, 0,
{ 9602,-3823,-937,-2984,11495,1675,-407,1415,5049 } },
+ { "Canon PowerShot G9 X", 0, 0,
+ { 9602,-3823,-937,-2984,11495,1675,-407,1415,5049 } },
{ "Canon PowerShot G9", 0, 0,
{ 7368,-2141,-598,-5621,13254,2625,-1418,1696,5743 } },
{ "Canon PowerShot Pro1", 0, 0,
@@ -9485,6 +9662,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 14134,-5576,-1527,-1991,10719,1273,-1158,1929,3581 } },
{ "Canon PowerShot SX220", 0, 0, /* DJC */
{ 13898,-5076,-1447,-1405,10109,1297,-244,1860,3687 } },
+ { "Canon IXUS 160", 0, 0, /* DJC */
+ { 11657,-3781,-1136,-3544,11262,2283,-160,1219,4700 } },
{ "Casio EX-S20", 0, 0, /* DJC */
{ 11634,-3924,-1128,-4968,12954,2015,-1588,2648,7206 } },
{ "Casio EX-Z750", 0, 0, /* DJC */
@@ -9499,6 +9678,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 20183,-4295,-423,-3940,15330,3985,-280,4870,9800 } },
{ "Contax N Digital", 0, 0xf1e,
{ 7777,1285,-1053,-9280,16543,2916,-3677,5679,7060 } },
+ { "DXO ONE", 0, 0,
+ { 6596,-2079,-562,-4782,13016,1933,-970,1581,5181 } },
{ "Epson R-D1", 0, 0,
{ 6827,-1878,-732,-8429,16012,2564,-704,592,7145 } },
{ "Fujifilm E550", 0, 0,
@@ -9579,23 +9760,31 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 11768,-4971,-1133,-4904,12927,2183,-480,1723,4605 } },
{ "Fujifilm X30", 0, 0,
{ 12328,-5256,-1144,-4469,12927,1675,-87,1291,4351 } },
+ { "Fujifilm X70", 0, 0,
+ { 10450,-4329,-878,-3217,11105,2421,-752,1758,6519 } },
{ "Fujifilm X-Pro1", 0, 0,
{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
+ { "Fujifilm X-Pro2", 0, 0,
+ { 11434,-4948,-1210,-3746,12042,1903,-666,1479,5235 } },
{ "Fujifilm X-A1", 0, 0,
{ 11086,-4555,-839,-3512,11310,2517,-815,1341,5940 } },
+ { "Fujifilm X-A2", 0, 0,
+ { 10763,-4560,-917,-3346,11311,2322,-475,1135,5843 } },
{ "Fujifilm X-E1", 0, 0,
{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
+ { "Fujifilm X-E2S", 0, 0,
+ { 11562,-5118,-961,-3022,11007,2311,-525,1569,6097 } },
{ "Fujifilm X-E2", 0, 0,
{ 8458,-2451,-855,-4597,12447,2407,-1475,2482,6526 } },
{ "Fujifilm X-M1", 0, 0,
{ 10413,-3996,-993,-3721,11640,2361,-733,1540,6011 } },
{ "Fujifilm X-S1", 0, 0,
{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
- { "Fujifilm X-T1", 0, 0,
+ { "Fujifilm X-T1", 0, 0, /* also X-T10 */
{ 8458,-2451,-855,-4597,12447,2407,-1475,2482,6526 } },
{ "Fujifilm XF1", 0, 0,
{ 13509,-6199,-1254,-4430,12733,1865,-331,1441,5022 } },
- { "Fujifilm XQ1", 0, 0,
+ { "Fujifilm XQ", 0, 0, /* XQ1 and XQ2 */
{ 9252,-2704,-1064,-5893,14265,1717,-1101,2341,4349 } },
{ "Imacon Ixpress", 0, 0, /* DJC */
{ 7025,-1415,-704,-5188,13765,1424,-1248,2742,6038 } },
@@ -9707,7 +9896,7 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 7911,-2167,-813,-5327,13150,2408,-1288,2483,7968 } },
{ "Nikon D3200", 0, 0xfb9,
{ 7013,-1408,-635,-5268,12902,2640,-1470,2801,7379 } },
- { "Nikon D3300", 150, 0,
+ { "Nikon D3300", 0, 0,
{ 6988,-1384,-714,-5631,13410,2447,-1485,2204,7318 } },
{ "Nikon D300", 0, 0,
{ 9030,-1992,-715,-8465,16302,2255,-2689,3217,8069 } },
@@ -9721,7 +9910,7 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 8819,-2543,-911,-9025,16928,2151,-1329,1213,8449 } },
{ "Nikon D40", 0, 0,
{ 6992,-1668,-806,-8138,15748,2543,-874,850,7897 } },
- { "Nikon D4S", 768, 0,
+ { "Nikon D4S", 0, 0,
{ 8598,-2848,-857,-5618,13606,2195,-1002,1773,7137 } },
{ "Nikon D4", 0, 0,
{ 8598,-2848,-857,-5618,13606,2195,-1002,1773,7137 } },
@@ -9733,10 +9922,16 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
{ "Nikon D5200", 0, 0,
{ 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
- { "Nikon D5300", 600, 0,
+ { "Nikon D5300", 0, 0,
{ 6988,-1384,-714,-5631,13410,2447,-1485,2204,7318 } },
+ { "Nikon D5500", 0, 0,
+ { 8821,-2938,-785,-4178,12142,2287,-824,1651,6860 } },
+ { "Nikon D500", 0, 0,
+ { 8813,-3210,-1036,-4703,12868,2021,-1054,1940,6129 } },
{ "Nikon D50", 0, 0,
{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
+ { "Nikon D5", 0, 0,
+ { 9200,-3522,-992,-5755,13803,2117,-753,1486,6338 } },
{ "Nikon D600", 0, 0x3e07,
{ 8178,-2245,-609,-4857,12394,2776,-1207,2086,7298 } },
{ "Nikon D610", 0, 0,
@@ -9747,13 +9942,15 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 8198,-2239,-724,-4871,12389,2798,-1043,2050,7181 } },
{ "Nikon D7100", 0, 0,
{ 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
- { "Nikon D750", 600, 0,
+ { "Nikon D7200", 0, 0,
+ { 8322,-3112,-1047,-6367,14342,2179,-988,1638,6394 } },
+ { "Nikon D750", 0, 0,
{ 9020,-2890,-715,-4535,12436,2348,-934,1919,7086 } },
{ "Nikon D700", 0, 0,
{ 8139,-2171,-663,-8747,16541,2295,-1925,2008,8093 } },
{ "Nikon D70", 0, 0,
{ 7732,-2422,-789,-8238,15884,2498,-859,783,7330 } },
- { "Nikon D810", 600, 0,
+ { "Nikon D810", 0, 0,
{ 9369,-3195,-791,-4488,12430,2301,-893,1796,6872 } },
{ "Nikon D800", 0, 0,
{ 7866,-2108,-555,-4869,12483,2681,-1176,2069,7501 } },
@@ -9807,10 +10004,12 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 10321,-3920,-931,-2750,11146,1824,-442,1545,5539 } },
{ "Nikon COOLPIX P7800", 200, 0,
{ 10321,-3920,-931,-2750,11146,1824,-442,1545,5539 } },
- { "Nikon 1 V3", 200, 0,
+ { "Nikon 1 V3", 0, 0,
{ 5958,-1559,-571,-4021,11453,2939,-634,1548,5087 } },
- { "Nikon 1 J4", 200, 0,
+ { "Nikon 1 J4", 0, 0,
{ 5958,-1559,-571,-4021,11453,2939,-634,1548,5087 } },
+ { "Nikon 1 J5", 0, 0,
+ { 7520,-2518,-645,-3844,12102,1945,-913,2249,6835 } },
{ "Nikon 1 S2", 200, 0,
{ 6612,-1342,-618,-3338,11055,2623,-174,1792,5075 } },
{ "Nikon 1 V2", 0, 0,
@@ -9821,6 +10020,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 6588,-1305,-693,-3277,10987,2634,-355,2016,5106 } },
{ "Nikon 1 ", 0, 0, /* J1, J2, S1, V1 */
{ 8994,-2667,-865,-4594,12324,2552,-699,1786,6260 } },
+ { "Olympus AIR A01", 0, 0,
+ { 8992,-3093,-639,-2563,10721,2122,-437,1270,5473 } },
{ "Olympus C5050", 0, 0,
{ 10508,-3124,-1273,-6079,14294,1901,-1653,2306,6237 } },
{ "Olympus C5060", 0, 0,
@@ -9891,12 +10092,18 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 7575,-2159,-571,-3722,11341,2725,-1434,2819,6271 } },
{ "Olympus E-PM2", 0, 0,
{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
- { "Olympus E-M10", 0, 0,
+ { "Olympus E-M10", 0, 0, /* also E-M10 Mark II */
{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
{ "Olympus E-M1", 0, 0,
{ 7687,-1984,-606,-4327,11928,2721,-1381,2339,6452 } },
+ { "Olympus E-M5MarkII", 0, 0,
+ { 9422,-3258,-711,-2655,10898,2015,-512,1354,5512 } },
{ "Olympus E-M5", 0, 0xfe1,
{ 8380,-2630,-639,-2887,10725,2496,-627,1427,5438 } },
+ { "Olympus PEN-F", 0, 0,
+ { 9476,-3182,-765,-2613,10958,1893,-449,1315,5268 } },
+ { "Olympus SH-2", 0, 0,
+ { 10156,-3425,-1077,-2611,11177,1624,-385,1592,5080 } },
{ "Olympus SP350", 0, 0,
{ 12078,-4836,-1069,-6671,14306,2578,-786,939,7418 } },
{ "Olympus SP3", 0, 0,
@@ -9913,13 +10120,15 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 11522,-4044,-1146,-4736,12172,2904,-988,1829,6039 } },
{ "Olympus STYLUS1", 0, 0,
{ 8360,-2420,-880,-3928,12353,1739,-1381,2416,5173 } },
+ { "Olympus TG-4", 0, 0,
+ { 11426,-4159,-1126,-2066,10678,1593,-120,1327,4998 } },
{ "Olympus XZ-10", 0, 0,
{ 9777,-3483,-925,-2886,11297,1800,-602,1663,5134 } },
{ "Olympus XZ-1", 0, 0,
{ 10901,-4095,-1074,-1141,9208,2293,-62,1417,5158 } },
{ "Olympus XZ-2", 0, 0,
{ 9777,-3483,-925,-2886,11297,1800,-602,1663,5134 } },
- { "OmniVision ov5647", 0, 0, /* DJC */
+ { "OmniVision", 0, 0, /* DJC */
{ 12782,-4059,-379,-478,9066,1413,1340,1513,5176 } },
{ "Pentax *ist DL2", 0, 0,
{ 10504,-2438,-1189,-8603,16207,2531,-1022,863,12242 } },
@@ -9947,6 +10156,12 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 8843,-2837,-625,-5025,12644,2668,-411,1234,7410 } },
{ "Pentax K-r", 0, 0,
{ 9895,-3077,-850,-5304,13035,2521,-883,1768,6936 } },
+ { "Pentax K-1", 0, 0,
+ { 8566,-2746,-1201,-3612,12204,1550,-893,1680,6264 } },
+ { "Pentax K-30", 0, 0,
+ { 8710,-2632,-1167,-3995,12301,1881,-981,1719,6535 } },
+ { "Pentax K-3 II", 0, 0,
+ { 8626,-2607,-1155,-3995,12301,1881,-1039,1822,6925 } },
{ "Pentax K-3", 0, 0,
{ 7415,-2052,-721,-5186,12788,2682,-1446,2157,6773 } },
{ "Pentax K-5 II", 0, 0,
@@ -9957,6 +10172,10 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 9142,-2947,-678,-8648,16967,1663,-2224,2898,8615 } },
{ "Pentax K-S1", 0, 0,
{ 8512,-3211,-787,-4167,11966,2487,-638,1288,6054 } },
+ { "Pentax K-S2", 0, 0,
+ { 8662,-3280,-798,-3928,11771,2444,-586,1232,6054 } },
+ { "Pentax Q-S1", 0, 0,
+ { 12995,-5593,-1107,-1879,10139,2027,-64,1233,4919 } },
{ "Pentax 645D", 0, 0x3e00,
{ 10646,-3593,-1158,-3329,11699,1831,-667,2874,6287 } },
{ "Panasonic DMC-CM1", 15, 0,
@@ -9967,6 +10186,10 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 9932,-3060,-935,-5809,13331,2753,-1267,2155,5575 } },
{ "Panasonic DMC-FZ28", 15, 0xf96,
{ 10109,-3488,-993,-5412,12812,2916,-1305,2140,5543 } },
+ { "Panasonic DMC-FZ330", 15, 0,
+ { 8378,-2798,-769,-3068,11410,1877,-538,1792,4623 } },
+ { "Panasonic DMC-FZ300", 15, 0,
+ { 8378,-2798,-769,-3068,11410,1877,-538,1792,4623 } },
{ "Panasonic DMC-FZ30", 0, 0xf94,
{ 10976,-4029,-1141,-7918,15491,2600,-1670,2071,8246 } },
{ "Panasonic DMC-FZ3", 15, 0,
@@ -10047,6 +10270,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 7798,-2562,-740,-3879,11584,2613,-1055,2248,5434 } },
{ "Panasonic DMC-G6", 15, 0xfff,
{ 8294,-2891,-651,-3869,11590,2595,-1183,2267,5352 } },
+ { "Panasonic DMC-G7", 15, 0xfff,
+ { 7610,-2780,-576,-4614,12195,2733,-1375,2393,6490 } },
{ "Panasonic DMC-GF1", 15, 0xf92,
{ 7888,-1902,-1011,-8106,16085,2099,-2353,2866,7330 } },
{ "Panasonic DMC-GF2", 15, 0xfff,
@@ -10057,6 +10282,10 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 8228,-2945,-660,-3938,11792,2430,-1094,2278,5793 } },
{ "Panasonic DMC-GF6", 15, 0,
{ 8130,-2801,-946,-3520,11289,2552,-1314,2511,5791 } },
+ { "Panasonic DMC-GF7", 15, 0,
+ { 7610,-2780,-576,-4614,12195,2733,-1375,2393,6490 } },
+ { "Panasonic DMC-GF8", 15, 0,
+ { 7610,-2780,-576,-4614,12195,2733,-1375,2393,6490 } },
{ "Panasonic DMC-GH1", 15, 0xf92,
{ 6299,-1466,-532,-6535,13852,2969,-2331,3112,5984 } },
{ "Panasonic DMC-GH2", 15, 0xf95,
@@ -10073,10 +10302,34 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 6763,-1919,-863,-3868,11515,2684,-1216,2387,5879 } },
{ "Panasonic DMC-GX7", 15, 0,
{ 7610,-2780,-576,-4614,12195,2733,-1375,2393,6490 } },
+ { "Panasonic DMC-GX8", 15, 0,
+ { 7564,-2263,-606,-3148,11239,2177,-540,1435,4853 } },
+ { "Panasonic DMC-TZ1", 15, 0,
+ { 7790,-2736,-755,-3452,11870,1769,-628,1647,4898 } },
+ { "Panasonic DMC-ZS1", 15, 0,
+ { 7790,-2736,-755,-3452,11870,1769,-628,1647,4898 } },
{ "Panasonic DMC-TZ6", 15, 0,
{ 8607,-2822,-808,-3755,11930,2049,-820,2060,5224 } },
{ "Panasonic DMC-ZS4", 15, 0,
{ 8607,-2822,-808,-3755,11930,2049,-820,2060,5224 } },
+ { "Panasonic DMC-TZ7", 15, 0,
+ { 8802,-3135,-789,-3151,11468,1904,-550,1745,4810 } },
+ { "Panasonic DMC-ZS5", 15, 0,
+ { 8802,-3135,-789,-3151,11468,1904,-550,1745,4810 } },
+ { "Panasonic DMC-TZ8", 15, 0,
+ { 8550,-2908,-842,-3195,11529,1881,-338,1603,4631 } },
+ { "Panasonic DMC-ZS6", 15, 0,
+ { 8550,-2908,-842,-3195,11529,1881,-338,1603,4631 } },
+ { "Leica S (Typ 007)", 0, 0,
+ { 6063,-2234,-231,-5210,13787,1500,-1043,2866,6997 } },
+ { "Leica X", 0, 0, /* X and X-U, both (Typ 113) */
+ { 7712,-2059,-653,-3882,11494,2726,-710,1332,5958 } },
+ { "Leica Q (Typ 116)", 0, 0,
+ { 11865,-4523,-1441,-5423,14458,935,-1587,2687,4830 } },
+ { "Leica M (Typ 262)", 0, 0,
+ { 6653,-1486,-611,-4221,13303,929,-881,2416,7226 } },
+ { "Leica SL (Typ 601)", 0, 0,
+ { 11865,-4523,-1441,-5423,14458,935,-1587,2687,4830} },
{ "Phase One H 20", 0, 0, /* DJC */
{ 1313,1855,-109,-6715,15908,808,-327,1840,6020 } },
{ "Phase One H 25", 0, 0,
@@ -10091,8 +10344,14 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
{ "Phase One P65", 0, 0,
{ 8035,435,-962,-6001,13872,2320,-1159,3065,5434 } },
+ { "Photron BC2-HD", 0, 0, /* DJC */
+ { 14603,-4122,-528,-1810,9794,2017,-297,2763,5936 } },
{ "Red One", 704, 0xffff, /* DJC */
{ 21014,-7891,-2613,-3056,12201,856,-2203,5125,8042 } },
+ { "Ricoh GR II", 0, 0,
+ { 4630,-834,-423,-4977,12805,2417,-638,1467,6115 } },
+ { "Ricoh GR", 0, 0,
+ { 3708,-543,-160,-5381,12254,3556,-1471,1929,8234 } },
{ "Samsung EX1", 0, 0x3e00,
{ 8898,-2498,-994,-3144,11328,2066,-760,1381,4576 } },
{ "Samsung EX2F", 0, 0x7ff,
@@ -10101,6 +10360,8 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 7557,-2522,-739,-4679,12949,1894,-840,1777,5311 } },
{ "Samsung NX mini", 0, 0,
{ 5222,-1196,-550,-6540,14649,2009,-1666,2819,5657 } },
+ { "Samsung NX3300", 0, 0,
+ { 8060,-2933,-761,-4504,12890,1762,-630,1489,5227 } },
{ "Samsung NX3000", 0, 0,
{ 8060,-2933,-761,-4504,12890,1762,-630,1489,5227 } },
{ "Samsung NX30", 0, 0, /* NX30, NX300, NX300M */
@@ -10117,9 +10378,11 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 10332,-3234,-1168,-6111,14639,1520,-1352,2647,8331 } },
{ "Samsung NX10", 0, 0, /* also NX100 */
{ 10332,-3234,-1168,-6111,14639,1520,-1352,2647,8331 } },
+ { "Samsung NX500", 0, 0,
+ { 10686,-4042,-1052,-3595,13238,276,-464,1259,5931 } },
{ "Samsung NX5", 0, 0,
{ 10332,-3234,-1168,-6111,14639,1520,-1352,2647,8331 } },
- { "Samsung NX1", 128, 0,
+ { "Samsung NX1", 0, 0,
{ 10686,-4042,-1052,-3595,13238,276,-464,1259,5931 } },
{ "Samsung WB2000", 0, 0xfff,
{ 12093,-3557,-1155,-1000,9534,1733,-22,1787,4576 } },
@@ -10133,17 +10396,19 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 16442,-2956,-2422,-2877,12128,750,-1136,6066,4559 } },
{ "Sony DSC-F828", 0, 0,
{ 7924,-1910,-777,-8226,15459,2998,-1517,2199,6818,-7242,11401,3481 } },
- { "Sony DSC-R1", 512, 0,
+ { "Sony DSC-R1", 0, 0,
{ 8512,-2641,-694,-8042,15670,2526,-1821,2117,7414 } },
{ "Sony DSC-V3", 0, 0,
{ 7511,-2571,-692,-7894,15088,3060,-948,1111,8128 } },
- { "Sony DSC-RX100M", 200, 0, /* M2 and M3 */
+ { "Sony DSC-RX100M", 0, 0, /* M2, M3, and M4 */
{ 6596,-2079,-562,-4782,13016,1933,-970,1581,5181 } },
- { "Sony DSC-RX100", 200, 0,
+ { "Sony DSC-RX100", 0, 0,
{ 8651,-2754,-1057,-3464,12207,1373,-568,1398,4434 } },
- { "Sony DSC-RX10", 200, 0,
+ { "Sony DSC-RX10", 0, 0, /* also RX10M2 */
{ 6679,-1825,-745,-5047,13256,1953,-1580,2422,5183 } },
- { "Sony DSC-RX1", 128, 0,
+ { "Sony DSC-RX1RM2", 0, 0,
+ { 6629,-1900,-483,-4618,12349,2550,-622,1381,6514 } },
+ { "Sony DSC-RX1", 0, 0,
{ 6344,-1612,-462,-4863,12477,2681,-865,1786,6899 } },
{ "Sony DSLR-A100", 0, 0xfeb,
{ 9437,-2811,-774,-8405,16215,2290,-710,596,7181 } },
@@ -10161,71 +10426,77 @@ void CLASS adobe_coeff (const char *make, const char *model)
{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
{ "Sony DSLR-A390", 0, 0,
{ 6038,-1484,-579,-9145,16746,2512,-875,746,7218 } },
- { "Sony DSLR-A450", 128, 0xfeb,
+ { "Sony DSLR-A450", 0, 0xfeb,
{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
- { "Sony DSLR-A580", 128, 0xfeb,
+ { "Sony DSLR-A580", 0, 0xfeb,
{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
- { "Sony DSLR-A500", 128, 0xfeb,
+ { "Sony DSLR-A500", 0, 0xfeb,
{ 6046,-1127,-278,-5574,13076,2786,-691,1419,7625 } },
- { "Sony DSLR-A5", 128, 0xfeb,
+ { "Sony DSLR-A5", 0, 0xfeb,
{ 4950,-580,-103,-5228,12542,3029,-709,1435,7371 } },
- { "Sony DSLR-A700", 128, 0,
+ { "Sony DSLR-A700", 0, 0,
{ 5775,-805,-359,-8574,16295,2391,-1943,2341,7249 } },
- { "Sony DSLR-A850", 128, 0,
+ { "Sony DSLR-A850", 0, 0,
{ 5413,-1162,-365,-5665,13098,2866,-608,1179,8440 } },
- { "Sony DSLR-A900", 128, 0,
+ { "Sony DSLR-A900", 0, 0,
{ 5209,-1072,-397,-8845,16120,2919,-1618,1803,8654 } },
- { "Sony ILCA-77M2", 128, 0,
+ { "Sony ILCA-68", 0, 0,
+ { 6435,-1903,-536,-4722,12449,2550,-663,1363,6517 } },
+ { "Sony ILCA-77M2", 0, 0,
{ 5991,-1732,-443,-4100,11989,2381,-704,1467,5992 } },
- { "Sony ILCE-7M2", 128, 0,
+ { "Sony ILCE-6300", 0, 0,
+ { 5973,-1695,-419,-3826,11797,2293,-639,1398,5789 } },
+ { "Sony ILCE-7M2", 0, 0,
{ 5271,-712,-347,-6153,13653,2763,-1601,2366,7242 } },
- { "Sony ILCE-7S", 128, 0,
+ { "Sony ILCE-7S", 0, 0, /* also ILCE-7SM2 */
{ 5838,-1430,-246,-3497,11477,2297,-748,1885,5778 } },
- { "Sony ILCE-7R", 128, 0,
+ { "Sony ILCE-7RM2", 0, 0,
+ { 6629,-1900,-483,-4618,12349,2550,-622,1381,6514 } },
+ { "Sony ILCE-7R", 0, 0,
{ 4913,-541,-202,-6130,13513,2906,-1564,2151,7183 } },
- { "Sony ILCE-7", 128, 0,
+ { "Sony ILCE-7", 0, 0,
{ 5271,-712,-347,-6153,13653,2763,-1601,2366,7242 } },
- { "Sony ILCE", 128, 0, /* 3000, 5000, 5100, 6000, and QX1 */
+ { "Sony ILCE", 0, 0, /* 3000, 5000, 5100, 6000, and QX1 */
{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
- { "Sony NEX-5N", 128, 0,
+ { "Sony NEX-5N", 0, 0,
{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
- { "Sony NEX-5R", 128, 0,
+ { "Sony NEX-5R", 0, 0,
{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
- { "Sony NEX-5T", 128, 0,
+ { "Sony NEX-5T", 0, 0,
{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
- { "Sony NEX-3N", 128, 0,
+ { "Sony NEX-3N", 0, 0,
{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
{ "Sony NEX-3", 138, 0, /* DJC */
{ 6907,-1256,-645,-4940,12621,2320,-1710,2581,6230 } },
{ "Sony NEX-5", 116, 0, /* DJC */
{ 6807,-1350,-342,-4216,11649,2567,-1089,2001,6420 } },
- { "Sony NEX-3", 128, 0, /* Adobe */
+ { "Sony NEX-3", 0, 0, /* Adobe */
{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
- { "Sony NEX-5", 128, 0, /* Adobe */
+ { "Sony NEX-5", 0, 0, /* Adobe */
{ 6549,-1550,-436,-4880,12435,2753,-854,1868,6976 } },
- { "Sony NEX-6", 128, 0,
+ { "Sony NEX-6", 0, 0,
{ 6129,-1545,-418,-4930,12490,2743,-977,1693,6615 } },
- { "Sony NEX-7", 128, 0,
+ { "Sony NEX-7", 0, 0,
{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
- { "Sony NEX", 128, 0, /* NEX-C3, NEX-F3 */
+ { "Sony NEX", 0, 0, /* NEX-C3, NEX-F3 */
{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
- { "Sony SLT-A33", 128, 0,
+ { "Sony SLT-A33", 0, 0,
{ 6069,-1221,-366,-5221,12779,2734,-1024,2066,6834 } },
- { "Sony SLT-A35", 128, 0,
+ { "Sony SLT-A35", 0, 0,
{ 5986,-1618,-415,-4557,11820,3120,-681,1404,6971 } },
- { "Sony SLT-A37", 128, 0,
+ { "Sony SLT-A37", 0, 0,
{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
- { "Sony SLT-A55", 128, 0,
+ { "Sony SLT-A55", 0, 0,
{ 5932,-1492,-411,-4813,12285,2856,-741,1524,6739 } },
- { "Sony SLT-A57", 128, 0,
+ { "Sony SLT-A57", 0, 0,
{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
- { "Sony SLT-A58", 128, 0,
+ { "Sony SLT-A58", 0, 0,
{ 5991,-1456,-455,-4764,12135,2980,-707,1425,6701 } },
- { "Sony SLT-A65", 128, 0,
+ { "Sony SLT-A65", 0, 0,
{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
- { "Sony SLT-A77", 128, 0,
+ { "Sony SLT-A77", 0, 0,
{ 5491,-1192,-363,-4951,12342,2948,-911,1722,7192 } },
- { "Sony SLT-A99", 128, 0,
+ { "Sony SLT-A99", 0, 0,
{ 6344,-1612,-462,-4863,12477,2681,-865,1786,6899 } },
};
double cam_xyz[4][3];
@@ -10239,7 +10510,7 @@ void CLASS adobe_coeff (const char *make, const char *model)
if (table[i].maximum) maximum = (ushort) table[i].maximum;
if (table[i].trans[0]) {
for (raw_color = j=0; j < 12; j++)
- cam_xyz[0][j] = table[i].trans[j] / 10000.0;
+ ((double *)cam_xyz)[j] = table[i].trans[j] / 10000.0;
cam_xyz_coeff (rgb_cam, cam_xyz);
}
break;
@@ -10382,6 +10653,9 @@ void CLASS identify()
{ 5712, 3774, 62, 20, 10, 2 },
{ 5792, 3804, 158, 51, 0, 0 },
{ 5920, 3950, 122, 80, 2, 0 },
+ { 6096, 4056, 72, 34, 0, 0 },
+ { 6288, 4056, 264, 34, 0, 0 },
+ { 8896, 5920, 160, 64, 0, 0 },
};
static const struct {
ushort id;
@@ -10394,6 +10668,7 @@ void CLASS identify()
{ 0x261, "EOS 50D" }, { 0x281, "EOS-1D Mark IV" },
{ 0x287, "EOS 60D" }, { 0x167, "EOS-1DS" },
{ 0x325, "EOS 70D" },
+ { 0x350, "EOS 80D" }, { 0x328, "EOS-1D X Mark II" },
{ 0x170, "EOS 300D" }, { 0x188, "EOS-1Ds Mark II" },
{ 0x176, "EOS 450D" }, { 0x215, "EOS-1Ds Mark III" },
{ 0x189, "EOS 350D" }, { 0x324, "EOS-1D C" },
@@ -10403,9 +10678,12 @@ void CLASS identify()
{ 0x286, "EOS 600D" }, { 0x285, "EOS 5D Mark III" },
{ 0x301, "EOS 650D" }, { 0x302, "EOS 6D" },
{ 0x326, "EOS 700D" }, { 0x250, "EOS 7D" },
+ { 0x393, "EOS 750D" }, { 0x289, "EOS 7D Mark II" },
+ { 0x347, "EOS 760D" },
{ 0x254, "EOS 1000D" },
{ 0x288, "EOS 1100D" },
- { 0x327, "EOS 1200D" },
+ { 0x327, "EOS 1200D" }, { 0x382, "Canon EOS 5DS" },
+ { 0x404, "EOS 1300D" }, { 0x401, "Canon EOS 5DS R" },
{ 0x346, "EOS 100D" },
}, sonique[] = {
{ 0x002, "DSC-R1" }, { 0x100, "DSLR-A100" },
@@ -10433,7 +10711,10 @@ void CLASS identify()
{ 0x139, "ILCE-5000" }, { 0x13d, "DSC-RX100M3" },
{ 0x13e, "ILCE-7S" }, { 0x13f, "ILCA-77M2" },
{ 0x153, "ILCE-5100" }, { 0x154, "ILCE-7M2" },
- { 0x15a, "ILCE-QX1" },
+ { 0x155, "DSC-RX100M4" },{ 0x156, "DSC-RX10M2" },
+ { 0x158, "DSC-RX1RM2" }, { 0x15a, "ILCE-QX1" },
+ { 0x15b, "ILCE-7RM2" }, { 0x15e, "ILCE-7SM2" },
+ { 0x161, "ILCA-68" }, { 0x165, "ILCE-6300" },
};
static const struct {
unsigned fsize;
@@ -10470,6 +10751,7 @@ void CLASS identify()
{ 19131120,4168,3060,92,16, 4, 1,40,0x94,0,2,"Canon","PowerShot SX220 HS" },
{ 21936096,4464,3276,25,10,73,12,40,0x16,0,2,"Canon","PowerShot SX30 IS" },
{ 24724224,4704,3504, 8,16,56, 8,40,0x94,0,2,"Canon","PowerShot A3300 IS" },
+ { 30858240,5248,3920, 8,16,56,16,40,0x94,0,2,"Canon","IXUS 160" },
{ 1976352,1632,1211, 0, 2, 0, 1, 0,0x94,0,1,"Casio","QV-2000UX" },
{ 3217760,2080,1547, 0, 0,10, 1, 0,0x94,0,1,"Casio","QV-3*00EX" },
{ 6218368,2585,1924, 0, 0, 9, 0, 0,0x94,0,1,"Casio","QV-5700" },
@@ -10511,6 +10793,7 @@ void CLASS identify()
{ 12272756,4040,3030, 2, 0, 0,13, 0,0x49,0,0,"Kodak","12MP",31556 },
{ 18000000,4000,3000, 0, 0, 0, 0, 0,0x00,0,0,"Kodak","12MP" },
{ 614400, 640, 480, 0, 3, 0, 0,64,0x94,0,0,"Kodak","KAI-0340" },
+ { 15360000,3200,2400, 0, 0, 0, 0,96,0x16,0,0,"Lenovo","A820" },
{ 3884928,1608,1207, 0, 0, 0, 0,96,0x16,0,0,"Micron","2010",3212 },
{ 1138688,1534, 986, 0, 0, 0, 0, 0,0x61,0,0,"Minolta","RD175",513 },
{ 1581060,1305, 969, 0, 0,18, 6, 6,0x1e,4,1,"Nikon","E900" },
@@ -10527,6 +10810,8 @@ void CLASS identify()
{ 4841984,2090,1544, 0, 0,22, 0, 0,0x94,7,1,"Pentax","Optio S" },
{ 6114240,2346,1737, 0, 0,22, 0, 0,0x94,7,1,"Pentax","Optio S4" },
{ 10702848,3072,2322, 0, 0, 0,21,30,0x94,0,1,"Pentax","Optio 750Z" },
+ { 4147200,1920,1080, 0, 0, 0, 0, 0,0x49,0,0,"Photron","BC2-HD" },
+ { 4151666,1920,1080, 0, 0, 0, 0, 0,0x49,0,0,"Photron","BC2-HD",8 },
{ 13248000,2208,3000, 0, 0, 0, 0,13,0x61,0,0,"Pixelink","A782" },
{ 6291456,2048,1536, 0, 0, 0, 0,96,0x61,0,0,"RoverShot","3320AF" },
{ 311696, 644, 484, 0, 0, 0, 0, 0,0x16,0,8,"ST Micro","STV680 VGA" },
@@ -10543,7 +10828,7 @@ void CLASS identify()
static const char *corp[] =
{ "AgfaPhoto", "Canon", "Casio", "Epson", "Fujifilm",
"Mamiya", "Minolta", "Motorola", "Kodak", "Konica", "Leica",
- "Nikon", "Nokia", "Olympus", "Pentax", "Phase One", "Ricoh",
+ "Nikon", "Nokia", "Olympus", "Ricoh", "Pentax", "Phase One",
"Samsung", "Sigma", "Sinar", "Sony" };
char head[32], *cp;
int hlen, flen, fsize, zero_fsize=1, i, c;
@@ -10710,7 +10995,7 @@ void CLASS identify()
parse_foveon();
else if (!memcmp (head,"CI",2))
parse_cine();
- else
+ if (make[0] == 0)
for (zero_fsize=i=0; i < sizeof table / sizeof *table; i++)
if (fsize == table[i].fsize) {
strcpy (make, table[i].make );
@@ -10805,9 +11090,10 @@ void CLASS identify()
width = 4014;
if (dng_version) {
if (filters == UINT_MAX) filters = 0;
- if (filters) is_raw = tiff_samples;
- else colors = tiff_samples;
+ if (filters) is_raw *= tiff_samples;
+ else colors = tiff_samples;
switch (tiff_compress) {
+ case 0:
case 1: load_raw = &CLASS packed_dng_load_raw; break;
case 7: load_raw = &CLASS lossless_dng_load_raw; break;
case 34892: load_raw = &CLASS lossy_dng_load_raw; break;
@@ -10859,6 +11145,8 @@ void CLASS identify()
top_margin = filters = 0;
strcpy (model,"C603");
}
+ if (!strcmp(make,"Sony") && raw_width > 3888)
+ black = 128 << (tiff_bps - 12);
if (is_foveon) {
if (height*2 < width) pixel_aspect = 0.5;
if (height > width) pixel_aspect = 2;
@@ -10869,7 +11157,14 @@ void CLASS identify()
case 3344: width -= 66;
case 3872: width -= 6;
}
- if (height > width) SWAP(height,width);
+ if (height > width) {
+ SWAP(height,width);
+ SWAP(raw_height,raw_width);
+ }
+ if (width == 7200 && height == 3888) {
+ raw_width = width = 6480;
+ raw_height = height = 4320;
+ }
filters = 0;
tiff_samples = colors = 3;
load_raw = &CLASS canon_sraw_load_raw;
@@ -11045,7 +11340,7 @@ canon_a5:
top_margin = (raw_height - height) >> 2 << 1;
left_margin = (raw_width - width ) >> 2 << 1;
if (width == 2848 || width == 3664) filters = 0x16161616;
- if (width == 4032 || width == 4952) left_margin = 0;
+ if (width == 4032 || width == 4952 || width == 6032) left_margin = 0;
if (width == 3328 && (width -= 66)) left_margin = 34;
if (width == 4936) left_margin = 4;
if (!strcmp(model,"HS50EXR") ||
@@ -11056,7 +11351,7 @@ canon_a5:
}
if (fuji_layout) raw_width *= is_raw;
if (filters == 9)
- FORC(36) xtrans[0][c] =
+ FORC(36) ((char *)xtrans)[c] =
xtrans_abs[(c/6+top_margin) % 6][(c+left_margin) % 6];
} else if (!strcmp(model,"KD-400Z")) {
height = 1712;
@@ -11128,6 +11423,7 @@ konica_400z:
filters = 0x49494949;
} else if (!strcmp(make,"Samsung") && raw_width == 6496) {
filters = 0x61616161;
+ black = 1 << (tiff_bps - 7);
} else if (!strcmp(model,"EX1")) {
order = 0x4949;
height -= 20;
@@ -11268,6 +11564,7 @@ konica_400z:
if (exif_cfa) filters = exif_cfa;
if (width == 4100) width -= 4;
if (width == 4080) width -= 24;
+ if (width == 9280) { width -= 6; height -= 6; }
if (load_raw == &CLASS unpacked_load_raw)
load_flags = 4;
tiff_bps = 12;
@@ -11286,6 +11583,8 @@ konica_400z:
thumb_length = flen - (thumb_offset = 0xa39800);
thumb_height = 480;
thumb_width = 640;
+ } else if (!strcmp(model,"TG-4")) {
+ width -= 16;
}
} else if (!strcmp(model,"N Digital")) {
height = 2047;
@@ -11313,16 +11612,29 @@ konica_400z:
order = 0x4d4d;
} else if (!strcmp(make,"Sony") && raw_width == 4288) {
width -= 32;
+ } else if (!strcmp(make,"Sony") && raw_width == 4600) {
+ if (!strcmp(model,"DSLR-A350"))
+ height -= 4;
+ black = 0;
} else if (!strcmp(make,"Sony") && raw_width == 4928) {
if (height < 3280) width -= 8;
} else if (!strcmp(make,"Sony") && raw_width == 5504) {
width -= height > 3664 ? 8 : 32;
+ if (!strncmp(model,"DSC",3))
+ black = 200 << (tiff_bps - 12);
} else if (!strcmp(make,"Sony") && raw_width == 6048) {
width -= 24;
if (strstr(model,"RX1") || strstr(model,"A99"))
width -= 6;
} else if (!strcmp(make,"Sony") && raw_width == 7392) {
width -= 30;
+ } else if (!strcmp(make,"Sony") && raw_width == 8000) {
+ width -= 32;
+ if (!strncmp(model,"DSC",3)) {
+ tiff_bps = 14;
+ load_raw = &CLASS unpacked_load_raw;
+ black = 512;
+ }
} else if (!strcmp(model,"DSLR-A100")) {
if (width == 3880) {
height--;
@@ -11334,8 +11646,6 @@ konica_400z:
load_flags = 2;
}
filters = 0x61616161;
- } else if (!strcmp(model,"DSLR-A350")) {
- height -= 4;
} else if (!strcmp(model,"PIXL")) {
height -= top_margin = 4;
width -= left_margin = 32;
@@ -11400,6 +11710,7 @@ bw: colors = 1;
width = 768;
data_offset = 1152;
load_raw = &CLASS kodak_radc_load_raw;
+ tiff_bps = 12;
} else if (strstr(model,"DC50")) {
strcpy (model, "DC50");
height = 512;
@@ -11478,7 +11789,7 @@ dng_skip:
if (raw_color) adobe_coeff ("Apple","Quicktake");
if (fuji_width) {
fuji_width = width >> !fuji_layout;
- if (~fuji_width & 1) filters = 0x49494949;
+ filters = fuji_width & 1 ? 0x94949494 : 0x49494949;
width = (height >> fuji_layout) + fuji_width;
height = width - 1;
pixel_aspect = 1;
@@ -11592,10 +11903,14 @@ void CLASS convert_to_rgb()
{ { 0.529317, 0.330092, 0.140588 },
{ 0.098368, 0.873465, 0.028169 },
{ 0.016879, 0.117663, 0.865457 } };
+ static const double aces_rgb[3][3] =
+ { { 0.432996, 0.375380, 0.189317 },
+ { 0.089427, 0.816523, 0.102989 },
+ { 0.019165, 0.118150, 0.941914 } };
static const double (*out_rgb[])[3] =
- { rgb_rgb, adobe_rgb, wide_rgb, prophoto_rgb, xyz_rgb };
+ { rgb_rgb, adobe_rgb, wide_rgb, prophoto_rgb, xyz_rgb, aces_rgb };
static const char *name[] =
- { "sRGB", "Adobe RGB (1998)", "WideGamut D65", "ProPhoto D65", "XYZ" };
+ { "sRGB", "Adobe RGB (1998)", "WideGamut D65", "ProPhoto D65", "XYZ", "ACES" };
static const unsigned phead[] =
{ 1024, 0, 0x2100000, 0x6d6e7472, 0x52474220, 0x58595a20, 0, 0, 0,
0x61637370, 0, 0, 0x6e6f6e65, 0, 0, 0, 0, 0xf6d6, 0x10000, 0xd32d };
@@ -11616,7 +11931,7 @@ void CLASS convert_to_rgb()
gamma_curve (gamm[0], gamm[1], 0, 0);
memcpy (out_cam, rgb_cam, sizeof out_cam);
raw_color |= colors == 1 || document_mode ||
- output_color < 1 || output_color > 5;
+ output_color < 1 || output_color > 6;
if (!raw_color) {
oprof = (unsigned *) calloc (phead[0], 1);
merror (oprof, "convert_to_rgb()");
@@ -11779,21 +12094,25 @@ struct tiff_hdr {
char desc[512], make[64], model[64], soft[32], date[20], artist[64];
};
-void CLASS tiff_set (ushort *ntag,
+void CLASS tiff_set (struct tiff_hdr *th, ushort *ntag,
ushort tag, ushort type, int count, int val)
{
struct tiff_tag *tt;
int c;
tt = (struct tiff_tag *)(ntag+1) + (*ntag)++;
- tt->tag = tag;
- tt->type = type;
- tt->count = count;
- if (type < 3 && count <= 4)
+ tt->val.i = val;
+ if (type == 1 && count <= 4)
FORC(4) tt->val.c[c] = val >> (c << 3);
- else if (type == 3 && count <= 2)
+ else if (type == 2) {
+ count = strnlen((char *)th + val, count-1) + 1;
+ if (count <= 4)
+ FORC(4) tt->val.c[c] = ((char *)th)[val+c];
+ } else if (type == 3 && count <= 2)
FORC(2) tt->val.s[c] = val >> (c << 4);
- else tt->val.i = val;
+ tt->count = count;
+ tt->type = type;
+ tt->tag = tag;
}
#define TOFF(ptr) ((char *)(&(ptr)) - (char *)th)
@@ -11807,55 +12126,6 @@ void CLASS tiff_head (struct tiff_hdr *th, int full)
th->order = htonl(0x4d4d4949) >> 16;
th->magic = 42;
th->ifd = 10;
- if (full) {
- tiff_set (&th->ntag, 254, 4, 1, 0);
- tiff_set (&th->ntag, 256, 4, 1, width);
- tiff_set (&th->ntag, 257, 4, 1, height);
- tiff_set (&th->ntag, 258, 3, colors, output_bps);
- if (colors > 2)
- th->tag[th->ntag-1].val.i = TOFF(th->bps);
- FORC4 th->bps[c] = output_bps;
- tiff_set (&th->ntag, 259, 3, 1, 1);
- tiff_set (&th->ntag, 262, 3, 1, 1 + (colors > 1));
- }
- tiff_set (&th->ntag, 270, 2, 512, TOFF(th->desc));
- tiff_set (&th->ntag, 271, 2, 64, TOFF(th->make));
- tiff_set (&th->ntag, 272, 2, 64, TOFF(th->model));
- if (full) {
- if (oprof) psize = ntohl(oprof[0]);
- tiff_set (&th->ntag, 273, 4, 1, sizeof *th + psize);
- tiff_set (&th->ntag, 277, 3, 1, colors);
- tiff_set (&th->ntag, 278, 4, 1, height);
- tiff_set (&th->ntag, 279, 4, 1, height*width*colors*output_bps/8);
- } else
- tiff_set (&th->ntag, 274, 3, 1, "12435867"[flip]-'0');
- tiff_set (&th->ntag, 282, 5, 1, TOFF(th->rat[0]));
- tiff_set (&th->ntag, 283, 5, 1, TOFF(th->rat[2]));
- tiff_set (&th->ntag, 284, 3, 1, 1);
- tiff_set (&th->ntag, 296, 3, 1, 2);
- tiff_set (&th->ntag, 305, 2, 32, TOFF(th->soft));
- tiff_set (&th->ntag, 306, 2, 20, TOFF(th->date));
- tiff_set (&th->ntag, 315, 2, 64, TOFF(th->artist));
- tiff_set (&th->ntag, 34665, 4, 1, TOFF(th->nexif));
- if (psize) tiff_set (&th->ntag, 34675, 7, psize, sizeof *th);
- tiff_set (&th->nexif, 33434, 5, 1, TOFF(th->rat[4]));
- tiff_set (&th->nexif, 33437, 5, 1, TOFF(th->rat[6]));
- tiff_set (&th->nexif, 34855, 3, 1, iso_speed);
- tiff_set (&th->nexif, 37386, 5, 1, TOFF(th->rat[8]));
- if (gpsdata[1]) {
- tiff_set (&th->ntag, 34853, 4, 1, TOFF(th->ngps));
- tiff_set (&th->ngps, 0, 1, 4, 0x202);
- tiff_set (&th->ngps, 1, 2, 2, gpsdata[29]);
- tiff_set (&th->ngps, 2, 5, 3, TOFF(th->gps[0]));
- tiff_set (&th->ngps, 3, 2, 2, gpsdata[30]);
- tiff_set (&th->ngps, 4, 5, 3, TOFF(th->gps[6]));
- tiff_set (&th->ngps, 5, 1, 1, gpsdata[31]);
- tiff_set (&th->ngps, 6, 5, 1, TOFF(th->gps[18]));
- tiff_set (&th->ngps, 7, 5, 3, TOFF(th->gps[12]));
- tiff_set (&th->ngps, 18, 2, 12, TOFF(th->gps[20]));
- tiff_set (&th->ngps, 29, 2, 12, TOFF(th->gps[23]));
- memcpy (th->gps, gpsdata, sizeof th->gps);
- }
th->rat[0] = th->rat[2] = 300;
th->rat[1] = th->rat[3] = 1;
FORC(6) th->rat[4+c] = 1000000;
@@ -11870,6 +12140,55 @@ void CLASS tiff_head (struct tiff_hdr *th, int full)
sprintf (th->date, "%04d:%02d:%02d %02d:%02d:%02d",
t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec);
strncpy (th->artist, artist, 64);
+ if (full) {
+ tiff_set (th, &th->ntag, 254, 4, 1, 0);
+ tiff_set (th, &th->ntag, 256, 4, 1, width);
+ tiff_set (th, &th->ntag, 257, 4, 1, height);
+ tiff_set (th, &th->ntag, 258, 3, colors, output_bps);
+ if (colors > 2)
+ th->tag[th->ntag-1].val.i = TOFF(th->bps);
+ FORC4 th->bps[c] = output_bps;
+ tiff_set (th, &th->ntag, 259, 3, 1, 1);
+ tiff_set (th, &th->ntag, 262, 3, 1, 1 + (colors > 1));
+ }
+ tiff_set (th, &th->ntag, 270, 2, 512, TOFF(th->desc));
+ tiff_set (th, &th->ntag, 271, 2, 64, TOFF(th->make));
+ tiff_set (th, &th->ntag, 272, 2, 64, TOFF(th->model));
+ if (full) {
+ if (oprof) psize = ntohl(oprof[0]);
+ tiff_set (th, &th->ntag, 273, 4, 1, sizeof *th + psize);
+ tiff_set (th, &th->ntag, 277, 3, 1, colors);
+ tiff_set (th, &th->ntag, 278, 4, 1, height);
+ tiff_set (th, &th->ntag, 279, 4, 1, height*width*colors*output_bps/8);
+ } else
+ tiff_set (th, &th->ntag, 274, 3, 1, "12435867"[flip]-'0');
+ tiff_set (th, &th->ntag, 282, 5, 1, TOFF(th->rat[0]));
+ tiff_set (th, &th->ntag, 283, 5, 1, TOFF(th->rat[2]));
+ tiff_set (th, &th->ntag, 284, 3, 1, 1);
+ tiff_set (th, &th->ntag, 296, 3, 1, 2);
+ tiff_set (th, &th->ntag, 305, 2, 32, TOFF(th->soft));
+ tiff_set (th, &th->ntag, 306, 2, 20, TOFF(th->date));
+ tiff_set (th, &th->ntag, 315, 2, 64, TOFF(th->artist));
+ tiff_set (th, &th->ntag, 34665, 4, 1, TOFF(th->nexif));
+ if (psize) tiff_set (th, &th->ntag, 34675, 7, psize, sizeof *th);
+ tiff_set (th, &th->nexif, 33434, 5, 1, TOFF(th->rat[4]));
+ tiff_set (th, &th->nexif, 33437, 5, 1, TOFF(th->rat[6]));
+ tiff_set (th, &th->nexif, 34855, 3, 1, iso_speed);
+ tiff_set (th, &th->nexif, 37386, 5, 1, TOFF(th->rat[8]));
+ if (gpsdata[1]) {
+ tiff_set (th, &th->ntag, 34853, 4, 1, TOFF(th->ngps));
+ tiff_set (th, &th->ngps, 0, 1, 4, 0x202);
+ tiff_set (th, &th->ngps, 1, 2, 2, gpsdata[29]);
+ tiff_set (th, &th->ngps, 2, 5, 3, TOFF(th->gps[0]));
+ tiff_set (th, &th->ngps, 3, 2, 2, gpsdata[30]);
+ tiff_set (th, &th->ngps, 4, 5, 3, TOFF(th->gps[6]));
+ tiff_set (th, &th->ngps, 5, 1, 1, gpsdata[31]);
+ tiff_set (th, &th->ngps, 6, 5, 1, TOFF(th->gps[18]));
+ tiff_set (th, &th->ngps, 7, 5, 3, TOFF(th->gps[12]));
+ tiff_set (th, &th->ngps, 18, 2, 12, TOFF(th->gps[20]));
+ tiff_set (th, &th->ngps, 29, 2, 12, TOFF(th->gps[23]));
+ memcpy (th->gps, gpsdata, sizeof th->gps);
+ }
}
void CLASS jpeg_thumb()
@@ -11990,7 +12309,7 @@ int CLASS main (int argc, const char **argv)
puts(_("-n <num> Set threshold for wavelet denoising"));
puts(_("-H [0-9] Highlight mode (0=clip, 1=unclip, 2=blend, 3+=rebuild)"));
puts(_("-t [0-7] Flip image (0=none, 3=180, 5=90CCW, 6=90CW)"));
- puts(_("-o [0-5] Output colorspace (raw,sRGB,Adobe,Wide,ProPhoto,XYZ)"));
+ puts(_("-o [0-6] Output colorspace (raw,sRGB,Adobe,Wide,ProPhoto,XYZ,ACES)"));
#ifndef NO_LCMS
puts(_("-o <file> Apply output ICC profile from file"));
puts(_("-p <file> Apply camera ICC profile from file or \"embed\""));
@@ -12369,6 +12688,664 @@ cleanup:
@
+1.476
+log
+@Support the Blackmagic URSA, Nokia N9, and Photron BC2-HD.
+Support the Canon EOS 750D, 760D, EOS M, and sRAW/mRAW for EOS 5DS R.
+When there's a tie for largest raw image, "-s" says which to decode.
+Fixed null-byte warnings in TIFF output.
+@
+text
+@d3 1
+a3 1
+ Copyright 1997-2015 by Dave Coffin, dcoffin a cybercom o net
+d26 1
+a26 1
+#define DCRAW_VERSION "9.26"
+d856 2
+d859 1
+a859 1
+ if (jh->clrs > 6 || !jh->huff[0]) return 0;
+d1772 1
+a1772 1
+ i = (pixel[col] << 2) - ph1.black
+d2864 2
+d5314 1
+a5314 1
+ FORC4 cblack[c ^ c >> 1] = get2() >> (14-tiff_ifd[2].bps);
+d5425 1
+a5425 1
+ if (tag == 0x2020)
+d5739 2
+d6074 1
+a6074 1
+ for (num=i=0; i < len; i++)
+d6215 4
+d6313 2
+a6314 2
+ || (tiff_bps == 8 && !strcasestr(make,"Kodak") &&
+ !strstr(model2,"DEBUG RAW")))
+d6734 1
+a6734 1
+ if ((tag = get4()) > 10000) tag = get4();
+d6756 1
+a6756 1
+ if (mark == 0xc0 || mark == 0xc3) {
+d7080 2
+d7112 2
+d7116 2
+d7136 2
+d7166 2
+d7170 2
+d7178 2
+d7238 2
+d7254 2
+d7336 2
+d7340 2
+d7348 2
+d7356 1
+a7356 1
+ { "Fujifilm X-T1", 0, 0,
+d7502 2
+d7506 2
+d7584 2
+a7585 2
+ { "Nikon 1 J5", 0, 0, /* DJC */
+ { 2621,-856,500,-4471,8761,5711,-1321,2644,11945 } },
+d7596 2
+d7668 1
+a7668 1
+ { "Olympus E-M10", 0, 0,
+d7676 2
+d7732 6
+d7748 2
+a7749 2
+ { "Pentax K-S2", 0, 0, /* DJC */
+ { 5322,-2195,41,-3689,8902,4788,-858,1831,7969 } },
+d7762 4
+d7846 2
+d7860 2
+d7878 6
+d7892 14
+d7924 4
+d7936 2
+d7972 1
+a7972 1
+ { "Sony DSC-R1", 512, 0,
+d7976 1
+a7976 1
+ { "Sony DSC-RX100M", 200, 0, /* M2 and M3 */
+d7978 1
+a7978 1
+ { "Sony DSC-RX100", 200, 0,
+d7980 1
+a7980 1
+ { "Sony DSC-RX10", 200, 0,
+d7982 3
+a7984 1
+ { "Sony DSC-RX1", 128, 0,
+d8002 1
+a8002 1
+ { "Sony DSLR-A450", 128, 0xfeb,
+d8004 1
+a8004 1
+ { "Sony DSLR-A580", 128, 0xfeb,
+d8006 1
+a8006 1
+ { "Sony DSLR-A500", 128, 0xfeb,
+d8008 1
+a8008 1
+ { "Sony DSLR-A5", 128, 0xfeb,
+d8010 1
+a8010 1
+ { "Sony DSLR-A700", 128, 0,
+d8012 1
+a8012 1
+ { "Sony DSLR-A850", 128, 0,
+d8014 1
+a8014 1
+ { "Sony DSLR-A900", 128, 0,
+d8016 3
+a8018 1
+ { "Sony ILCA-77M2", 128, 0,
+d8020 3
+a8022 1
+ { "Sony ILCE-7M2", 128, 0,
+d8024 1
+a8024 1
+ { "Sony ILCE-7S", 128, 0,
+d8026 3
+a8028 1
+ { "Sony ILCE-7R", 128, 0,
+d8030 1
+a8030 1
+ { "Sony ILCE-7", 128, 0,
+d8032 1
+a8032 1
+ { "Sony ILCE", 128, 0, /* 3000, 5000, 5100, 6000, and QX1 */
+d8034 1
+a8034 1
+ { "Sony NEX-5N", 128, 0,
+d8036 1
+a8036 1
+ { "Sony NEX-5R", 128, 0,
+d8038 1
+a8038 1
+ { "Sony NEX-5T", 128, 0,
+d8040 1
+a8040 1
+ { "Sony NEX-3N", 128, 0,
+d8046 1
+a8046 1
+ { "Sony NEX-3", 128, 0, /* Adobe */
+d8048 1
+a8048 1
+ { "Sony NEX-5", 128, 0, /* Adobe */
+d8050 1
+a8050 1
+ { "Sony NEX-6", 128, 0,
+d8052 1
+a8052 1
+ { "Sony NEX-7", 128, 0,
+d8054 1
+a8054 1
+ { "Sony NEX", 128, 0, /* NEX-C3, NEX-F3 */
+d8056 1
+a8056 1
+ { "Sony SLT-A33", 128, 0,
+d8058 1
+a8058 1
+ { "Sony SLT-A35", 128, 0,
+d8060 1
+a8060 1
+ { "Sony SLT-A37", 128, 0,
+d8062 1
+a8062 1
+ { "Sony SLT-A55", 128, 0,
+d8064 1
+a8064 1
+ { "Sony SLT-A57", 128, 0,
+d8066 1
+a8066 1
+ { "Sony SLT-A58", 128, 0,
+d8068 1
+a8068 1
+ { "Sony SLT-A65", 128, 0,
+d8070 1
+a8070 1
+ { "Sony SLT-A77", 128, 0,
+d8072 1
+a8072 1
+ { "Sony SLT-A99", 128, 0,
+d8230 1
+d8244 1
+d8258 2
+a8259 1
+ { 0x327, "EOS 1200D" },
+d8287 4
+a8290 1
+ { 0x15a, "ILCE-QX1" },
+d8327 1
+d8404 1
+a8404 1
+ "Nikon", "Nokia", "Olympus", "Pentax", "Phase One", "Ricoh",
+d8721 2
+d8916 1
+a8916 1
+ if (width == 4032 || width == 4952) left_margin = 0;
+d9159 2
+d9188 4
+d9196 2
+d9204 7
+a9221 2
+ } else if (!strcmp(model,"DSLR-A350")) {
+ height -= 4;
+d9286 1
+d9479 4
+d9484 1
+a9484 1
+ { rgb_rgb, adobe_rgb, wide_rgb, prophoto_rgb, xyz_rgb };
+d9486 1
+a9486 1
+ { "sRGB", "Adobe RGB (1998)", "WideGamut D65", "ProPhoto D65", "XYZ" };
+d9507 1
+a9507 1
+ output_color < 1 || output_color > 5;
+d9885 1
+a9885 1
+ puts(_("-o [0-5] Output colorspace (raw,sRGB,Adobe,Wide,ProPhoto,XYZ)"));
+@
+
+
+1.475
+log
+@Use typecasts instead of [0] to flatten multi-dimensional arrays.
+@
+text
+@d26 1
+a26 1
+#define DCRAW_VERSION "9.25"
+a91 9
+#ifdef LJPEG_DECODE
+#error Please compile dcraw.c by itself.
+#error Do not link it with ljpeg_decode.
+#endif
+
+#ifndef LONG_BIT
+#define LONG_BIT (8 * sizeof (long))
+#endif
+
+d152 1
+d174 1
+a174 1
+#define CLIP(x) LIM(x,0,65535)
+a807 4
+/*
+ Not a full implementation of Lossless JPEG, just
+ enough to decode Canon, Kodak and Adobe DNG images.
+ */
+d809 2
+a810 2
+ int bits, high, wide, clrs, sraw, psv, restart, vpred[6];
+ ushort *huff[6], *free[4], *row;
+d815 1
+a815 1
+ int c, tag, len;
+d821 1
+a821 2
+ fread (data, 2, 1, ifp);
+ if (data[1] != 0xd8) return 0;
+d823 1
+a823 1
+ fread (data, 2, 2, ifp);
+d831 1
+d833 1
+d842 1
+a842 1
+ for (dp = data; dp < data+len && (c = *dp++) < 4; )
+d849 3
+d858 1
+a858 1
+ FORC(5) if (!jh->huff[c+1]) jh->huff[c+1] = jh->huff[c];
+d1037 1
+a1037 1
+ if (is_raw == 2 && shot_select) (*rp)++;
+d1041 1
+a1041 1
+ *rp += is_raw;
+d1048 37
+a1084 1
+ if (is_raw == 2 && shot_select) (*rp)--;
+d1089 1
+a1089 1
+ unsigned save, trow=0, tcol=0, jwide, jrow, jcol, row, col;
+d1100 26
+a1125 8
+ jwide /= is_raw;
+ for (row=col=jrow=0; jrow < jh.high; jrow++) {
+ rp = ljpeg_row (jrow, &jh);
+ for (jcol=0; jcol < jwide; jcol++) {
+ adobe_copy_pixel (trow+row, tcol+col, &rp);
+ if (++col >= tile_width || col >= raw_width)
+ row += 1 + (col = 0);
+ }
+d5340 2
+a5341 1
+ goto get2_rggb;
+d5375 1
+a5375 1
+ goto get2_rggb;
+a5431 1
+get2_rggb:
+d5433 5
+a5437 3
+ i = len >> 3 == 164 || len == 1506 ? 112:22;
+ fseek (ifp, i, SEEK_CUR);
+ FORC4 sraw_mul[c ^ (c >> 1)] = get2();
+d5490 2
+a5491 1
+ case 33434: shutter = getreal(type); break;
+d5497 1
+d5896 1
+a5896 1
+ shutter = getreal(type);
+d6024 8
+d6045 1
+a6045 4
+ if (get2() == 2) {
+ fuji_width = 1;
+ filters = 0x49494949;
+ }
+d6186 1
+a6186 1
+ int max_samp=0, raw=-1, thm=-1, i;
+d6198 5
+d6207 2
+d6211 2
+a6212 1
+ tiff_ifd[i].width*tiff_ifd[i].height > raw_width*raw_height) {
+d6222 1
+d6226 1
+d6445 1
+a6445 3
+ white[row][col] =
+ bitbuf << (LONG_BIT - vbits) >> (LONG_BIT - bpp);
+ vbits -= bpp;
+d7040 2
+a7041 2
+ { "Canon EOS 5DS", 0, 0x3c96, /* DJC */
+ { 6885,-753,-856,-4416,11752,2665,-1266,2393,5468 } },
+d7090 4
+d7100 2
+d7480 2
+a7481 2
+ { "Nikon D7200", 0, 0, /* DJC */
+ { 6111,-2759,-358,-5108,10766,4343,-769,1691,8030 } },
+d7636 2
+d7654 2
+d7700 4
+d7844 2
+d7872 2
+a7873 2
+ { "Samsung NX500", 0, 0, /* DJC */
+ { 10196,-4532,-272,-3888,11489,2400,-1203,2424,9173 } },
+d8139 1
+d8162 2
+d8289 2
+d8474 1
+a8474 1
+ else
+d8569 2
+a8570 2
+ if (filters) is_raw = tiff_samples;
+ else colors = tiff_samples;
+d8572 1
+d8638 4
+d9252 1
+a9252 1
+ if (~fuji_width & 1) filters = 0x49494949;
+d9553 1
+a9553 1
+void CLASS tiff_set (ushort *ntag,
+d9560 2
+a9561 4
+ tt->tag = tag;
+ tt->type = type;
+ tt->count = count;
+ if (type < 3 && count <= 4)
+d9563 5
+a9567 1
+ else if (type == 3 && count <= 2)
+d9569 3
+a9571 1
+ else tt->val.i = val;
+a9584 49
+ if (full) {
+ tiff_set (&th->ntag, 254, 4, 1, 0);
+ tiff_set (&th->ntag, 256, 4, 1, width);
+ tiff_set (&th->ntag, 257, 4, 1, height);
+ tiff_set (&th->ntag, 258, 3, colors, output_bps);
+ if (colors > 2)
+ th->tag[th->ntag-1].val.i = TOFF(th->bps);
+ FORC4 th->bps[c] = output_bps;
+ tiff_set (&th->ntag, 259, 3, 1, 1);
+ tiff_set (&th->ntag, 262, 3, 1, 1 + (colors > 1));
+ }
+ tiff_set (&th->ntag, 270, 2, 512, TOFF(th->desc));
+ tiff_set (&th->ntag, 271, 2, 64, TOFF(th->make));
+ tiff_set (&th->ntag, 272, 2, 64, TOFF(th->model));
+ if (full) {
+ if (oprof) psize = ntohl(oprof[0]);
+ tiff_set (&th->ntag, 273, 4, 1, sizeof *th + psize);
+ tiff_set (&th->ntag, 277, 3, 1, colors);
+ tiff_set (&th->ntag, 278, 4, 1, height);
+ tiff_set (&th->ntag, 279, 4, 1, height*width*colors*output_bps/8);
+ } else
+ tiff_set (&th->ntag, 274, 3, 1, "12435867"[flip]-'0');
+ tiff_set (&th->ntag, 282, 5, 1, TOFF(th->rat[0]));
+ tiff_set (&th->ntag, 283, 5, 1, TOFF(th->rat[2]));
+ tiff_set (&th->ntag, 284, 3, 1, 1);
+ tiff_set (&th->ntag, 296, 3, 1, 2);
+ tiff_set (&th->ntag, 305, 2, 32, TOFF(th->soft));
+ tiff_set (&th->ntag, 306, 2, 20, TOFF(th->date));
+ tiff_set (&th->ntag, 315, 2, 64, TOFF(th->artist));
+ tiff_set (&th->ntag, 34665, 4, 1, TOFF(th->nexif));
+ if (psize) tiff_set (&th->ntag, 34675, 7, psize, sizeof *th);
+ tiff_set (&th->nexif, 33434, 5, 1, TOFF(th->rat[4]));
+ tiff_set (&th->nexif, 33437, 5, 1, TOFF(th->rat[6]));
+ tiff_set (&th->nexif, 34855, 3, 1, iso_speed);
+ tiff_set (&th->nexif, 37386, 5, 1, TOFF(th->rat[8]));
+ if (gpsdata[1]) {
+ tiff_set (&th->ntag, 34853, 4, 1, TOFF(th->ngps));
+ tiff_set (&th->ngps, 0, 1, 4, 0x202);
+ tiff_set (&th->ngps, 1, 2, 2, gpsdata[29]);
+ tiff_set (&th->ngps, 2, 5, 3, TOFF(th->gps[0]));
+ tiff_set (&th->ngps, 3, 2, 2, gpsdata[30]);
+ tiff_set (&th->ngps, 4, 5, 3, TOFF(th->gps[6]));
+ tiff_set (&th->ngps, 5, 1, 1, gpsdata[31]);
+ tiff_set (&th->ngps, 6, 5, 1, TOFF(th->gps[18]));
+ tiff_set (&th->ngps, 7, 5, 3, TOFF(th->gps[12]));
+ tiff_set (&th->ngps, 18, 2, 12, TOFF(th->gps[20]));
+ tiff_set (&th->ngps, 29, 2, 12, TOFF(th->gps[23]));
+ memcpy (th->gps, gpsdata, sizeof th->gps);
+ }
+d9599 49
+@
+
+
+1.474
+log
+@Updated color matrices, support the Canon EOS 5DS.
+@
+text
+@d2175 1
+a2175 1
+ huff[0][s++] = src[i] << 8 | (uchar) src[i+1];
+d2180 1
+a2180 1
+ buf[0][0][i] = 2048;
+d2189 1
+a2189 1
+ buf[c][0][i] = (buf[c][0][i] * val + x) >> s;
+d2764 1
+a2764 1
+ FORC(6) lent[0][c] = row < 2 ? 7:4;
+d2921 1
+a2921 1
+ nseg = fgetc(ifp);
+d2924 1
+a2924 1
+ seg[0][i] = get4() + data_offset*(i & 1);
+d3387 2
+a3388 2
+ ddft[0][0][i] = ddft[1][0][i] +
+ row / (height-1.0) * (ddft[2][0][i] - ddft[1][0][i]);
+d3433 2
+a3434 2
+ ddft[0][0][i] = ddft[1][0][i] +
+ row / (height-1.0) * (ddft[2][0][i] - ddft[1][0][i]);
+d4214 1
+a4214 1
+ if (!(val = image[0][i])) continue;
+d4220 1
+a4220 1
+ image[0][i] = CLIP(val);
+d5532 1
+a5532 1
+ romm_cam[0][i] = int_to_float(get4());
+d5537 1
+a5537 1
+ fscanf (ifp, "%f", &romm_cam[0][i]);
+d5827 1
+a5827 1
+ FORC(36) xtrans[0][c] = fgetc(ifp) & 3;
+d6064 1
+a6064 1
+ mask[0][i] = getint(type);
+d6588 1
+a6588 1
+ romm_cam[0][i] = getreal(11);
+d6927 1
+a6927 1
+ poff[0][i] = off + get4()*2;
+d7917 1
+a7917 1
+ cam_xyz[0][j] = table[i].trans[j] / 10000.0;
+d8739 1
+a8739 1
+ FORC(36) xtrans[0][c] =
+@
+
+
+1.473
+log
+@Canon multi-exposure files are already white-balanced.
+@
+text
+@d26 1
+a26 1
+#define DCRAW_VERSION "9.24"
+d952 1
+a952 1
+ i = jidx / (cr2_slice[1]*jh.high);
+d955 1
+a955 1
+ jidx -= i * (cr2_slice[1]*jh.high);
+d1538 1
+a1538 1
+ int cx[18], cf[18];
+d1545 2
+a1546 2
+ cubic_spline(cx, cf, 18);
+
+d5506 1
+a5506 1
+ "Aptus-II 7","","","Aptus-II 6","","","Aptus-II 10","Aptus-II 5",
+d5725 4
+d6977 2
+d7243 2
+d7257 1
+a7257 1
+ { "Fujifilm XQ1", 0, 0,
+d7397 2
+a7398 2
+ { "Nikon D5500", 0, 0, /* DJC */
+ { 5765,-2176,184,-3736,9072,4664,-1028,2213,9259 } },
+d7411 2
+d7477 2
+d7563 2
+a7564 2
+ { "Olympus E-M5MarkII", 0, 0, /* DJC */
+ { 6617,-2589,139,-2917,8499,4419,-884,1913,6829 } },
+d7727 2
+a7728 2
+ { "Panasonic DMC-GF7", 15, 0, /* DJC */
+ { 6086,-2691,-18,-4207,9767,4441,-1486,2640,7441 } },
+d7749 4
+d7793 2
+d7797 1
+a7797 1
+ { "Samsung NX1", 128, 0,
+d8060 1
+d8549 4
+a8552 1
+ if (height > width) SWAP(height,width);
+d8811 1
+@
+
+
+1.472
+log
+@Moved border_interpolate() to the end of xtrans_interpolate().
+@
+text
+@d5391 2
+@
+
+
+1.471
+log
+@Support all format options of the Nikon D4S and D810.
+Guess which filter pattern OmniVision cameras use.
+@
+text
+@a4608 1
+ border_interpolate(6);
+d4813 1
+@
+
+
+1.470
+log
+@Fixed data errors with Olympus E-M5MarkII HR images.
+@
+text
+@d26 1
+a26 1
+#define DCRAW_VERSION "9.23"
+d1201 19
+d1914 1
+d1928 7
+d5263 2
+d6206 6
+d7359 1
+a7359 1
+ { "Nikon D3300", 150, 0,
+d7373 1
+a7373 1
+ { "Nikon D4S", 768, 0,
+d7385 1
+a7385 1
+ { "Nikon D5300", 600, 0,
+d7387 2
+d7401 1
+a7401 1
+ { "Nikon D750", 600, 0,
+d7407 1
+a7407 1
+ { "Nikon D810", 600, 0,
+d7461 1
+a7461 1
+ { "Nikon 1 V3", 200, 0,
+d7463 1
+a7463 1
+ { "Nikon 1 J4", 200, 0,
+d7549 2
+d7575 1
+a7575 1
+ { "OmniVision ov5647", 0, 0, /* DJC */
+d7713 2
+@
+
+
+1.469
+log
+@Support the Lenovo A820.
+@
+text
+@d1884 2
+a1885 2
+ if (load_flags & 1 && (col % 10) == 9 &&
+ fgetc(ifp) && col < width+left_margin) derror();
+d8886 1
+@
+
+
+1.468
+log
+@Copied color matrices from DNG Converter 8.7.1.
+Support pre-release Sonys and Canons that lack a proper model name.
+Support the Samsung NX1 (yet another compression algorithm).
+Read camera white balance in all professional Kodak cameras.
+Reduced zippering in Fuji X-Trans interpolation.
+Support YCbCr files from the Kodak C330.
+Support Hasselblad multi-shot files.
+@
+text
+@d8128 1
+@
+
+
1.467
log
@Correctly handle Fuji X-Trans images in DNG format.
@@ -20875,7 +21852,7 @@ a4388 1
short sorder;
a4393 1
sorder = order;
-d4486 5
+d4479 5
d4501 2
a4502 4
if (tag == 0x8c)
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-05 05:31:07 +0000