liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #7257 from Beep6581/fix-warnings-5.12

Browse Source 
Compiler warning fixes
This commit is contained in:
Lawrence37 2024-12-26 22:26:11 -08:00 committed by GitHub
commit 98752a2433
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 184 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rtengine/FTblockDN.cc
View File

@ -755,8 +755,8 @@ BENCHFUN
int min_numblox_W = ceil((static_cast<float>((MIN(imwidth, ((numtiles_W - 1) * tileWskip) + tilewidth)) - ((numtiles_W - 1) * tileWskip))) / (offset)) + 2 * blkrad; int min_numblox_W = ceil((static_cast<float>((MIN(imwidth, ((numtiles_W - 1) * tileWskip) + tilewidth)) - ((numtiles_W - 1) * tileWskip))) / (offset)) + 2 * blkrad;
// these are needed only for creation of the plans and will be freed before entering the parallel loop // these are needed only for creation of the plans and will be freed before entering the parallel loop
fftwf_plan plan_forward_blox[2]; fftwf_plan plan_forward_blox[2] = {};
fftwf_plan plan_backward_blox[2]; fftwf_plan plan_backward_blox[2] = {};
if (denoiseLuminance) { if (denoiseLuminance) {
float *Lbloxtmp = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * TS * TS * sizeof(float))); float *Lbloxtmp = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * TS * TS * sizeof(float)));

2
rtengine/canon_cr3_decoder.cc
View File

@ -2759,6 +2759,7 @@ bool crxMakeQStep(CrxImage *img, CrxTile *tile, std::int32_t *qpTable, std::uint
} }
// continue to the next level - we always decode all levels // continue to the next level - we always decode all levels
++qStep; ++qStep;
// fall through
case 2: case 2:
qStep->qStepTbl = qStepTbl; qStep->qStepTbl = qStepTbl;
qStep->width = qpWidth; qStep->width = qpWidth;
@ -2777,6 +2778,7 @@ bool crxMakeQStep(CrxImage *img, CrxTile *tile, std::int32_t *qpTable, std::uint
} }
// continue to the next level - we always decode all levels // continue to the next level - we always decode all levels
++qStep; ++qStep;
// fall through
case 1: case 1:
qStep->qStepTbl = qStepTbl; qStep->qStepTbl = qStepTbl;
qStep->width = qpWidth; qStep->width = qpWidth;

189
rtengine/dcraw.cc
View File

@ -2851,7 +2851,7 @@ void CLASS kodak_radc_load_raw()
FORC3 { FORC3 {
val = ((0x1000000/last[c] + 0x7ff) >> 12) * mul[c]; val = ((0x1000000/last[c] + 0x7ff) >> 12) * mul[c];
s = val > 65564 ? 10:12; s = val > 65564 ? 10:12;
x = ~(-1 << (s-1)); x = ~(~0U << (s-1));
val <<= 12-s; val <<= 12-s;
for (i=0; i < sizeof(buf[0])/sizeof(short); i++) for (i=0; i < sizeof(buf[0])/sizeof(short); i++)
((short *)buf[c])[i] = (((short *)buf[c])[i] * val + x) >> s; ((short *)buf[c])[i] = (((short *)buf[c])[i] * val + x) >> s;
@ -3527,7 +3527,7 @@ void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
if ((data >> nbits & 0xff) == 0xff) break; if ((data >> nbits & 0xff) == 0xff) break;
if (nbits > 0) if (nbits > 0)
data = ((data & ((1 << (nbits-1)) - 1)) << 1) | data = ((data & ((1 << (nbits-1)) - 1)) << 1) |
((data + (((data & (1 << (nbits-1)))) << 1)) & (-1 << nbits)); ((data + (((data & (1 << (nbits-1)))) << 1)) & (~0U << nbits));
if (nbits >= 0) { if (nbits >= 0) {
data += getbits(1); data += getbits(1);
carry = nbits - 8; carry = nbits - 8;
@ -7450,7 +7450,7 @@ void CLASS ciff_block_1030()
bitbuf = bitbuf << 16 | (get2() ^ key[i++ & 1]); bitbuf = bitbuf << 16 | (get2() ^ key[i++ & 1]);
vbits += 16; vbits += 16;
} }
white[row][col] = bitbuf >> (vbits -= bpp) & ~(-1 << bpp); white[row][col] = bitbuf >> (vbits -= bpp) & ~(~0U << bpp);
} }
} }
@ -7911,7 +7911,7 @@ void CLASS parse_cine()
} }
cam_mul[0] = getreal(11); cam_mul[0] = getreal(11);
cam_mul[2] = getreal(11); cam_mul[2] = getreal(11);
maximum = ~(-1 << get4()); maximum = ~(~0U << get4());
fseek (ifp, 668, SEEK_CUR); fseek (ifp, 668, SEEK_CUR);
shutter = get4()/1000000000.0; shutter = get4()/1000000000.0;
fseek (ifp, off_image, SEEK_SET); fseek (ifp, off_image, SEEK_SET);
@ -10004,107 +10004,108 @@ void CLASS identify()
char make[10], model[20]; char make[10], model[20];
ushort offset; ushort offset;
} table[] = { } table[] = {
{ 786432,1024, 768, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-080C" }, { 786432,1024, 768, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-080C",0 },
{ 1447680,1392,1040, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-145C" }, { 1447680,1392,1040, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-145C",0 },
{ 1920000,1600,1200, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-201C" }, { 1920000,1600,1200, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-201C",0 },
{ 5067304,2588,1958, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-510C" }, { 5067304,2588,1958, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-510C",0 },
{ 5067316,2588,1958, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-510C",12 }, { 5067316,2588,1958, 0, 0, 0, 0, 0,0x94,0,0,"AVT","F-510C",12 },
{ 10134608,2588,1958, 0, 0, 0, 0, 9,0x94,0,0,"AVT","F-510C" }, { 10134608,2588,1958, 0, 0, 0, 0, 9,0x94,0,0,"AVT","F-510C",0 },
{ 10134620,2588,1958, 0, 0, 0, 0, 9,0x94,0,0,"AVT","F-510C",12 }, { 10134620,2588,1958, 0, 0, 0, 0, 9,0x94,0,0,"AVT","F-510C",12 },
{ 16157136,3272,2469, 0, 0, 0, 0, 9,0x94,0,0,"AVT","F-810C" }, { 16157136,3272,2469, 0, 0, 0, 0, 9,0x94,0,0,"AVT","F-810C",0 },
{ 15980544,3264,2448, 0, 0, 0, 0, 8,0x61,0,1,"AgfaPhoto","DC-833m" }, { 15980544,3264,2448, 0, 0, 0, 0, 8,0x61,0,1,"AgfaPhoto","DC-833m",0 },
{ 9631728,2532,1902, 0, 0, 0, 0,96,0x61,0,0,"Alcatel","5035D" }, { 9631728,2532,1902, 0, 0, 0, 0,96,0x61,0,0,"Alcatel","5035D",0 },
{ 2868726,1384,1036, 0, 0, 0, 0,64,0x49,0,8,"Baumer","TXG14",1078 }, { 2868726,1384,1036, 0, 0, 0, 0,64,0x49,0,8,"Baumer","TXG14",1078 },
{ 5298000,2400,1766,12,12,44, 2, 8,0x94,0,2,"Canon","PowerShot SD300" }, { 5298000,2400,1766,12,12,44, 2, 8,0x94,0,2,"Canon","PowerShot SD300",0 },
{ 6553440,2664,1968, 4, 4,44, 4, 8,0x94,0,2,"Canon","PowerShot A460" }, { 6553440,2664,1968, 4, 4,44, 4, 8,0x94,0,2,"Canon","PowerShot A460",0 },
{ 6573120,2672,1968,12, 8,44, 0, 8,0x94,0,2,"Canon","PowerShot A610" }, { 6573120,2672,1968,12, 8,44, 0, 8,0x94,0,2,"Canon","PowerShot A610",0 },
{ 6653280,2672,1992,10, 6,42, 2, 8,0x94,0,2,"Canon","PowerShot A530" }, { 6653280,2672,1992,10, 6,42, 2, 8,0x94,0,2,"Canon","PowerShot A530",0 },
{ 7710960,2888,2136,44, 8, 4, 0, 8,0x94,0,2,"Canon","PowerShot S3 IS" }, { 7710960,2888,2136,44, 8, 4, 0, 8,0x94,0,2,"Canon","PowerShot S3 IS",0 },
{ 9219600,3152,2340,36,12, 4, 0, 8,0x94,0,2,"Canon","PowerShot A620" }, { 9219600,3152,2340,36,12, 4, 0, 8,0x94,0,2,"Canon","PowerShot A620",0 },
{ 9243240,3152,2346,12, 7,44,13, 8,0x49,0,2,"Canon","PowerShot A470" }, { 9243240,3152,2346,12, 7,44,13, 8,0x49,0,2,"Canon","PowerShot A470",0 },
{ 10341600,3336,2480, 6, 5,32, 3, 8,0x94,0,2,"Canon","PowerShot A720 IS" }, { 10341600,3336,2480, 6, 5,32, 3, 8,0x94,0,2,"Canon","PowerShot A720 IS",0 },
{ 10383120,3344,2484,12, 6,44, 6, 8,0x94,0,2,"Canon","PowerShot A630" }, { 10383120,3344,2484,12, 6,44, 6, 8,0x94,0,2,"Canon","PowerShot A630",0 },
{ 12945240,3736,2772,12, 6,52, 6, 8,0x94,0,2,"Canon","PowerShot A640" }, { 12945240,3736,2772,12, 6,52, 6, 8,0x94,0,2,"Canon","PowerShot A640",0 },
{ 15636240,4104,3048,48,12,24,12, 8,0x94,0,2,"Canon","PowerShot A650" }, { 15636240,4104,3048,48,12,24,12, 8,0x94,0,2,"Canon","PowerShot A650",0 },
{ 15467760,3720,2772, 6,12,30, 0, 8,0x94,0,2,"Canon","PowerShot SX110 IS" }, { 15467760,3720,2772, 6,12,30, 0, 8,0x94,0,2,"Canon","PowerShot SX110 IS",0 },
{ 15534576,3728,2778,12, 9,44, 9, 8,0x94,0,2,"Canon","PowerShot SX120 IS" }, { 15534576,3728,2778,12, 9,44, 9, 8,0x94,0,2,"Canon","PowerShot SX120 IS",0 },
{ 18653760,4080,3048,24,12,24,12, 8,0x94,0,2,"Canon","PowerShot SX20 IS" }, { 18653760,4080,3048,24,12,24,12, 8,0x94,0,2,"Canon","PowerShot SX20 IS",0 },
{ 19131120,4168,3060,92,16, 4, 1, 8,0x94,0,2,"Canon","PowerShot SX220 HS" }, { 19131120,4168,3060,92,16, 4, 1, 8,0x94,0,2,"Canon","PowerShot SX220 HS",0 },
{ 21936096,4464,3276,25,10,73,12, 8,0x16,0,2,"Canon","PowerShot SX30 IS" }, { 21936096,4464,3276,25,10,73,12, 8,0x16,0,2,"Canon","PowerShot SX30 IS",0 },
{ 24724224,4704,3504, 8,16,56, 8, 8,0x94,0,2,"Canon","PowerShot A3300 IS" }, { 24724224,4704,3504, 8,16,56, 8, 8,0x94,0,2,"Canon","PowerShot A3300 IS",0 },
{ 30858240,5248,3920, 8,16,56,16, 8,0x94,0,2,"Canon","IXUS 160" }, { 1976352,1632,1211, 0, 2, 0, 1, 0,0x94,0,1,"Casio","QV-2000UX" }, { 30858240,5248,3920, 8,16,56,16, 8,0x94,0,2,"Canon","IXUS 160",0 },
{ 3217760,2080,1547, 0, 0,10, 1, 0,0x94,0,1,"Casio","QV-3*00EX" }, { 1976352,1632,1211, 0, 2, 0, 1, 0,0x94,0,1,"Casio","QV-2000UX",0 },
{ 6218368,2585,1924, 0, 0, 9, 0, 0,0x94,0,1,"Casio","QV-5700" }, { 3217760,2080,1547, 0, 0,10, 1, 0,0x94,0,1,"Casio","QV-3*00EX",0 },
{ 7816704,2867,2181, 0, 0,34,36, 0,0x16,0,1,"Casio","EX-Z60" }, { 6218368,2585,1924, 0, 0, 9, 0, 0,0x94,0,1,"Casio","QV-5700",0 },
{ 2937856,1621,1208, 0, 0, 1, 0, 0,0x94,7,13,"Casio","EX-S20" }, { 7816704,2867,2181, 0, 0,34,36, 0,0x16,0,1,"Casio","EX-Z60",0 },
{ 4948608,2090,1578, 0, 0,32,34, 0,0x94,7,1,"Casio","EX-S100" }, { 2937856,1621,1208, 0, 0, 1, 0, 0,0x94,7,13,"Casio","EX-S20",0 },
{ 6054400,2346,1720, 2, 0,32, 0, 0,0x94,7,1,"Casio","QV-R41" }, { 4948608,2090,1578, 0, 0,32,34, 0,0x94,7,1,"Casio","EX-S100",0 },
{ 7426656,2568,1928, 0, 0, 0, 0, 0,0x94,0,1,"Casio","EX-P505" }, { 6054400,2346,1720, 2, 0,32, 0, 0,0x94,7,1,"Casio","QV-R41",0 },
{ 7530816,2602,1929, 0, 0,22, 0, 0,0x94,7,1,"Casio","QV-R51" }, { 7426656,2568,1928, 0, 0, 0, 0, 0,0x94,0,1,"Casio","EX-P505",0 },
{ 7542528,2602,1932, 0, 0,32, 0, 0,0x94,7,1,"Casio","EX-Z50" }, { 7530816,2602,1929, 0, 0,22, 0, 0,0x94,7,1,"Casio","QV-R51",0 },
{ 7562048,2602,1937, 0, 0,25, 0, 0,0x16,7,1,"Casio","EX-Z500" }, { 7542528,2602,1932, 0, 0,32, 0, 0,0x94,7,1,"Casio","EX-Z50",0 },
{ 7753344,2602,1986, 0, 0,32,26, 0,0x94,7,1,"Casio","EX-Z55" }, { 7562048,2602,1937, 0, 0,25, 0, 0,0x16,7,1,"Casio","EX-Z500",0 },
{ 9313536,2858,2172, 0, 0,14,30, 0,0x94,7,1,"Casio","EX-P600" }, { 7753344,2602,1986, 0, 0,32,26, 0,0x94,7,1,"Casio","EX-Z55",0 },
{ 10834368,3114,2319, 0, 0,27, 0, 0,0x94,0,1,"Casio","EX-Z750" }, { 9313536,2858,2172, 0, 0,14,30, 0,0x94,7,1,"Casio","EX-P600",0 },
{ 10843712,3114,2321, 0, 0,25, 0, 0,0x94,0,1,"Casio","EX-Z75" }, { 10834368,3114,2319, 0, 0,27, 0, 0,0x94,0,1,"Casio","EX-Z750",0 },
{ 10979200,3114,2350, 0, 0,32,32, 0,0x94,7,1,"Casio","EX-P700" }, { 10843712,3114,2321, 0, 0,25, 0, 0,0x94,0,1,"Casio","EX-Z75",0 },
{ 12310144,3285,2498, 0, 0, 6,30, 0,0x94,0,1,"Casio","EX-Z850" }, { 10979200,3114,2350, 0, 0,32,32, 0,0x94,7,1,"Casio","EX-P700",0 },
{ 12489984,3328,2502, 0, 0,47,35, 0,0x94,0,1,"Casio","EX-Z8" }, { 12310144,3285,2498, 0, 0, 6,30, 0,0x94,0,1,"Casio","EX-Z850",0 },
{ 15499264,3754,2752, 0, 0,82, 0, 0,0x94,0,1,"Casio","EX-Z1050" }, { 12489984,3328,2502, 0, 0,47,35, 0,0x94,0,1,"Casio","EX-Z8",0 },
{ 18702336,4096,3044, 0, 0,24, 0,80,0x94,7,1,"Casio","EX-ZR100" }, { 15499264,3754,2752, 0, 0,82, 0, 0,0x94,0,1,"Casio","EX-Z1050",0 },
{ 7684000,2260,1700, 0, 0, 0, 0,13,0x94,0,1,"Casio","QV-4000" }, { 18702336,4096,3044, 0, 0,24, 0,80,0x94,7,1,"Casio","EX-ZR100",0 },
{ 787456,1024, 769, 0, 1, 0, 0, 0,0x49,0,0,"Creative","PC-CAM 600" }, { 7684000,2260,1700, 0, 0, 0, 0,13,0x94,0,1,"Casio","QV-4000",0 },
{ 28829184,4384,3288, 0, 0, 0, 0,36,0x61,0,0,"DJI" }, { 787456,1024, 769, 0, 1, 0, 0, 0,0x49,0,0,"Creative","PC-CAM 600",0 },
{ 15151104,4608,3288, 0, 0, 0, 0, 0,0x94,0,0,"Matrix" }, { 28829184,4384,3288, 0, 0, 0, 0,36,0x61,0,0,"DJI",0 },
{ 3840000,1600,1200, 0, 0, 0, 0,65,0x49,0,0,"Foculus","531C" }, { 15151104,4608,3288, 0, 0, 0, 0, 0,0x94,0,0,"Matrix",0 },
{ 307200, 640, 480, 0, 0, 0, 0, 0,0x94,0,0,"Generic" }, { 3840000,1600,1200, 0, 0, 0, 0,65,0x49,0,0,"Foculus","531C",0 },
{ 62464, 256, 244, 1, 1, 6, 1, 0,0x8d,0,0,"Kodak","DC20" }, { 307200, 640, 480, 0, 0, 0, 0, 0,0x94,0,0,"Generic",0 },
{ 124928, 512, 244, 1, 1,10, 1, 0,0x8d,0,0,"Kodak","DC20" }, { 62464, 256, 244, 1, 1, 6, 1, 0,0x8d,0,0,"Kodak","DC20",0 },
{ 1652736,1536,1076, 0,52, 0, 0, 0,0x61,0,0,"Kodak","DCS200" }, { 124928, 512, 244, 1, 1,10, 1, 0,0x8d,0,0,"Kodak","DC20",0 },
{ 4159302,2338,1779, 1,33, 1, 2, 0,0x94,0,0,"Kodak","C330" }, { 1652736,1536,1076, 0,52, 0, 0, 0,0x61,0,0,"Kodak","DCS200",0 },
{ 4159302,2338,1779, 1,33, 1, 2, 0,0x94,0,0,"Kodak","C330",0 },
{ 4162462,2338,1779, 1,33, 1, 2, 0,0x94,0,0,"Kodak","C330",3160 }, { 4162462,2338,1779, 1,33, 1, 2, 0,0x94,0,0,"Kodak","C330",3160 },
{ 2247168,1232, 912, 0, 0,16, 0, 0,0x00,0,0,"Kodak","C330" }, { 2247168,1232, 912, 0, 0,16, 0, 0,0x00,0,0,"Kodak","C330",0 },
{ 3370752,1232, 912, 0, 0,16, 0, 0,0x00,0,0,"Kodak","C330" }, { 3370752,1232, 912, 0, 0,16, 0, 0,0x00,0,0,"Kodak","C330",0 },
{ 6163328,2864,2152, 0, 0, 0, 0, 0,0x94,0,0,"Kodak","C603" }, { 6163328,2864,2152, 0, 0, 0, 0, 0,0x94,0,0,"Kodak","C603",0 },
{ 6166488,2864,2152, 0, 0, 0, 0, 0,0x94,0,0,"Kodak","C603",3160 }, { 6166488,2864,2152, 0, 0, 0, 0, 0,0x94,0,0,"Kodak","C603",3160 },
{ 460800, 640, 480, 0, 0, 0, 0, 0,0x00,0,0,"Kodak","C603" }, { 460800, 640, 480, 0, 0, 0, 0, 0,0x00,0,0,"Kodak","C603",0 },
{ 9116448,2848,2134, 0, 0, 0, 0, 0,0x00,0,0,"Kodak","C603" }, { 9116448,2848,2134, 0, 0, 0, 0, 0,0x00,0,0,"Kodak","C603",0 },
{ 12241200,4040,3030, 2, 0, 0,13, 0,0x49,0,0,"Kodak","12MP" }, { 12241200,4040,3030, 2, 0, 0,13, 0,0x49,0,0,"Kodak","12MP",0 },
{ 12272756,4040,3030, 2, 0, 0,13, 0,0x49,0,0,"Kodak","12MP",31556 }, { 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" }, { 18000000,4000,3000, 0, 0, 0, 0, 0,0x00,0,0,"Kodak","12MP",0 },
{ 614400, 640, 480, 0, 3, 0, 0,64,0x94,0,0,"Kodak","KAI-0340" }, { 614400, 640, 480, 0, 3, 0, 0,64,0x94,0,0,"Kodak","KAI-0340",0 },
{ 15360000,3200,2400, 0, 0, 0, 0,96,0x16,0,0,"Lenovo","A820" }, { 15360000,3200,2400, 0, 0, 0, 0,96,0x16,0,0,"Lenovo","A820",0 },
{ 3884928,1608,1207, 0, 0, 0, 0,96,0x16,0,0,"Micron","2010",3212 }, { 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 }, { 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" }, { 1581060,1305, 969, 0, 0,18, 6, 6,0x1e,4,1,"Nikon","E900",0 },
{ 2465792,1638,1204, 0, 0,22, 1, 6,0x4b,5,1,"Nikon","E950" }, { 2465792,1638,1204, 0, 0,22, 1, 6,0x4b,5,1,"Nikon","E950",0 },
{ 2940928,1616,1213, 0, 0, 0, 7,30,0x94,0,1,"Nikon","E2100" }, { 2940928,1616,1213, 0, 0, 0, 7,30,0x94,0,1,"Nikon","E2100",0 },
{ 4771840,2064,1541, 0, 0, 0, 1, 6,0xe1,0,1,"Nikon","E990" }, { 4771840,2064,1541, 0, 0, 0, 1, 6,0xe1,0,1,"Nikon","E990",0 },
{ 4775936,2064,1542, 0, 0, 0, 0,30,0x94,0,1,"Nikon","E3700" }, { 4775936,2064,1542, 0, 0, 0, 0,30,0x94,0,1,"Nikon","E3700",0 },
{ 5865472,2288,1709, 0, 0, 0, 1, 6,0xb4,0,1,"Nikon","E4500" }, { 5865472,2288,1709, 0, 0, 0, 1, 6,0xb4,0,1,"Nikon","E4500",0 },
{ 5869568,2288,1710, 0, 0, 0, 0, 6,0x16,0,1,"Nikon","E4300" }, { 5869568,2288,1710, 0, 0, 0, 0, 6,0x16,0,1,"Nikon","E4300",0 },
{ 7438336,2576,1925, 0, 0, 0, 1, 6,0xb4,0,1,"Nikon","E5000" }, { 7438336,2576,1925, 0, 0, 0, 1, 6,0xb4,0,1,"Nikon","E5000",0 },
{ 8998912,2832,2118, 0, 0, 0, 0,30,0x94,7,1,"Nikon","COOLPIX S6" }, { 8998912,2832,2118, 0, 0, 0, 0,30,0x94,7,1,"Nikon","COOLPIX S6",0 },
{ 5939200,2304,1718, 0, 0, 0, 0,30,0x16,0,0,"Olympus","C770UZ" }, { 5939200,2304,1718, 0, 0, 0, 0,30,0x16,0,0,"Olympus","C770UZ",0 },
{ 3178560,2064,1540, 0, 0, 0, 0, 0,0x94,0,1,"Pentax","Optio S" }, { 3178560,2064,1540, 0, 0, 0, 0, 0,0x94,0,1,"Pentax","Optio S",0 },
{ 4841984,2090,1544, 0, 0,22, 0, 0,0x94,7,1,"Pentax","Optio S" }, { 4841984,2090,1544, 0, 0,22, 0, 0,0x94,7,1,"Pentax","Optio S",0 },
{ 6114240,2346,1737, 0, 0,22, 0, 0,0x94,7,1,"Pentax","Optio S4" }, { 6114240,2346,1737, 0, 0,22, 0, 0,0x94,7,1,"Pentax","Optio S4",0 },
{ 10702848,3072,2322, 0, 0, 0,21,30,0x94,0,1,"Pentax","Optio 750Z" }, { 10702848,3072,2322, 0, 0, 0,21,30,0x94,0,1,"Pentax","Optio 750Z",0 },
{ 4147200,1920,1080, 0, 0, 0, 0, 0,0x49,0,0,"Photron","BC2-HD" }, { 4147200,1920,1080, 0, 0, 0, 0, 0,0x49,0,0,"Photron","BC2-HD",0 },
{ 4151666,1920,1080, 0, 0, 0, 0, 0,0x49,0,0,"Photron","BC2-HD",8 }, { 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" }, { 13248000,2208,3000, 0, 0, 0, 0,13,0x61,0,0,"Pixelink","A782",0 },
{ 6291456,2048,1536, 0, 0, 0, 0,96,0x61,0,0,"RoverShot","3320AF" }, { 6291456,2048,1536, 0, 0, 0, 0,96,0x61,0,0,"RoverShot","3320AF",0 },
{ 311696, 644, 484, 0, 0, 0, 0, 0,0x16,0,8,"ST Micro","STV680 VGA" }, { 311696, 644, 484, 0, 0, 0, 0, 0,0x16,0,8,"ST Micro","STV680 VGA",0 },
{ 16098048,3288,2448, 0, 0,24, 0, 9,0x94,0,1,"Samsung","S85" }, { 16098048,3288,2448, 0, 0,24, 0, 9,0x94,0,1,"Samsung","S85",0 },
{ 16215552,3312,2448, 0, 0,48, 0, 9,0x94,0,1,"Samsung","S85" }, { 16215552,3312,2448, 0, 0,48, 0, 9,0x94,0,1,"Samsung","S85",0 },
{ 20487168,3648,2808, 0, 0, 0, 0,13,0x94,5,1,"Samsung","WB550" }, { 20487168,3648,2808, 0, 0, 0, 0,13,0x94,5,1,"Samsung","WB550",0 },
{ 24000000,4000,3000, 0, 0, 0, 0,13,0x94,5,1,"Samsung","WB550" }, { 24000000,4000,3000, 0, 0, 0, 0,13,0x94,5,1,"Samsung","WB550",0 },
{ 12582980,3072,2048, 0, 0, 0, 0,33,0x61,0,0,"Sinar","",68 }, { 12582980,3072,2048, 0, 0, 0, 0,33,0x61,0,0,"Sinar","",68 },
{ 33292868,4080,4080, 0, 0, 0, 0,33,0x61,0,0,"Sinar","",68 }, { 33292868,4080,4080, 0, 0, 0, 0,33,0x61,0,0,"Sinar","",68 },
{ 44390468,4080,5440, 0, 0, 0, 0,33,0x61,0,0,"Sinar","",68 }, { 44390468,4080,5440, 0, 0, 0, 0,33,0x61,0,0,"Sinar","",68 },
{ 1409024,1376,1024, 0, 0, 1, 0, 0,0x49,0,0,"Sony","XCD-SX910CR" }, { 1409024,1376,1024, 0, 0, 1, 0, 0,0x49,0,0,"Sony","XCD-SX910CR",0 },
{ 2818048,1376,1024, 0, 0, 1, 0,97,0x49,0,0,"Sony","XCD-SX910CR" }, { 2818048,1376,1024, 0, 0, 1, 0,97,0x49,0,0,"Sony","XCD-SX910CR",0 },
{ 17496000,4320,3240, 0, 0, 0,0,224,0x94,0,0,"Xiro","Xplorer V" }, { 17496000,4320,3240, 0, 0, 0,0,224,0x94,0,0,"Xiro","Xplorer V",0 },
}; };
static const char *corp[] = static const char *corp[] =
{ "AgfaPhoto", "Canon", "Casio", "Epson", "Fujifilm", { "AgfaPhoto", "Canon", "Casio", "Epson", "Fujifilm",
@ -10750,7 +10751,7 @@ canon_a5:
} else if (!strncmp(model,"ALPHA",5) || } else if (!strncmp(model,"ALPHA",5) ||
!strncmp(model,"DYNAX",5) || !strncmp(model,"DYNAX",5) ||
!strncmp(model,"MAXXUM",6)) { !strncmp(model,"MAXXUM",6)) {
sprintf (model+20, "DYNAX %-10s", model+6+(model[0]=='M')); snprintf (model+20, 20-(model[0]=='M'), "DYNAX %-10s", model+6+(model[0]=='M'));
adobe_coeff (make, model+20); adobe_coeff (make, model+20);
load_raw = &CLASS packed_load_raw; load_raw = &CLASS packed_load_raw;
} else if (!strncmp(model,"DiMAGE G",8)) { } else if (!strncmp(model,"DiMAGE G",8)) {

2
rtengine/imagedata.cc
View File

@ -736,7 +736,7 @@ FramesData::FramesData(const Glib::ustring &fname, time_t ts) :
// ----------------------- // -----------------------
// Special file type detection (HDR, PixelShift) // Special file type detection (HDR, PixelShift)
// ------------------------ // ------------------------
uint16 bitspersample = 0, samplesperpixel = 0, sampleformat = 0, photometric = 0, compression = 0; std::uint16_t bitspersample = 0, samplesperpixel = 0, sampleformat = 0, photometric = 0, compression = 0;
const auto bps = exif.findKey(Exiv2::ExifKey("Exif.Image.BitsPerSample")); const auto bps = exif.findKey(Exiv2::ExifKey("Exif.Image.BitsPerSample"));
const auto spp = exif.findKey(Exiv2::ExifKey("Exif.Image.SamplesPerPixel")); const auto spp = exif.findKey(Exiv2::ExifKey("Exif.Image.SamplesPerPixel"));
const auto sf = exif.findKey(Exiv2::ExifKey("Exif.Image.SampleFormat")); const auto sf = exif.findKey(Exiv2::ExifKey("Exif.Image.SampleFormat"));

19
rtengine/imageio.cc
View File

@ -17,6 +17,7 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <https://www.gnu.org/licenses/>. * along with RawTherapee. If not, see <https://www.gnu.org/licenses/>.
*/ */
#include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <iostream> #include <iostream>
@ -590,7 +591,7 @@ int ImageIO::getTIFFSampleFormat (const Glib::ustring &fname, IIOSampleFormat &s
return IMIO_CANNOTREADFILE; return IMIO_CANNOTREADFILE;
} }
uint16 bitspersample = 0, samplesperpixel = 0, sampleformat = 0; std::uint16_t bitspersample = 0, samplesperpixel = 0, sampleformat = 0;
int hasTag = TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample); int hasTag = TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
hasTag &= TIFFGetField(in, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel); hasTag &= TIFFGetField(in, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
@ -615,7 +616,7 @@ int ImageIO::getTIFFSampleFormat (const Glib::ustring &fname, IIOSampleFormat &s
sampleformat = SAMPLEFORMAT_UINT; sampleformat = SAMPLEFORMAT_UINT;
} }
uint16 config; std::uint16_t config;
TIFFGetField(in, TIFFTAG_PLANARCONFIG, &config); TIFFGetField(in, TIFFTAG_PLANARCONFIG, &config);
if (config == PLANARCONFIG_CONTIG) { if (config == PLANARCONFIG_CONTIG) {
@ -627,14 +628,14 @@ int ImageIO::getTIFFSampleFormat (const Glib::ustring &fname, IIOSampleFormat &s
return IMIO_VARIANTNOTSUPPORTED; return IMIO_VARIANTNOTSUPPORTED;
} }
uint16 photometric; std::uint16_t photometric;
if (!TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &photometric)) { if (!TIFFGetField(in, TIFFTAG_PHOTOMETRIC, &photometric)) {
TIFFClose(in); TIFFClose(in);
return IMIO_VARIANTNOTSUPPORTED; return IMIO_VARIANTNOTSUPPORTED;
} }
uint16 compression; std::uint16_t compression;
if (photometric == PHOTOMETRIC_LOGLUV) if (photometric == PHOTOMETRIC_LOGLUV)
if (!TIFFGetField(in, TIFFTAG_COMPRESSION, &compression)) { if (!TIFFGetField(in, TIFFTAG_COMPRESSION, &compression)) {
@ -712,7 +713,7 @@ int ImageIO::loadTIFF (const Glib::ustring &fname)
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width); TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height); TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
uint16 bitspersample, samplesperpixel; std::uint16_t bitspersample, samplesperpixel;
int hasTag = TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample); int hasTag = TIFFGetField(in, TIFFTAG_BITSPERSAMPLE, &bitspersample);
hasTag &= TIFFGetField(in, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel); hasTag &= TIFFGetField(in, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
@ -724,7 +725,7 @@ int ImageIO::loadTIFF (const Glib::ustring &fname)
return IMIO_VARIANTNOTSUPPORTED; return IMIO_VARIANTNOTSUPPORTED;
} }
uint16 config; std::uint16_t config;
TIFFGetField(in, TIFFTAG_PLANARCONFIG, &config); TIFFGetField(in, TIFFTAG_PLANARCONFIG, &config);
if (config != PLANARCONFIG_CONTIG) { if (config != PLANARCONFIG_CONTIG) {
@ -745,7 +746,7 @@ int ImageIO::loadTIFF (const Glib::ustring &fname)
*/ */
if (settings->verbose) { if (settings->verbose) {
printf("Information of \"%s\":\n", fname.c_str()); printf("Information of \"%s\":\n", fname.c_str());
uint16 tiffDefaultScale, tiffBaselineExposure, tiffLinearResponseLimit; std::uint16_t tiffDefaultScale, tiffBaselineExposure, tiffLinearResponseLimit;
if (TIFFGetField(in, TIFFTAG_DEFAULTSCALE, &tiffDefaultScale)) { if (TIFFGetField(in, TIFFTAG_DEFAULTSCALE, &tiffDefaultScale)) {
printf(" DefaultScale: %d\n", tiffDefaultScale); printf(" DefaultScale: %d\n", tiffDefaultScale);
} }
@ -762,7 +763,7 @@ int ImageIO::loadTIFF (const Glib::ustring &fname)
else else
printf(" No LinearResponseLimit value!\n"); printf(" No LinearResponseLimit value!\n");
uint16 tiffMinValue, tiffMaxValue; std::uint16_t tiffMinValue, tiffMaxValue;
if (TIFFGetField(in, TIFFTAG_SMINSAMPLEVALUE, &tiffMinValue)) { if (TIFFGetField(in, TIFFTAG_SMINSAMPLEVALUE, &tiffMinValue)) {
printf(" MinValue: %d\n", tiffMinValue); printf(" MinValue: %d\n", tiffMinValue);
} }
@ -1020,7 +1021,7 @@ int ImageIO::loadPPMFromMemory(const char* buffer, int width, int height, bool s
} }
int ImageIO::savePNG (const Glib::ustring &fname, int bps) const int ImageIO::savePNG (const Glib::ustring &fname, volatile int bps) const
{ {
if (getWidth() < 1 || getHeight() < 1) { if (getWidth() < 1 || getHeight() < 1) {
return IMIO_HEADERERROR; return IMIO_HEADERERROR;

3
rtengine/iplocallab.cc
View File

@ -6728,7 +6728,8 @@ void ImProcFunctions::maskcalccol(bool invmask, bool pde, int bfw, int bfh, int
bdecomp.reconstruct(tmpab.b[0]); bdecomp.reconstruct(tmpab.b[0]);
} }
float meanfab1, fab1, maxfab1; float meanfab1, fab1;
float maxfab1 = 0.f;
std::unique_ptr<LabImage> buforig; std::unique_ptr<LabImage> buforig;
buforig.reset(new LabImage(bfw, bfh)); buforig.reset(new LabImage(bfw, bfh));
#ifdef _OPENMP #ifdef _OPENMP

4
rtengine/ipwavelet.cc
View File

@ -224,7 +224,7 @@ void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int kall, const
{wiprof[2][0], wiprof[2][1], wiprof[2][2]} {wiprof[2][0], wiprof[2][1], wiprof[2][2]}
}; };
const int imheight = lab->H, imwidth = lab->W; const int imheight = lab->H, imwidth = lab->W;
int levwavL; int levwavL = 0;
//Flat curve for H=f(H) in final touchup for guidedfilter //Flat curve for H=f(H) in final touchup for guidedfilter
FlatCurve* wavguidCurve = new FlatCurve(params->wavelet.wavguidcurve); //curve H=f(H) FlatCurve* wavguidCurve = new FlatCurve(params->wavelet.wavguidcurve); //curve H=f(H)
bool wavguidutili = false; bool wavguidutili = false;
@ -258,6 +258,8 @@ void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int kall, const
cp.complex = 0; cp.complex = 0;
} else if (params->wavelet.complexmethod == "expert") { } else if (params->wavelet.complexmethod == "expert") {
cp.complex = 1; cp.complex = 1;
} else {
cp.complex = 0;
} }

2
rtengine/metadata.cc
View File

@ -579,7 +579,7 @@ void Exiv2Metadata::init()
{ {
cache_.reset(new ImageCache(IMAGE_CACHE_SIZE)); cache_.reset(new ImageCache(IMAGE_CACHE_SIZE));
Exiv2::XmpParser::initialize(); Exiv2::XmpParser::initialize();
#ifdef EXV_ENABLE_BMFF #if defined EXV_ENABLE_BMFF && !EXIV2_TEST_VERSION(0, 28, 3)
Exiv2::enableBMFF(true); Exiv2::enableBMFF(true);
#endif #endif
} }

14
rtengine/rtthumbnail.cc
View File

@ -53,20 +53,6 @@
namespace namespace
{ {
bool checkRawImageThumb (const rtengine::RawImage& raw_image)
{
if (!raw_image.is_supportedThumb()) {
return false;
}
const ssize_t length =
fdata (raw_image.get_thumbOffset(), raw_image.get_file())[1] != 0xD8 && raw_image.is_ppmThumb()
? raw_image.get_thumbWidth() * raw_image.get_thumbHeight() * (raw_image.get_thumbBPS() / 8) * 3
: raw_image.get_thumbLength();
return raw_image.get_thumbOffset() + length <= raw_image.get_file()->size;
}
/** /**
* Apply the black level adjustments in the processing parameters. * Apply the black level adjustments in the processing parameters.
* *

1
rtgui/editorpanel.cc
View File

@ -299,6 +299,7 @@ void setUserOnlyPermission(const Glib::RefPtr<Gio::File> file, bool execute)
.grfAccessPermissions = FILE_ALL_ACCESS, .grfAccessPermissions = FILE_ALL_ACCESS,
.grfAccessMode = GRANT_ACCESS, .grfAccessMode = GRANT_ACCESS,
.grfInheritance = NO_INHERITANCE, .grfInheritance = NO_INHERITANCE,
.Trustee = {},
}; };
BuildTrusteeWithSid(&(ea.Trustee), user_sid); BuildTrusteeWithSid(&(ea.Trustee), user_sid);
PACL new_dacl_raw = nullptr; PACL new_dacl_raw = nullptr;

2
rtgui/main-cli.cc
View File

@ -273,6 +273,7 @@ int processLineParams ( int argc, char **argv )
case 'O': case 'O':
copyParamsFile = true; copyParamsFile = true;
// fall through
case 'o': // outputfile or dir case 'o': // outputfile or dir
if ( iArg + 1 < argc ) { if ( iArg + 1 < argc ) {
@ -324,6 +325,7 @@ int processLineParams ( int argc, char **argv )
case 'S': case 'S':
skipIfNoSidecar = true; skipIfNoSidecar = true;
// fall through
case 's': // Processing params next to file (file extension appended) case 's': // Processing params next to file (file extension appended)
sideProcParams = true; sideProcParams = true;

2
rtgui/main.cc
View File

@ -149,7 +149,7 @@ int processLineParams ( int argc, char **argv )
break; break;
} }
// no break here on purpose // fall through
case 'h': case 'h':
case '?': case '?':

8
rtgui/myflatcurve.cc
View File

@ -1598,7 +1598,8 @@ void MyFlatCurve::movePoint(bool moveX, bool moveY, bool pipetteDrag)
void MyFlatCurve::getCursorPosition(Gdk::EventType evType, bool isHint, int evX, int evY, Gdk::ModifierType modifierKey) void MyFlatCurve::getCursorPosition(Gdk::EventType evType, bool isHint, int evX, int evY, Gdk::ModifierType modifierKey)
{ {
int tx, ty; int tx, ty;
int prevCursorX, prevCursorY; int prevCursorX = cursorX;
int prevCursorY = cursorY;
double incrementX = 1. / double(graphW); double incrementX = 1. / double(graphW);
double incrementY = 1. / double(graphH); double incrementY = 1. / double(graphH);
@ -1627,11 +1628,6 @@ void MyFlatCurve::getCursorPosition(Gdk::EventType evType, bool isHint, int evX,
break; break;
} }
if (editedHandle != FCT_EditedHandle_None) {
prevCursorX = cursorX;
prevCursorY = cursorY;
}
cursorX = tx - graphX; cursorX = tx - graphX;
cursorY = graphY - ty; cursorY = graphY - ty;

4
rtgui/options.cc
View File

@ -370,7 +370,7 @@ void Options::setDefaults()
maxZoomLimit = MaxZoom::PERCENTS_1600; maxZoomLimit = MaxZoom::PERCENTS_1600;
#ifdef _WIN32 #ifdef _WIN32
// use windows setting for visibility of hidden files/folders // use windows setting for visibility of hidden files/folders
SHELLFLAGSTATE sft = { 0 }; SHELLFLAGSTATE sft = { };
SHGetSettings(&sft, SSF_SHOWALLOBJECTS); SHGetSettings(&sft, SSF_SHOWALLOBJECTS);
fbShowHidden = sft.fShowAllObjects; fbShowHidden = sft.fShowAllObjects;
#else #else
@ -1273,7 +1273,7 @@ void Options::readFromFile(Glib::ustring fname)
std::map<std::string, int> checkedExtensions; std::map<std::string, int> checkedExtensions;
if (parseExtensions.size() == parseExtensionsEnabled.size()) { if (parseExtensions.size() == parseExtensionsEnabled.size()) {
for (auto i = 0; i < parseExtensions.size(); ++i) { for (unsigned i = 0; i < parseExtensions.size(); ++i) {
checkedExtensions[parseExtensions[i]] = parseExtensionsEnabled[i]; checkedExtensions[parseExtensions[i]] = parseExtensionsEnabled[i];
} }
} }

2
rtgui/profilestorecombobox.cc
View File

@ -314,7 +314,7 @@ Gtk::TreeIter ProfileStoreComboBox::getRowFromLabel (const Glib::ustring &name)
const ProfileStoreEntry *pse = currRow[methodColumns.profileStoreEntry]; const ProfileStoreEntry *pse = currRow[methodColumns.profileStoreEntry];
if (pse->label == name) { if (pse->label == name) {
return std::move(currRow); return currRow;
} }
} }
} }

2
rtgui/rtimage.cc
View File

@ -56,6 +56,8 @@ void RTImageCache::updateCache()
RTImage::RTImage () {} RTImage::RTImage () {}
RTImage::RTImage (const Glib::ustring& iconName, const Gtk::IconSize iconSize) : RTImage::RTImage (const Glib::ustring& iconName, const Gtk::IconSize iconSize) :
sigc::trackable(),
Glib::ObjectBase(),
Gtk::Image(), Gtk::Image(),
size(iconSize), size(iconSize),
icon_name(iconName), icon_name(iconName),

4
rtgui/rtscalable.cc
View File

@ -87,7 +87,7 @@ Cairo::RefPtr<Cairo::ImageSurface> RTScalable::loadSurfaceFromIcon(const Glib::u
// Create surface from corresponding icon // Create surface from corresponding icon
const auto pos = iconPath.find_last_of('.'); const auto pos = iconPath.find_last_of('.');
if (pos >= 0 && pos < iconPath.length()) { if (pos < iconPath.length()) {
const auto fext = iconPath.substr(pos + 1, iconPath.length()).lowercase(); const auto fext = iconPath.substr(pos + 1, iconPath.length()).lowercase();
// Case where iconPath is a PNG file // Case where iconPath is a PNG file
@ -220,7 +220,7 @@ Cairo::RefPtr<Cairo::ImageSurface> RTScalable::loadSurfaceFromSVG(const Glib::us
return surf; return surf;
} }
rsvg_handle_free(handle); g_object_unref(handle);
// Set device scale to avoid blur effect // Set device scale to avoid blur effect
cairo_surface_set_device_scale(surf->cobj(), cairo_surface_set_device_scale(surf->cobj(),

2
rtgui/rtsurface.cc
View File

@ -57,7 +57,7 @@ RTSurface::RTSurface(const Glib::ustring &fname) :
// Create surface based on file extension // Create surface based on file extension
const auto pos = fname.find_last_of('.'); const auto pos = fname.find_last_of('.');
if (pos >= 0 && pos < fname.length()) { if (pos < fname.length()) {
const auto fext = fname.substr(pos + 1, fname.length()).lowercase(); const auto fext = fname.substr(pos + 1, fname.length()).lowercase();
// Case where fname is a PNG file // Case where fname is a PNG file

2
rtgui/thumbnail.cc
View File

@ -66,7 +66,7 @@ bool CPBDump(
} }
// open the file in write mode // open the file in write mode
const std::unique_ptr<FILE, decltype(&std::fclose)> f(g_fopen(commFName.c_str (), "wt"), &std::fclose); const std::unique_ptr<FILE, int (*)(FILE *)> f(g_fopen(commFName.c_str(), "wt"), &std::fclose);
if (!f) { if (!f) {
printf ("CPBDump(\"%s\") >>> Error: unable to open file with write access!\n", commFName.c_str()); printf ("CPBDump(\"%s\") >>> Error: unable to open file with write access!\n", commFName.c_str());

53
rtgui/toolpanelcoord.cc
View File

@ -40,129 +40,164 @@ using ToolTree = ToolPanelCoordinator::ToolTree;
const std::vector<ToolTree> EXPOSURE_PANEL_TOOLS = { const std::vector<ToolTree> EXPOSURE_PANEL_TOOLS = {
{ {
.id = Tool::TONE_CURVE, .id = Tool::TONE_CURVE,
.children = {},
}, },
{ {
.id = Tool::SHADOWS_HIGHLIGHTS, .id = Tool::SHADOWS_HIGHLIGHTS,
.children = {},
}, },
{ {
.id = Tool::TONE_EQUALIZER, .id = Tool::TONE_EQUALIZER,
.children = {},
}, },
{ {
.id = Tool::EPD, .id = Tool::EPD,
.children = {},
}, },
{ {
.id = Tool::FATTAL, .id = Tool::FATTAL,
.children = {},
}, },
{ {
.id = Tool::PC_VIGNETTE, .id = Tool::PC_VIGNETTE,
.children = {},
}, },
{ {
.id = Tool::GRADIENT, .id = Tool::GRADIENT,
.children = {},
}, },
{ {
.id = Tool::L_CURVE, .id = Tool::L_CURVE,
.children = {},
}, },
}; };
const std::vector<ToolTree> DETAILS_PANEL_TOOLS = { const std::vector<ToolTree> DETAILS_PANEL_TOOLS = {
{ {
.id = Tool::SPOT, .id = Tool::SPOT,
.children = {},
}, },
{ {
.id = Tool::SHARPENING_TOOL, .id = Tool::SHARPENING_TOOL,
.children = {},
}, },
{ {
.id = Tool::LOCAL_CONTRAST, .id = Tool::LOCAL_CONTRAST,
.children = {},
}, },
{ {
.id = Tool::SHARPEN_EDGE, .id = Tool::SHARPEN_EDGE,
.children = {},
}, },
{ {
.id = Tool::SHARPEN_MICRO, .id = Tool::SHARPEN_MICRO,
.children = {},
}, },
{ {
.id = Tool::IMPULSE_DENOISE, .id = Tool::IMPULSE_DENOISE,
.children = {},
}, },
{ {
.id = Tool::DIR_PYR_DENOISE, .id = Tool::DIR_PYR_DENOISE,
.children = {},
}, },
{ {
.id = Tool::DEFRINGE_TOOL, .id = Tool::DEFRINGE_TOOL,
.children = {},
}, },
{ {
.id = Tool::DIR_PYR_EQUALIZER, .id = Tool::DIR_PYR_EQUALIZER,
.children = {},
}, },
{ {
.id = Tool::DEHAZE, .id = Tool::DEHAZE,
.children = {},
}, },
}; };
const std::vector<ToolTree> COLOR_PANEL_TOOLS = { const std::vector<ToolTree> COLOR_PANEL_TOOLS = {
{ {
.id = Tool::WHITE_BALANCE, .id = Tool::WHITE_BALANCE,
.children = {},
}, },
{ {
.id = Tool::COMPRESSGAMUT_TOOL, .id = Tool::COMPRESSGAMUT_TOOL,
}, },
{ {
.id = Tool::VIBRANCE, .id = Tool::VIBRANCE,
.children = {},
}, },
{ {
.id = Tool::CH_MIXER, .id = Tool::CH_MIXER,
.children = {},
}, },
{ {
.id = Tool::BLACK_WHITE, .id = Tool::BLACK_WHITE,
.children = {},
}, },
{ {
.id = Tool::HSV_EQUALIZER, .id = Tool::HSV_EQUALIZER,
.children = {},
}, },
{ {
.id = Tool::FILM_SIMULATION, .id = Tool::FILM_SIMULATION,
.children = {},
}, },
{ {
.id = Tool::FILM_NEGATIVE, .id = Tool::FILM_NEGATIVE,
.children = {},
}, },
{ {
.id = Tool::SOFT_LIGHT, .id = Tool::SOFT_LIGHT,
.children = {},
}, },
{ {
.id = Tool::RGB_CURVES, .id = Tool::RGB_CURVES,
.children = {},
}, },
{ {
.id = Tool::COLOR_TONING, .id = Tool::COLOR_TONING,
.children = {},
}, },
{ {
.id = Tool::ICM, .id = Tool::ICM,
.children = {},
}, },
}; };
const std::vector<ToolTree> ADVANCED_PANEL_TOOLS = { const std::vector<ToolTree> ADVANCED_PANEL_TOOLS = {
{ {
.id = Tool::RETINEX_TOOL, .id = Tool::RETINEX_TOOL,
.children = {},
}, },
{ {
.id = Tool::COLOR_APPEARANCE, .id = Tool::COLOR_APPEARANCE,
.children = {},
}, },
{ {
.id = Tool::WAVELET, .id = Tool::WAVELET,
.children = {},
}, },
}; };
const std::vector<ToolTree> LOCALLAB_PANEL_TOOLS = { const std::vector<ToolTree> LOCALLAB_PANEL_TOOLS = {
{ {
.id = Tool::LOCALLAB, .id = Tool::LOCALLAB,
.children = {},
}, },
}; };
const std::vector<ToolTree> TRANSFORM_PANEL_TOOLS = { const std::vector<ToolTree> TRANSFORM_PANEL_TOOLS = {
{ {
.id = Tool::CROP_TOOL, .id = Tool::CROP_TOOL,
.children = {},
}, },
{ {
.id = Tool::RESIZE_TOOL, .id = Tool::RESIZE_TOOL,
.children = { .children = {
{ {
.id = Tool::PR_SHARPENING, .id = Tool::PR_SHARPENING,
.children = {},
}, },
{ {
.id = Tool::FRAMING, .id = Tool::FRAMING,
@ -174,21 +209,27 @@ const std::vector<ToolTree> TRANSFORM_PANEL_TOOLS = {
.children = { .children = {
{ {
.id = Tool::ROTATE, .id = Tool::ROTATE,
.children = {},
}, },
{ {
.id = Tool::PERSPECTIVE, .id = Tool::PERSPECTIVE,
.children = {},
}, },
{ {
.id = Tool::LENS_PROF, .id = Tool::LENS_PROF,
.children = {},
}, },
{ {
.id = Tool::DISTORTION, .id = Tool::DISTORTION,
.children = {},
}, },
{ {
.id = Tool::CA_CORRECTION, .id = Tool::CA_CORRECTION,
.children = {},
}, },
{ {
.id = Tool::VIGNETTING, .id = Tool::VIGNETTING,
.children = {},
}, },
}, },
}, },
@ -201,15 +242,19 @@ const std::vector<ToolTree> RAW_PANEL_TOOLS = {
{ {
{ {
.id = Tool::BAYER_PROCESS, .id = Tool::BAYER_PROCESS,
.children = {},
}, },
{ {
.id = Tool::BAYER_RAW_EXPOSURE, .id = Tool::BAYER_RAW_EXPOSURE,
.children = {},
}, },
{ {
.id = Tool::BAYER_PREPROCESS, .id = Tool::BAYER_PREPROCESS,
.children = {},
}, },
{ {
.id = Tool::RAW_CA_CORRECTION, .id = Tool::RAW_CA_CORRECTION,
.children = {},
}, },
}, },
}, },
@ -220,30 +265,38 @@ const std::vector<ToolTree> RAW_PANEL_TOOLS = {
{ {
{ {
.id = Tool::XTRANS_PROCESS, .id = Tool::XTRANS_PROCESS,
.children = {},
}, },
{ {
.id = Tool::XTRANS_RAW_EXPOSURE, .id = Tool::XTRANS_RAW_EXPOSURE,
.children = {},
}, },
}, },
}, },
}, },
{ {
.id = Tool::RAW_EXPOSURE, .id = Tool::RAW_EXPOSURE,
.children = {},
}, },
{ {
.id = Tool::PREPROCESS_WB, .id = Tool::PREPROCESS_WB,
.children = {},
}, },
{ {
.id = Tool::PREPROCESS, .id = Tool::PREPROCESS,
.children = {},
}, },
{ {
.id = Tool::DARKFRAME_TOOL, .id = Tool::DARKFRAME_TOOL,
.children = {},
}, },
{ {
.id = Tool::FLATFIELD_TOOL, .id = Tool::FLATFIELD_TOOL,
.children = {},
}, },
{ {
.id = Tool::PD_SHARPENING, .id = Tool::PD_SHARPENING,
.children = {},
}, },
}; };