diff options
| author | giraffedata <giraffedata@9d0c8265-081b-0410-96cb-a4ca84ce46f8> | 2014-09-26 16:03:01 +0000 |
|---|---|---|
| committer | giraffedata <giraffedata@9d0c8265-081b-0410-96cb-a4ca84ce46f8> | 2014-09-26 16:03:01 +0000 |
| commit | 67e1689f9d7e6b8dfffe393f2d318e3e374c7a36 (patch) | |
| tree | 5943a3e98e1f12ed80d92e2cb8c5623d8af9fcd3 /converter | |
| parent | fd6e24ededb4ee1e92e101ea50fe21d88630c17f (diff) | |
| download | netpbm-mirror-67e1689f9d7e6b8dfffe393f2d318e3e374c7a36.tar.gz netpbm-mirror-67e1689f9d7e6b8dfffe393f2d318e3e374c7a36.tar.xz netpbm-mirror-67e1689f9d7e6b8dfffe393f2d318e3e374c7a36.zip | |
Promote current development as Release 10.68
git-svn-id: http://svn.code.sf.net/p/netpbm/code/advanced@2294 9d0c8265-081b-0410-96cb-a4ca84ce46f8
Diffstat (limited to 'converter')
32 files changed, 1157 insertions, 1011 deletions
diff --git a/converter/other/cameratopam/camera.c b/converter/other/cameratopam/camera.c index 4008dbb2..14d208e3 100644 --- a/converter/other/cameratopam/camera.c +++ b/converter/other/cameratopam/camera.c @@ -17,6 +17,7 @@ #include "mallocvar.h" #include "global_variables.h" +#include "cameratopam.h" #include "util.h" #include "decode.h" #include "bayer.h" @@ -55,67 +56,76 @@ merror (const void *ptr, const char *where) static void -adobe_copy_pixel (int row, int col, unsigned short **rp, bool use_secondary) -{ - unsigned r=row, c=col; - - if (fuji_secondary && use_secondary) (*rp)++; - if (filters) { - if (fuji_width) { - r = row + fuji_width - 1 - (col >> 1); - c = row + ((col+1) >> 1); - } - if (r < height && c < width) - BAYER(r,c) = **rp < 0x1000 ? curve[**rp] : **rp; - *rp += 1 + fuji_secondary; - } else - for (c=0; c < tiff_samples; c++) { - image[row*width+col][c] = **rp < 0x1000 ? curve[**rp] : **rp; - (*rp)++; +adobeCopyPixel(Image const image, + unsigned int const row, + unsigned int const col, + unsigned short ** const rp, + bool const useSecondary) { + + unsigned r=row, c=col; + + if (fuji_secondary && useSecondary) + ++(*rp); + if (filters) { + if (fuji_width) { + r = row + fuji_width - 1 - (col >> 1); + c = row + ((col+1) >> 1); + } + if (r < height && c < width) + BAYER(r,c) = **rp < 0x1000 ? curve[**rp] : **rp; + *rp += 1 + fuji_secondary; + } else { + unsigned int c; + for (c = 0; c < tiff_samples; ++c) { + image[row*width+col][c] = **rp < 0x1000 ? curve[**rp] : **rp; + ++(*rp); + } } - if (fuji_secondary && use_secondary) (*rp)--; + if (fuji_secondary && useSecondary) + --(*rp); } void -adobe_dng_load_raw_lj() -{ - int save, twide, trow=0, tcol=0, jrow, jcol; - struct jhead jh; - unsigned short *rp; +adobe_dng_load_raw_lj(Image const image) { - while (1) { - save = ftell(ifp); - fseek (ifp, get4(ifp), SEEK_SET); - if (!ljpeg_start (ifp, &jh)) break; - if (trow >= raw_height) break; - if (jh.high > raw_height-trow) - jh.high = raw_height-trow; - twide = jh.wide; - if (filters) twide *= jh.clrs; - else colors = jh.clrs; - if (fuji_secondary) twide /= 2; - if (twide > raw_width-tcol) - twide = raw_width-tcol; - - for (jrow=0; jrow < jh.high; jrow++) { - ljpeg_row (&jh); - for (rp=jh.row, jcol=0; jcol < twide; jcol++) - adobe_copy_pixel (trow+jrow, tcol+jcol, &rp, use_secondary); - } - fseek (ifp, save+4, SEEK_SET); - if ((tcol += twide) >= raw_width) { - tcol = 0; - trow += jh.high; + int save, twide, trow=0, tcol=0, jrow, jcol; + struct jhead jh; + unsigned short *rp; + + while (1) { + save = ftell(ifp); + fseek (ifp, get4(ifp), SEEK_SET); + if (!ljpeg_start (ifp, &jh)) break; + if (trow >= raw_height) break; + if (jh.high > raw_height-trow) + jh.high = raw_height-trow; + twide = jh.wide; + if (filters) twide *= jh.clrs; + else colors = jh.clrs; + if (fuji_secondary) twide /= 2; + if (twide > raw_width-tcol) + twide = raw_width-tcol; + + for (jrow=0; jrow < jh.high; jrow++) { + ljpeg_row (&jh); + for (rp=jh.row, jcol=0; jcol < twide; jcol++) + adobeCopyPixel(image, + trow+jrow, tcol+jcol, &rp, use_secondary); + } + fseek (ifp, save+4, SEEK_SET); + if ((tcol += twide) >= raw_width) { + tcol = 0; + trow += jh.high; + } + free (jh.row); } - free (jh.row); - } } void -adobe_dng_load_raw_nc() -{ +adobe_dng_load_raw_nc(Image const image) { + unsigned short *pixel, *rp; int row, col; @@ -124,7 +134,7 @@ adobe_dng_load_raw_nc() for (row=0; row < raw_height; row++) { read_shorts (ifp, pixel, raw_width * tiff_samples); for (rp=pixel, col=0; col < raw_width; col++) - adobe_copy_pixel (row, col, &rp, use_secondary); + adobeCopyPixel(image, row, col, &rp, use_secondary); } free (pixel); } @@ -134,8 +144,8 @@ adobe_dng_load_raw_nc() static int nikon_curve_offset; void -nikon_compressed_load_raw(void) -{ +nikon_compressed_load_raw(Image const image) { + static const unsigned char nikon_tree[] = { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0, 5,4,3,6,2,7,1,0,8,9,11,10,12 @@ -176,8 +186,8 @@ nikon_compressed_load_raw(void) } void -nikon_load_raw() -{ +nikon_load_raw(Image const image) { + int irow, row, col, i; getbits(ifp, -1); @@ -294,8 +304,8 @@ minolta_z2() } void -nikon_e2100_load_raw() -{ +nikon_e2100_load_raw(Image const image) { + unsigned char data[3432], *dp; unsigned short pixel[2288], *pix; int row, col; @@ -322,8 +332,8 @@ nikon_e2100_load_raw() } void -nikon_e950_load_raw() -{ +nikon_e950_load_raw(Image const image) { + int irow, row, col; getbits(ifp, -1); @@ -341,8 +351,7 @@ nikon_e950_load_raw() The Fuji Super CCD is just a Bayer grid rotated 45 degrees. */ void -fuji_s2_load_raw() -{ +fuji_s2_load_raw(Image const image) { unsigned short pixel[2944]; int row, col, r, c; @@ -358,8 +367,7 @@ fuji_s2_load_raw() } void -fuji_s3_load_raw() -{ +fuji_s3_load_raw(Image const image) { unsigned short pixel[4352]; int row, col, r, c; @@ -374,42 +382,52 @@ fuji_s3_load_raw() } } -static void fuji_common_load_raw (int ncol, int icol, int nrow) -{ - unsigned short pixel[2048]; - int row, col, r, c; - - for (row=0; row < nrow; row++) { - read_shorts(ifp, pixel, ncol); - for (col=0; col <= icol; col++) { - r = icol - col + (row >> 1); - c = col + ((row+1) >> 1); - BAYER(r,c) = pixel[col]; +static void +fuji_common_load_raw(Image const image, + unsigned int const ncol, + unsigned int const icol, + unsigned int const nrow) { + + unsigned short pixel[2048]; + unsigned int row; + + for (row = 0; row < nrow; ++row) { + unsigned int col; + read_shorts(ifp, pixel, ncol); + for (col = 0; col <= icol; ++col) { + int const r = icol - col + (row >> 1); + int const c = col + ((row+1) >> 1); + BAYER(r,c) = pixel[col]; + } } - } } + + void -fuji_s5000_load_raw() -{ +fuji_s5000_load_raw(Image const image) { + fseek (ifp, (1472*4+24)*2, SEEK_CUR); - fuji_common_load_raw (1472, 1423, 2152); + fuji_common_load_raw(image, 1472, 1423, 2152); } + + void -fuji_s7000_load_raw() -{ - fuji_common_load_raw (2048, 2047, 3080); +fuji_s7000_load_raw(Image const image) { + + fuji_common_load_raw(image, 2048, 2047, 3080); } + + /* The Fuji Super CCD SR has two photodiodes for each pixel. The secondary has about 1/16 the sensitivity of the primary, but this ratio may vary. */ void -fuji_f700_load_raw() -{ +fuji_f700_load_raw(Image const image) { unsigned short pixel[2944]; int row, col, r, c, val; @@ -425,8 +443,7 @@ fuji_f700_load_raw() } void -rollei_load_raw() -{ +rollei_load_raw(Image const image) { unsigned char pixel[10]; unsigned iten=0, isix, i, buffer=0, row, col, todo[16]; @@ -452,8 +469,7 @@ rollei_load_raw() } void -phase_one_load_raw() -{ +phase_one_load_raw(Image const image) { int row, col, a, b; unsigned short *pixel, akey, bkey; @@ -479,8 +495,7 @@ phase_one_load_raw() } void -ixpress_load_raw() -{ +ixpress_load_raw(Image const image) { unsigned short pixel[4090]; int row, col; @@ -494,8 +509,7 @@ ixpress_load_raw() } void -leaf_load_raw() -{ +leaf_load_raw(Image const image) { unsigned short *pixel; int r, c, row, col; @@ -514,8 +528,7 @@ leaf_load_raw() For this function only, raw_width is in bytes, not pixels! */ void -packed_12_load_raw() -{ +packed_12_load_raw(Image const image) { int row, col; getbits(ifp, -1); @@ -528,8 +541,7 @@ packed_12_load_raw() } void -unpacked_load_raw() -{ +unpacked_load_raw(Image const image) { unsigned short *pixel; int row, col; @@ -544,8 +556,7 @@ unpacked_load_raw() } void -olympus_e300_load_raw() -{ +olympus_e300_load_raw(Image const image) { unsigned char *data, *dp; unsigned short *pixel, *pix; int dwide, row, col; @@ -568,8 +579,7 @@ olympus_e300_load_raw() } void -olympus_cseries_load_raw() -{ +olympus_cseries_load_raw(Image const image) { int irow, row, col; for (irow=0; irow < height; irow++) { @@ -584,8 +594,7 @@ olympus_cseries_load_raw() } void -eight_bit_load_raw() -{ +eight_bit_load_raw(Image const image) { unsigned char *pixel; int row, col; @@ -601,8 +610,7 @@ eight_bit_load_raw() } void -casio_qv5700_load_raw() -{ +casio_qv5700_load_raw(Image const image) { unsigned char data[3232], *dp; unsigned short pixel[2576], *pix; int row, col; @@ -622,8 +630,7 @@ casio_qv5700_load_raw() } void -nucore_load_raw() -{ +nucore_load_raw(Image const image) { unsigned short *pixel; int irow, row, col; @@ -685,8 +692,7 @@ static int radc_token (int tree) : (buf[c][y-1][x+1] + 2*buf[c][y-1][x] + buf[c][y][x+1]) / 4) void -kodak_radc_load_raw() -{ +kodak_radc_load_raw(Image const image) { int row, col, tree, nreps, rep, step, c, s, r, x, y, val; unsigned int i; short last[3] = { 16,16,16 }, mul[3], buf[3][3][386]; @@ -765,7 +771,8 @@ kodak_radc_load_raw() #undef PREDICTOR #ifndef HAVE_JPEG -void kodak_jpeg_load_raw() {} +void +kodak_jpeg_load_raw(Image const Image) {} #else static bool @@ -782,7 +789,7 @@ fill_input_buffer (j_decompress_ptr cinfo) } void -kodak_jpeg_load_raw() +kodak_jpeg_load_raw(Image const image) { struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; @@ -823,7 +830,7 @@ kodak_jpeg_load_raw() #endif void -kodak_dc120_load_raw() +kodak_dc120_load_raw(Image const image) { static const int mul[4] = { 162, 192, 187, 92 }; static const int add[4] = { 0, 636, 424, 212 }; @@ -859,7 +866,7 @@ kodak_dc20_coeff (float const juice) } void -kodak_easy_load_raw() +kodak_easy_load_raw(Image const image) { unsigned char *pixel; unsigned row, col, icol; @@ -887,7 +894,7 @@ kodak_easy_load_raw() } void -kodak_compressed_load_raw() +kodak_compressed_load_raw(Image const image) { unsigned char c, blen[256]; unsigned short raw[6]; @@ -951,7 +958,7 @@ kodak_compressed_load_raw() } void -kodak_yuv_load_raw() +kodak_yuv_load_raw(Image const image) { unsigned char c, blen[384]; unsigned row, col, len, bits=0; @@ -1042,7 +1049,7 @@ static void sony_decrypt (unsigned *data, int len, int start, int key) } void -sony_load_raw() +sony_load_raw(Image const image) { unsigned char head[40]; struct pixel { @@ -1310,12 +1317,6 @@ parse_mos(FILE * const ifp, fread (data, 1, 40, ifp); skip = get4(ifp); from = ftell(ifp); -#ifdef USE_LCMS - if (!strcmp(data,"icc_camera_profile")) { - profile_length = skip; - profile_offset = from; - } -#endif if (!strcmp(data,"NeutObj_neutrals")) { for (i=0; i < 4; i++) fscanf (ifp, "%d", neut+i); diff --git a/converter/other/cameratopam/camera.h b/converter/other/cameratopam/camera.h index a1e884cf..02c3f2af 100644 --- a/converter/other/cameratopam/camera.h +++ b/converter/other/cameratopam/camera.h @@ -1,5 +1,10 @@ +#ifndef CAMERA_H_INCLUDED +#define CAMERA_H_INCLUDED + #include <stdio.h> +#include "cameratopam.h" + void parse_ciff(FILE * const ifp, int const offset, @@ -21,20 +26,18 @@ void parse_mos(FILE * const ifp, int const offset); -void -adobe_dng_load_raw_lj(void); +typedef void LoadRawFn(Image const image); -void -adobe_dng_load_raw_nc(void); +LoadRawFn adobe_dng_load_raw_lj; + +LoadRawFn adobe_dng_load_raw_nc; int nikon_is_compressed(void); -void -nikon_compressed_load_raw(void); +LoadRawFn nikon_compressed_load_raw; -void -nikon_e950_load_raw(void); +LoadRawFn nikon_e950_load_raw; void nikon_e950_coeff(void); @@ -45,87 +48,63 @@ nikon_e990(void); int nikon_e2100(void); -void -nikon_e2100_load_raw(void); +LoadRawFn nikon_e2100_load_raw; int minolta_z2(void); -void -fuji_s2_load_raw(void); +LoadRawFn fuji_s2_load_raw; -void -fuji_s3_load_raw(void); +LoadRawFn fuji_s3_load_raw; -void -fuji_s5000_load_raw(void); +LoadRawFn fuji_s5000_load_raw; -void -unpacked_load_raw(void); +LoadRawFn unpacked_load_raw; -void -fuji_s7000_load_raw(void); +LoadRawFn fuji_s7000_load_raw; -void -fuji_f700_load_raw(void); +LoadRawFn fuji_f700_load_raw; -void -packed_12_load_raw(void); +LoadRawFn packed_12_load_raw; -void -eight_bit_load_raw(void); +LoadRawFn eight_bit_load_raw; -void -phase_one_load_raw(void); +LoadRawFn phase_one_load_raw; -void -ixpress_load_raw(void); +LoadRawFn ixpress_load_raw; -void -leaf_load_raw(void); +LoadRawFn leaf_load_raw; -void -olympus_e300_load_raw(void); +LoadRawFn olympus_e300_load_raw; -void -olympus_cseries_load_raw(void); +LoadRawFn olympus_cseries_load_raw; -void -sony_load_raw(void); +LoadRawFn sony_load_raw; -void -kodak_easy_load_raw(void); +LoadRawFn kodak_easy_load_raw; -void -kodak_compressed_load_raw(void); +LoadRawFn kodak_compressed_load_raw; -void -kodak_yuv_load_raw(void); +LoadRawFn kodak_yuv_load_raw; void kodak_dc20_coeff (float const juice); -void -kodak_radc_load_raw(void); +LoadRawFn kodak_radc_load_raw; -void -kodak_jpeg_load_raw(void); +LoadRawFn kodak_jpeg_load_raw; -void -kodak_dc120_load_raw(void); +LoadRawFn kodak_dc120_load_raw; -void -rollei_load_raw(void); +LoadRawFn rollei_load_raw; -void -casio_qv5700_load_raw(void); +LoadRawFn casio_qv5700_load_raw; -void -nucore_load_raw(void); +LoadRawFn nucore_load_raw; -void -nikon_load_raw(void); +LoadRawFn nikon_load_raw; int pentax_optio33(void); +#endif diff --git a/converter/other/cameratopam/cameratopam.c b/converter/other/cameratopam/cameratopam.c index 71c9c7af..40d8207f 100644 --- a/converter/other/cameratopam/cameratopam.c +++ b/converter/other/cameratopam/cameratopam.c @@ -8,7 +8,8 @@ #define _BSD_SOURCE 1 /* Make sure string.h contains strdup() */ -#define _XOPEN_SOURCE /* Make sure unistd.h contains swab() */ +#define _XOPEN_SOURCE 500 + /* Make sure unistd.h contains swab(), string.h constains strdup() */ #include "pm_config.h" @@ -38,6 +39,7 @@ #include "pam.h" #include "global_variables.h" +#include "cameratopam.h" #include "util.h" #include "decode.h" #include "identify.h" @@ -61,22 +63,19 @@ int height, width, fuji_width, colors, tiff_samples; int black, maximum, clip_max; int iheight, iwidth, shrink; int is_dng, is_canon, is_foveon, use_coeff, use_gamma; -int trim, flip, xmag, ymag; +int flip, xmag, ymag; int zero_after_ff; unsigned filters; -unsigned short (*image)[4], white[8][8], curve[0x1000]; +unsigned short white[8][8]; +unsigned short curve[0x1000]; int fuji_secondary; -float cam_mul[4], pre_mul[4], coeff[3][4]; +float cam_mul[4], coeff[3][4]; +float pre_mul[4]; int histogram[3][0x2000]; jmp_buf failure; int use_secondary; bool verbose; -#ifdef USE_LCMS -#include <lcms.h> -int profile_offset, profile_length; -#endif - #define CLASS #define FORC3 for (c=0; c < 3; c++) @@ -88,7 +87,7 @@ static void CLASS merror (const void *ptr, const char *where) pm_error ("Out of memory in %s", where); } -struct cmdlineInfo { +struct CmdlineInfo { /* All the information the user supplied in the command line, in a form easy for the program to use. */ @@ -112,11 +111,11 @@ struct cmdlineInfo { }; -static struct cmdlineInfo cmdline; +static struct CmdlineInfo cmdline; static void parseCommandLine(int argc, char ** argv, - struct cmdlineInfo *cmdlineP) { + struct CmdlineInfo *cmdlineP) { /*---------------------------------------------------------------------------- Note that many of the strings that this function returns in the *cmdlineP structure are actually in the supplied argv array. And @@ -191,615 +190,694 @@ parseCommandLine(int argc, char ** argv, } -/* - Seach from the current directory up to the root looking for - a ".badpixels" file, and fix those pixels now. - */ -static void CLASS bad_pixels() -{ - FILE *fp=NULL; - char *fname, *cp, line[128]; - int len, time, row, col, r, c, rad, tot, n, fixed=0; - - if (!filters) return; - for (len=16 ; ; len *= 2) { - fname = malloc (len); - if (!fname) return; - if (getcwd (fname, len-12)) break; - free (fname); - if (errno != ERANGE) return; - } + +static void CLASS +fixBadPixels(Image const image) { +/*---------------------------------------------------------------------------- + Search from the current directory up to the root looking for + a ".badpixels" file, and fix those pixels now. +-----------------------------------------------------------------------------*/ + if (filters) { + FILE *fp; + char *fname, *cp, line[128]; + int len, time, row, col, rad, tot, n, fixed=0; + + for (len=16 ; ; len *= 2) { + fname = malloc (len); + if (!fname) return; + if (getcwd (fname, len-12)) + break; + free (fname); + if (errno != ERANGE) + return; + } #if MSVCRT - if (fname[1] == ':') - memmove (fname, fname+2, len-2); - for (cp=fname; *cp; cp++) - if (*cp == '\\') *cp = '/'; + if (fname[1] == ':') + memmove (fname, fname+2, len-2); + for (cp=fname; *cp; cp++) + if (*cp == '\\') *cp = '/'; #endif - cp = fname + strlen(fname); - if (cp[-1] == '/') cp--; - while (*fname == '/') { - strcpy (cp, "/.badpixels"); - if ((fp = fopen (fname, "r"))) break; - if (cp == fname) break; - while (*--cp != '/'); - } - free (fname); - if (!fp) return; - while (fgets (line, 128, fp)) { - cp = strchr (line, '#'); - if (cp) *cp = 0; - if (sscanf (line, "%d %d %d", &col, &row, &time) != 3) continue; - if ((unsigned) col >= width || (unsigned) row >= height) continue; - if (time > timestamp) continue; - for (tot=n=0, rad=1; rad < 3 && n==0; rad++) - for (r = row-rad; r <= row+rad; r++) - for (c = col-rad; c <= col+rad; c++) - if ((unsigned) r < height && (unsigned) c < width && - (r != row || c != col) && FC(r,c) == FC(row,col)) { - tot += BAYER(r,c); - n++; - } - BAYER(row,col) = tot/n; - if (cmdline.verbose) { - if (!fixed++) - pm_message ("Fixed bad pixels at: %d,%d", col, row); + cp = fname + strlen(fname); + if (cp[-1] == '/') + --cp; + fp = NULL; /* initial value */ + while (*fname == '/') { + strcpy (cp, "/.badpixels"); + fp = fopen (fname, "r"); + if (fp) + break; + if (cp == fname) + break; + while (*--cp != '/'); + } + free (fname); + if (fp) { + while (fgets (line, 128, fp)) { + char * cp; + cp = strchr (line, '#'); + if (cp) *cp = 0; + if (sscanf (line, "%d %d %d", &col, &row, &time) != 3) + continue; + if ((unsigned) col >= width || (unsigned) row >= height) + continue; + if (time > timestamp) continue; + for (tot=n=0, rad=1; rad < 3 && n==0; rad++) { + unsigned int r; + for (r = row-rad; r <= row+rad; ++r) { + unsigned int c; + for (c = col-rad; c <= col+rad; ++c) { + if ((unsigned) r < height && + (unsigned) c < width && + (r != row || c != col) && + FC(r,c) == FC(row,col)) { + tot += BAYER(r,c); + ++n; + } + } + } + } + BAYER(row,col) = tot/n; + if (cmdline.verbose) { + if (!fixed++) + pm_message ("Fixed bad pixels at: %d,%d", col, row); + } + } + fclose (fp); + } } - } - fclose (fp); } -static void CLASS scale_colors() -{ - int row, col, c, val, shift=0; - int min[4], max[4], count[4]; - double sum[4], dmin; - - maximum -= black; - if (cmdline.use_auto_wb || (cmdline.use_camera_wb && camera_red == -1)) { - FORC4 min[c] = INT_MAX; - FORC4 max[c] = count[c] = sum[c] = 0; - for (row=0; row < height; row++) - for (col=0; col < width; col++) - FORC4 { - val = image[row*width+col][c]; - if (!val) continue; - if (min[c] > val) min[c] = val; - if (max[c] < val) max[c] = val; - val -= black; - if (val > maximum-25) continue; - if (val < 0) val = 0; - sum[c] += val; - count[c]++; + + +static void CLASS +scaleColors(Image const image) { + + int row; + int c; + int val; + int shift; + int min[4], max[4], count[4]; + double sum[4], dmin; + int scaleMax; + + scaleMax = maximum - black; /* initial value */ + if (cmdline.use_auto_wb || (cmdline.use_camera_wb && camera_red == -1)) { + unsigned int row; + FORC4 min [c] = INT_MAX; + FORC4 max [c] = 0; + FORC4 count[c] = 0; + FORC4 sum [c] = 0; + for (row = 0; row < height; ++row) { + unsigned int col; + for (col = 0; col < width; ++col) { + FORC4 { + int val; + val = image[row*width+col][c]; + if (val != 0) { + if (min[c] > val) + min[c] = val; + if (max[c] < val) + max[c] = val; + val -= black; + if (val <= scaleMax-25) { + sum [c] += MAX(0, val); + count[c] += 1; + } + } + } + } + } + FORC4 pre_mul[c] = count[c] / sum[c]; } - FORC4 pre_mul[c] = count[c] / sum[c]; - } - if (cmdline.use_camera_wb && camera_red != -1) { - FORC4 count[c] = sum[c] = 0; - for (row=0; row < 8; row++) - for (col=0; col < 8; col++) { - c = FC(row,col); - if ((val = white[row][col] - black) > 0) - sum[c] += val; - count[c]++; - } - val = 1; - FORC4 if (sum[c] == 0) val = 0; - if (val) - FORC4 pre_mul[c] = count[c] / sum[c]; - else if (camera_red && camera_blue) - memcpy (pre_mul, cam_mul, sizeof pre_mul); - else - pm_message ("Cannot use camera white balance."); - } - if (!use_coeff) { - pre_mul[0] *= cmdline.red_scale; - pre_mul[2] *= cmdline.blue_scale; - } - dmin = DBL_MAX; - FORC4 if (dmin > pre_mul[c]) + if (cmdline.use_camera_wb && camera_red != -1) { + unsigned int row; + FORC4 count[c] = sum[c] = 0; + for (row = 0; row < 8; ++row) { + unsigned int col; + for (col = 0; col < 8; ++col) { + c = FC(row,col); + if ((val = white[row][col] - black) > 0) + sum[c] += val; + ++count[c]; + } + } + val = 1; + FORC4 if (sum[c] == 0) val = 0; + if (val) + FORC4 pre_mul[c] = count[c] / sum[c]; + else if (camera_red && camera_blue) + memcpy(pre_mul, cam_mul, sizeof pre_mul); + else + pm_message ("Cannot use camera white balance."); + } + if (!use_coeff) { + pre_mul[0] *= cmdline.red_scale; + pre_mul[2] *= cmdline.blue_scale; + } + dmin = DBL_MAX; + FORC4 if (dmin > pre_mul[c]) dmin = pre_mul[c]; - FORC4 pre_mul[c] /= dmin; - - while (maximum << shift < 0x8000) shift++; - FORC4 pre_mul[c] *= 1 << shift; - maximum <<= shift; - - if (cmdline.linear || cmdline.bright < 1) { - maximum *= cmdline.bright; - if (maximum > 0xffff) - maximum = 0xffff; - FORC4 pre_mul[c] *= cmdline.bright; - } - if (cmdline.verbose) { - fprintf (stderr, "Scaling with black=%d, pre_mul[] =", black); - FORC4 fprintf (stderr, " %f", pre_mul[c]); - fputc ('\n', stderr); - } - clip_max = cmdline.no_clip_color ? 0xffff : maximum; - for (row=0; row < height; row++) - for (col=0; col < width; col++) - FORC4 { - val = image[row*width+col][c]; - if (!val) continue; - val -= black; - val *= pre_mul[c]; - if (val < 0) val = 0; - if (val > clip_max) val = clip_max; - image[row*width+col][c] = val; - } -} - -/* - This algorithm is officially called: + FORC4 pre_mul[c] /= dmin; - "Interpolation using a Threshold-based variable number of gradients" + for (shift = 0; scaleMax << shift < 0x8000; ++shift); - described in http://www-ise.stanford.edu/~tingchen/algodep/vargra.html + FORC4 pre_mul[c] *= 1 << shift; + scaleMax <<= shift; - I've extended the basic idea to work with non-Bayer filter arrays. - Gradients are numbered clockwise from NW=0 to W=7. - */ -static void CLASS vng_interpolate() -{ - static const signed char *cp, terms[] = { - -2,-2,+0,-1,0,(char)0x01, -2,-2,+0,+0,1,(char)0x01, -2,-1,-1,+0,0,(char)0x01, - -2,-1,+0,-1,0,(char)0x02, -2,-1,+0,+0,0,(char)0x03, -2,-1,+0,+1,1,(char)0x01, - -2,+0,+0,-1,0,(char)0x06, -2,+0,+0,+0,1,(char)0x02, -2,+0,+0,+1,0,(char)0x03, - -2,+1,-1,+0,0,(char)0x04, -2,+1,+0,-1,1,(char)0x04, -2,+1,+0,+0,0,(char)0x06, - -2,+1,+0,+1,0,(char)0x02, -2,+2,+0,+0,1,(char)0x04, -2,+2,+0,+1,0,(char)0x04, - -1,-2,-1,+0,0,(char)0x80, -1,-2,+0,-1,0,(char)0x01, -1,-2,+1,-1,0,(char)0x01, - -1,-2,+1,+0,1,(char)0x01, -1,-1,-1,+1,0,(char)0x88, -1,-1,+1,-2,0,(char)0x40, - -1,-1,+1,-1,0,(char)0x22, -1,-1,+1,+0,0,(char)0x33, -1,-1,+1,+1,1,(char)0x11, - -1,+0,-1,+2,0,(char)0x08, -1,+0,+0,-1,0,(char)0x44, -1,+0,+0,+1,0,(char)0x11, - -1,+0,+1,-2,1,(char)0x40, -1,+0,+1,-1,0,(char)0x66, -1,+0,+1,+0,1,(char)0x22, - -1,+0,+1,+1,0,(char)0x33, -1,+0,+1,+2,1,(char)0x10, -1,+1,+1,-1,1,(char)0x44, - -1,+1,+1,+0,0,(char)0x66, -1,+1,+1,+1,0,(char)0x22, -1,+1,+1,+2,0,(char)0x10, - -1,+2,+0,+1,0,(char)0x04, -1,+2,+1,+0,1,(char)0x04, -1,+2,+1,+1,0,(char)0x04, - +0,-2,+0,+0,1,(char)0x80, +0,-1,+0,+1,1,(char)0x88, +0,-1,+1,-2,0,(char)0x40, - +0,-1,+1,+0,0,(char)0x11, +0,-1,+2,-2,0,(char)0x40, +0,-1,+2,-1,0,(char)0x20, - +0,-1,+2,+0,0,(char)0x30, +0,-1,+2,+1,1,(char)0x10, +0,+0,+0,+2,1,(char)0x08, - +0,+0,+2,-2,1,(char)0x40, +0,+0,+2,-1,0,(char)0x60, +0,+0,+2,+0,1,(char)0x20, - +0,+0,+2,+1,0,(char)0x30, +0,+0,+2,+2,1,(char)0x10, +0,+1,+1,+0,0,(char)0x44, - +0,+1,+1,+2,0,(char)0x10, +0,+1,+2,-1,1,(char)0x40, +0,+1,+2,+0,0,(char)0x60, - +0,+1,+2,+1,0,(char)0x20, +0,+1,+2,+2,0,(char)0x10, +1,-2,+1,+0,0,(char)0x80, - +1,-1,+1,+1,0,(char)0x88, +1,+0,+1,+2,0,(char)0x08, +1,+0,+2,-1,0,(char)0x40, - +1,+0,+2,+1,0,(char)0x10 - }, chood[] = { -1,-1, -1,0, -1,+1, 0,+1, +1,+1, +1,0, +1,-1, 0,-1 }; - unsigned short (*brow[5])[4], *pix; - int code[8][2][320], *ip, gval[8], gmin, gmax, sum[4]; - int row, col, shift, x, y, x1, x2, y1, y2, t, weight, grads, color, diag; - int g, diff, thold, num, c; - - for (row=0; row < 8; row++) { /* Precalculate for bilinear */ - for (col=1; col < 3; col++) { - ip = code[row][col & 1]; - memset (sum, 0, sizeof sum); - for (y=-1; y <= 1; y++) - for (x=-1; x <= 1; x++) { - shift = (y==0) + (x==0); - if (shift == 2) continue; - color = FC(row+y,col+x); - *ip++ = (width*y + x)*4 + color; - *ip++ = shift; - *ip++ = color; - sum[color] += 1 << shift; - } - FORC4 - if (c != FC(row,col)) { - *ip++ = c; - *ip++ = sum[c]; + if (cmdline.linear || cmdline.bright < 1) { + scaleMax = MIN(0xffff, scaleMax * cmdline.bright); + FORC4 pre_mul[c] *= cmdline.bright; } + if (cmdline.verbose) { + fprintf(stderr, "Scaling with black=%d, ", black); + fprintf(stderr, "pre_mul[] = "); + FORC4 fprintf (stderr, " %f", pre_mul[c]); + fprintf(stderr, "\n"); } - } - for (row=1; row < height-1; row++) { /* Do bilinear interpolation */ - for (col=1; col < width-1; col++) { - pix = image[row*width+col]; - ip = code[row & 7][col & 1]; - memset (sum, 0, sizeof sum); - for (g=8; g--; ) { - diff = pix[*ip++]; - diff <<= *ip++; - sum[*ip++] += diff; - } - for (g=colors; --g; ) { - c = *ip++; - pix[c] = sum[c] / *ip++; - } + clip_max = cmdline.no_clip_color ? 0xffff : scaleMax; + for (row = 0; row < height; ++row) { + unsigned int col; + for (col = 0; col < width; ++col) { + unsigned int c; + for (c = 0; c < colors; ++c) { + int val; + val = image[row*width+col][c]; + if (val != 0) { + val -= black; + val *= pre_mul[c]; + image[row*width+col][c] = MAX(0, MIN(clip_max, val)); + } + } + } } - } - if (cmdline.quick_interpolate) - return; - - for (row=0; row < 8; row++) { /* Precalculate for VNG */ - for (col=0; col < 2; col++) { - ip = code[row][col]; - for (cp=terms, t=0; t < 64; t++) { - y1 = *cp++; x1 = *cp++; - y2 = *cp++; x2 = *cp++; - weight = *cp++; - grads = *cp++; - color = FC(row+y1,col+x1); - if (FC(row+y2,col+x2) != color) continue; - diag = (FC(row,col+1) == color && FC(row+1,col) == color) ? 2:1; - if (abs(y1-y2) == diag && abs(x1-x2) == diag) continue; - *ip++ = (y1*width + x1)*4 + color; - *ip++ = (y2*width + x2)*4 + color; - *ip++ = weight; - for (g=0; g < 8; g++) - if (grads & 1<<g) *ip++ = g; - *ip++ = -1; - } - *ip++ = INT_MAX; - for (cp=chood, g=0; g < 8; g++) { - y = *cp++; x = *cp++; - *ip++ = (y*width + x) * 4; - color = FC(row,col); - if (FC(row+y,col+x) != color && FC(row+y*2,col+x*2) == color) - *ip++ = (y*width + x) * 8 + color; - else - *ip++ = 0; - } +} + + + +static void CLASS +vngInterpolate(Image const image) { + + /* + This algorithm is officially called "Interpolation using a + Threshold-based variable number of gradients," described in + http://www-ise.stanford.edu/~tingchen/algodep/vargra.html + + I've extended the basic idea to work with non-Bayer filter arrays. + Gradients are numbered clockwise from NW=0 to W=7. + */ + + static const signed char *cp, terms[] = { + -2,-2,+0,-1,0,(char)0x01, -2,-2,+0,+0,1,(char)0x01, -2,-1,-1,+0,0,(char)0x01, + -2,-1,+0,-1,0,(char)0x02, -2,-1,+0,+0,0,(char)0x03, -2,-1,+0,+1,1,(char)0x01, + -2,+0,+0,-1,0,(char)0x06, -2,+0,+0,+0,1,(char)0x02, -2,+0,+0,+1,0,(char)0x03, + -2,+1,-1,+0,0,(char)0x04, -2,+1,+0,-1,1,(char)0x04, -2,+1,+0,+0,0,(char)0x06, + -2,+1,+0,+1,0,(char)0x02, -2,+2,+0,+0,1,(char)0x04, -2,+2,+0,+1,0,(char)0x04, + -1,-2,-1,+0,0,(char)0x80, -1,-2,+0,-1,0,(char)0x01, -1,-2,+1,-1,0,(char)0x01, + -1,-2,+1,+0,1,(char)0x01, -1,-1,-1,+1,0,(char)0x88, -1,-1,+1,-2,0,(char)0x40, + -1,-1,+1,-1,0,(char)0x22, -1,-1,+1,+0,0,(char)0x33, -1,-1,+1,+1,1,(char)0x11, + -1,+0,-1,+2,0,(char)0x08, -1,+0,+0,-1,0,(char)0x44, -1,+0,+0,+1,0,(char)0x11, + -1,+0,+1,-2,1,(char)0x40, -1,+0,+1,-1,0,(char)0x66, -1,+0,+1,+0,1,(char)0x22, + -1,+0,+1,+1,0,(char)0x33, -1,+0,+1,+2,1,(char)0x10, -1,+1,+1,-1,1,(char)0x44, + -1,+1,+1,+0,0,(char)0x66, -1,+1,+1,+1,0,(char)0x22, -1,+1,+1,+2,0,(char)0x10, + -1,+2,+0,+1,0,(char)0x04, -1,+2,+1,+0,1,(char)0x04, -1,+2,+1,+1,0,(char)0x04, + +0,-2,+0,+0,1,(char)0x80, +0,-1,+0,+1,1,(char)0x88, +0,-1,+1,-2,0,(char)0x40, + +0,-1,+1,+0,0,(char)0x11, +0,-1,+2,-2,0,(char)0x40, +0,-1,+2,-1,0,(char)0x20, + +0,-1,+2,+0,0,(char)0x30, +0,-1,+2,+1,1,(char)0x10, +0,+0,+0,+2,1,(char)0x08, + +0,+0,+2,-2,1,(char)0x40, +0,+0,+2,-1,0,(char)0x60, +0,+0,+2,+0,1,(char)0x20, + +0,+0,+2,+1,0,(char)0x30, +0,+0,+2,+2,1,(char)0x10, +0,+1,+1,+0,0,(char)0x44, + +0,+1,+1,+2,0,(char)0x10, +0,+1,+2,-1,1,(char)0x40, +0,+1,+2,+0,0,(char)0x60, + +0,+1,+2,+1,0,(char)0x20, +0,+1,+2,+2,0,(char)0x10, +1,-2,+1,+0,0,(char)0x80, + +1,-1,+1,+1,0,(char)0x88, +1,+0,+1,+2,0,(char)0x08, +1,+0,+2,-1,0,(char)0x40, + +1,+0,+2,+1,0,(char)0x10 + }, chood[] = { -1,-1, -1,0, -1,+1, 0,+1, +1,+1, +1,0, +1,-1, 0,-1 }; + unsigned short (*brow[5])[4], *pix; + int code[8][2][320], *ip, gval[8], gmin, gmax, sum[4]; + int row, col, shift, x, y, x1, x2, y1, y2, t, weight, grads, color, diag; + int g, diff, thold, num, c; + + for (row=0; row < 8; row++) { /* Precalculate for bilinear */ + for (col=1; col < 3; col++) { + ip = code[row][col & 1]; + memset (sum, 0, sizeof sum); + for (y=-1; y <= 1; y++) + for (x=-1; x <= 1; x++) { + shift = (y==0) + (x==0); + if (shift == 2) continue; + color = FC(row+y,col+x); + *ip++ = (width*y + x)*4 + color; + *ip++ = shift; + *ip++ = color; + sum[color] += 1 << shift; + } + FORC4 + if (c != FC(row,col)) { + *ip++ = c; + *ip++ = sum[c]; + } + } } - } - brow[4] = calloc (width*3, sizeof **brow); - merror (brow[4], "vng_interpolate()"); - for (row=0; row < 3; row++) - brow[row] = brow[4] + row*width; - for (row=2; row < height-2; row++) { /* Do VNG interpolation */ - for (col=2; col < width-2; col++) { - pix = image[row*width+col]; - ip = code[row & 7][col & 1]; - memset (gval, 0, sizeof gval); - while ((g = ip[0]) != INT_MAX) { /* Calculate gradients */ - num = (diff = pix[g] - pix[ip[1]]) >> 31; - gval[ip[3]] += (diff = ((diff ^ num) - num) << ip[2]); - ip += 5; - if ((g = ip[-1]) == -1) continue; - gval[g] += diff; - while ((g = *ip++) != -1) - gval[g] += diff; - } - ip++; - gmin = gmax = gval[0]; /* Choose a threshold */ - for (g=1; g < 8; g++) { - if (gmin > gval[g]) gmin = gval[g]; - if (gmax < gval[g]) gmax = gval[g]; - } - if (gmax == 0) { - memcpy (brow[2][col], pix, sizeof *image); - continue; - } - thold = gmin + (gmax >> 1); - memset (sum, 0, sizeof sum); - color = FC(row,col); - for (num=g=0; g < 8; g++,ip+=2) { /* Average the neighbors */ - if (gval[g] <= thold) { - FORC4 - if (c == color && ip[1]) - sum[c] += (pix[c] + pix[ip[1]]) >> 1; - else - sum[c] += pix[ip[0] + c]; - num++; + for (row=1; row < height-1; row++) { /* Do bilinear interpolation */ + for (col=1; col < width-1; col++) { + pix = image[row*width+col]; + ip = code[row & 7][col & 1]; + memset (sum, 0, sizeof sum); + for (g=8; g--; ) { + diff = pix[*ip++]; + diff <<= *ip++; + sum[*ip++] += diff; + } + for (g=colors; --g; ) { + c = *ip++; + pix[c] = sum[c] / *ip++; + } + } } - } - FORC4 { /* Save to buffer */ - t = pix[color]; - if (c != color) { - t += (sum[c] - sum[color])/num; - if (t < 0) t = 0; - if (t > clip_max) t = clip_max; + if (cmdline.quick_interpolate) + return; + + for (row=0; row < 8; row++) { /* Precalculate for VNG */ + for (col=0; col < 2; col++) { + ip = code[row][col]; + for (cp=terms, t=0; t < 64; t++) { + y1 = *cp++; x1 = *cp++; + y2 = *cp++; x2 = *cp++; + weight = *cp++; + grads = *cp++; + color = FC(row+y1,col+x1); + if (FC(row+y2,col+x2) != color) continue; + diag = + (FC(row,col+1) == color && FC(row+1,col) == color) ? 2:1; + if (abs(y1-y2) == diag && abs(x1-x2) == diag) continue; + *ip++ = (y1*width + x1)*4 + color; + *ip++ = (y2*width + x2)*4 + color; + *ip++ = weight; + for (g=0; g < 8; g++) + if (grads & 1<<g) *ip++ = g; + *ip++ = -1; + } + *ip++ = INT_MAX; + for (cp=chood, g=0; g < 8; g++) { + y = *cp++; x = *cp++; + *ip++ = (y*width + x) * 4; + color = FC(row,col); + if (FC(row+y,col+x) != color && FC(row+y*2,col+x*2) == color) + *ip++ = (y*width + x) * 8 + color; + else + *ip++ = 0; + } + } } - brow[2][col][c] = t; - } + brow[4] = calloc (width*3, sizeof **brow); + merror (brow[4], "vngInterpolate()"); + for (row=0; row < 3; row++) + brow[row] = brow[4] + row*width; + for (row=2; row < height-2; row++) { /* Do VNG interpolation */ + for (col=2; col < width-2; col++) { + pix = image[row*width+col]; + ip = code[row & 7][col & 1]; + memset (gval, 0, sizeof gval); + while ((g = ip[0]) != INT_MAX) { /* Calculate gradients */ + num = (diff = pix[g] - pix[ip[1]]) >> 31; + gval[ip[3]] += (diff = ((diff ^ num) - num) << ip[2]); + ip += 5; + if ((g = ip[-1]) == -1) continue; + gval[g] += diff; + while ((g = *ip++) != -1) + gval[g] += diff; + } + ip++; + gmin = gmax = gval[0]; /* Choose a threshold */ + for (g=1; g < 8; g++) { + if (gmin > gval[g]) gmin = gval[g]; + if (gmax < gval[g]) gmax = gval[g]; + } + if (gmax == 0) { + memcpy (brow[2][col], pix, sizeof *image); + continue; + } + thold = gmin + (gmax >> 1); + memset (sum, 0, sizeof sum); + color = FC(row,col); + for (num=g=0; g < 8; g++,ip+=2) { /* Average the neighbors */ + if (gval[g] <= thold) { + FORC4 + if (c == color && ip[1]) + sum[c] += (pix[c] + pix[ip[1]]) >> 1; + else + sum[c] += pix[ip[0] + c]; + num++; + } + } + FORC4 { /* Save to buffer */ + t = pix[color]; + if (c != color) { + t += (sum[c] - sum[color])/num; + if (t < 0) t = 0; + if (t > clip_max) t = clip_max; + } + brow[2][col][c] = t; + } + } + if (row > 3) /* Write buffer to image */ + memcpy(image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image); + for (g=0; g < 4; g++) + brow[(g-1) & 3] = brow[g]; } - if (row > 3) /* Write buffer to image */ - memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image); - for (g=0; g < 4; g++) - brow[(g-1) & 3] = brow[g]; - } - memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image); - memcpy (image[(row-1)*width+2], brow[1]+2, (width-4)*sizeof *image); - free (brow[4]); + memcpy (image[(row-2)*width+2], brow[0]+2, (width-4)*sizeof *image); + memcpy (image[(row-1)*width+2], brow[1]+2, (width-4)*sizeof *image); + free (brow[4]); } -#ifdef USE_LCMS -static void -apply_profile(FILE * const ifP, - const char * const pfname) -{ - char *prof; - cmsHPROFILE hInProfile=NULL, hOutProfile; - cmsHTRANSFORM hTransform; - - if (pfname) - hInProfile = cmsOpenProfileFromFile (pfname, "r"); - else if (profile_length) { - prof = malloc (profile_length); - merror (prof, "apply_profile()"); - fseek (ifP, profile_offset, SEEK_SET); - fread (prof, 1, profile_length, ifP); - hInProfile = cmsOpenProfileFromMem (prof, profile_length); - free (prof); - } - if (!hInProfile) return; - if (cmdline.verbose) - pm_message( "Applying color profile..."); - maximum = 0xffff; - use_gamma = use_coeff = 0; - - hOutProfile = cmsCreate_sRGBProfile(); - hTransform = cmsCreateTransform (hInProfile, TYPE_RGBA_16, - hOutProfile, TYPE_RGBA_16, INTENT_PERCEPTUAL, 0); - cmsDoTransform (hTransform, image, image, width*height); - - cmsDeleteTransform (hTransform); - cmsCloseProfile (hInProfile); - cmsCloseProfile (hOutProfile); -} -#else -static void -apply_profile(FILE * const ifP, - const char * const pfname) -{ -} -#endif -/* + +static void CLASS +convertToRgb(Image const image, + unsigned int const trim) { +/*---------------------------------------------------------------------------- Convert the entire image to RGB colorspace and build a histogram. - */ -static void CLASS convert_to_rgb() -{ - int row, col, r, g, c=0; - unsigned short *img; - float rgb[3]; - - if (cmdline.document_mode) - colors = 1; - memset (histogram, 0, sizeof histogram); - for (row = trim; row < height-trim; row++) - for (col = trim; col < width-trim; col++) { - img = image[row*width+col]; - if (cmdline.document_mode) - c = FC(row,col); - if (colors == 4 && !use_coeff) /* Recombine the greens */ - img[1] = (img[1] + img[3]) >> 1; - if (colors == 1) /* RGB from grayscale */ - for (r=0; r < 3; r++) - rgb[r] = img[c]; - else if (use_coeff) { /* RGB via coeff[][] */ - for (r=0; r < 3; r++) - for (rgb[r]=g=0; g < colors; g++) - rgb[r] += img[g] * coeff[r][g]; - } else /* RGB from RGB (easy) */ - goto norgb; - for (r=0; r < 3; r++) { - if (rgb[r] < 0) rgb[r] = 0; - if (rgb[r] > clip_max) rgb[r] = clip_max; - img[r] = rgb[r]; - } -norgb: - for (r=0; r < 3; r++) - histogram[r][img[r] >> 3]++; + + We modify 'image' to change it from whatever it is now to RGB. +-----------------------------------------------------------------------------*/ + unsigned int row; + unsigned int c; + float rgb[3]; /* { red, green, blue } */ + + c = 0; /* initial value */ + + if (cmdline.document_mode) + colors = 1; + + memset(histogram, 0, sizeof histogram); + + for (row = 0 + trim; row < height - trim; ++row) { + unsigned int col; + for (col = 0 + trim; col < width - trim; ++col) { + unsigned short * const img = image[row*width+col]; + + if (cmdline.document_mode) + c = FC(row,col); + + if (colors == 4 && !use_coeff) + /* Recombine the greens */ + img[1] = (img[1] + img[3]) / 2; + + if (colors == 1) { + /* RGB from grayscale */ + unsigned int i; + for (i = 0; i < 3; ++i) + rgb[i] = img[c]; + } else if (use_coeff) { + /* RGB via coeff[][] */ + unsigned int i; + for (i = 0; i < 3; ++i) { + unsigned int j; + for (j = 0, rgb[i]= 0; j < colors; ++j) + rgb[i] += img[j] * coeff[i][j]; + } + } else { + /* RGB from RGB (easy) */ + unsigned int i; + for (i = 0; i < 3; ++i) + rgb[i] = img[i]; + } + { + unsigned int i; + for (i = 0; i < 3; ++i) + img[i] = MIN(clip_max, MAX(0, rgb[i])); + } + { + unsigned int i; + for (i = 0; i < 3; ++i) + ++histogram[i][img[i] >> 3]; + } + } } } -static void CLASS fuji_rotate() -{ - int i, wide, high, row, col; - double step; - float r, c, fr, fc; - unsigned ur, uc; - unsigned short (*img)[4], (*pix)[4]; - - if (!fuji_width) return; - if (cmdline.verbose) - pm_message ("Rotating image 45 degrees..."); - fuji_width = (fuji_width + shrink) >> shrink; - step = sqrt(0.5); - wide = fuji_width / step; - high = (height - fuji_width) / step; - img = calloc (wide*high, sizeof *img); - merror (img, "fuji_rotate()"); - - for (row=0; row < high; row++) - for (col=0; col < wide; col++) { - ur = r = fuji_width + (row-col)*step; - uc = c = (row+col)*step; - if (ur > height-2 || uc > width-2) continue; - fr = r - ur; - fc = c - uc; - pix = image + ur*width + uc; - for (i=0; i < colors; i++) - img[row*wide+col][i] = - (pix[ 0][i]*(1-fc) + pix[ 1][i]*fc) * (1-fr) + - (pix[width][i]*(1-fc) + pix[width+1][i]*fc) * fr; + + +static void CLASS +fujiRotate(Image * const imageP) { + + int wide; + int high; + unsigned int row; + double step; + float r, c, fr, fc; + unsigned short (*newImage)[4]; + unsigned short (*pix)[4]; + + if (fuji_width > 0) { + if (cmdline.verbose) + pm_message ("Rotating image 45 degrees..."); + + fuji_width = (fuji_width + shrink) >> shrink; + step = sqrt(0.5); + wide = fuji_width / step; + high = (height - fuji_width) / step; + newImage = calloc (wide*high, sizeof *newImage); + merror (newImage, "fujiRotate()"); + + for (row = 0; row < high; ++row) { + unsigned int col; + for (col = 0; col < wide; ++col) { + unsigned int ur = r = fuji_width + (row-col)*step; + unsigned int uc = c = (row+col)*step; + + unsigned int i; + + if (ur > height-2 || uc > width-2) + continue; + + fr = r - ur; + fc = c - uc; + pix = (*imageP) + ur * width + uc; + + for (i = 0; i < colors; ++i) { + newImage[row*wide+col][i] = + (pix[ 0][i]*(1-fc) + pix[ 1][i]*fc) * (1-fr) + + (pix[width][i]*(1-fc) + pix[width+1][i]*fc) * fr; + } + } + } + free(*imageP); + width = wide; + height = high; + *imageP = newImage; + fuji_width = 0; } - free (image); - width = wide; - height = high; - image = img; - fuji_width = 0; } -static void CLASS flip_image() -{ + + +static void CLASS +flipImage(Image const image) { + unsigned *flag; - int size, base, dest, next, row, col, temp; + int size, base, dest; struct imageCell { unsigned char contents[8]; }; struct imageCell * img; - struct imageCell hold; switch ((flip+3600) % 360) { - case 270: flip = 5; break; - case 180: flip = 3; break; - case 90: flip = 6; + case 270: flip = 0x5; break; + case 180: flip = 0x3; break; + case 90: flip = 0x6; } img = (struct imageCell *) image; size = height * width; flag = calloc ((size+31) >> 5, sizeof *flag); - merror (flag, "flip_image()"); - for (base = 0; base < size; base++) { - if (flag[base >> 5] & (1 << (base & 31))) - continue; - dest = base; - hold = img[base]; - while (1) { - if (flip & 4) { - row = dest % height; - col = dest / height; - } else { - row = dest / width; - col = dest % width; + merror (flag, "flipImage()"); + for (base = 0; base < size; ++base) { + if (flag[base >> 5] & (1 << (base & 31))) { + /* nothing */ + } else { + struct imageCell const hold = img[base]; + dest = base; + while (true) { + unsigned int col; + unsigned int row; + int next; + if (flip & 0x4) { + row = dest % height; + col = dest / height; + } else { + row = dest / width; + col = dest % width; + } + if (flip & 0x2) + row = height - 1 - row; + if (flip & 1) + col = width - 1 - col; + next = row * width + col; + if (next == base) + break; + flag[next >> 5] |= 1 << (next & 31); + img[dest] = img[next]; + dest = next; } - if (flip & 2) - row = height - 1 - row; - if (flip & 1) - col = width - 1 - col; - next = row * width + col; - if (next == base) break; - flag[next >> 5] |= 1 << (next & 31); - img[dest] = img[next]; - dest = next; + img[dest] = hold; } - img[dest] = hold; } free (flag); - if (flip & 4) { - temp = height; + if (flip & 0x4) { + int const oldHeight = height; + int const oldYmag = ymag; + height = width; - width = temp; - temp = ymag; + width = oldHeight; ymag = xmag; - xmag = temp; + xmag = oldYmag; } } -/* - Write the image as an RGB PAM image - */ -static void CLASS write_pam_nonlinear (FILE *ofp) -{ - unsigned char lut[0x10000]; - int perc, c, val, total, i, row, col; - float white=0, r; - struct pam pam; - tuple * tuplerow; - - pam.size = sizeof(pam); - pam.len = PAM_STRUCT_SIZE(tuple_type); - pam.file = ofp; - pam.width = xmag*(width-trim*2); - pam.height = ymag*(height-trim*2); - pam.depth = 3; - pam.format = PAM_FORMAT; - pam.maxval = 255; - strcpy(pam.tuple_type, "RGB"); - - pnm_writepaminit(&pam); - - tuplerow = pnm_allocpamrow(&pam); - - perc = width * height * 0.01; /* 99th percentile white point */ - if (fuji_width) perc /= 2; - FORC3 { - for (val=0x2000, total=0; --val > 32; ) - if ((total += histogram[c][val]) > perc) break; - if (white < val) white = val; - } - white *= 8 / cmdline.bright; - for (i=0; i < 0x10000; i++) { - r = i / white; - val = 256 * ( !use_gamma ? r : - r <= 0.018 ? r*4.5 : pow(r,0.45)*1.099-0.099 ); - if (val > 255) val = 255; - lut[i] = val; - } - for (row=trim; row < height-trim; row++) { - for (col=trim; col < width-trim; col++) { - unsigned int plane; - for (plane=0; plane < pam.depth; ++plane) { - unsigned int copy; - for (copy=0; copy < xmag; ++copy) { - unsigned int const pamcol = xmag*(col-trim)+copy; - tuplerow[pamcol][plane] = lut[image[row*width+col][plane]]; - } - } - } - { - unsigned int copy; - for (copy=0; copy < ymag; ++copy) - pnm_writepamrow(&pam, tuplerow); - } - } - pnm_freepamrow(tuplerow); + + +static void CLASS +writePamLinear(FILE * const ofP, + Image const image, + unsigned int const trim) { +/*---------------------------------------------------------------------------- + Write the image 'image' to a 16-bit PAM file with linear color space +-----------------------------------------------------------------------------*/ + unsigned int row; + + struct pam pam; + tuple * tuplerow; + + pam.size = sizeof(pam); + pam.len = PAM_STRUCT_SIZE(tuple_type); + pam.file = ofP; + pam.width = width - trim - trim; + pam.height = height - trim - trim; + pam.depth = 3; + pam.format = PAM_FORMAT; + pam.maxval = MAX(maximum, 256); + strcpy(pam.tuple_type, "RGB"); + + pnm_writepaminit(&pam); + + tuplerow = pnm_allocpamrow(&pam); + + for (row = 0 + trim; row < height - trim; ++row) { + unsigned int col; + for (col = 0 + trim; col < width - trim; ++col) { + unsigned int const pamCol = col - trim; + unsigned int plane; + for (plane = 0; plane < 3; ++plane) + tuplerow[pamCol][plane] = image[row*width+col][plane]; + } + pnm_writepamrow(&pam, tuplerow); + } + pnm_freepamrow(tuplerow); } -/* - Write the image to a 16-bit PAM file with linear color space - */ -static void CLASS write_pam_linear (FILE *ofp) -{ - int row; - - struct pam pam; - tuple * tuplerow; - - if (maximum < 256) maximum = 256; - - pam.size = sizeof(pam); - pam.len = PAM_STRUCT_SIZE(tuple_type); - pam.file = ofp; - pam.width = width-trim*2; - pam.height = height-trim*2; - pam.depth = 3; - pam.format = PAM_FORMAT; - pam.maxval = MAX(maximum, 256); - strcpy(pam.tuple_type, "RGB"); - - pnm_writepaminit(&pam); - - tuplerow = pnm_allocpamrow(&pam); - - for (row = trim; row < height-trim; row++) { - unsigned int col; - for (col = trim; col < width-trim; col++) { - unsigned int const pamCol = col - trim; - unsigned int plane; - for (plane = 0; plane < 3; ++plane) - tuplerow[pamCol][plane] = image[row*width+col][plane]; - } - pnm_writepamrow(&pam, tuplerow); - } - pnm_freepamrow(tuplerow); + + +static void CLASS +writePamNonlinear(FILE * const ofP, + Image const image, + unsigned int const trim) { +/*---------------------------------------------------------------------------- + Write the image 'image' as an RGB PAM image +-----------------------------------------------------------------------------*/ + unsigned char lut[0x10000]; + int perc; + int c; + int total; + int i; + unsigned int row; + float white; + float r; + struct pam pam; + tuple * tuplerow; + + white = 0; /* initial value */ + + pam.size = sizeof(pam); + pam.len = PAM_STRUCT_SIZE(tuple_type); + pam.file = ofP; + pam.width = xmag*(width-trim*2); + pam.height = ymag*(height-trim*2); + pam.depth = 3; + pam.format = PAM_FORMAT; + pam.maxval = 255; + strcpy(pam.tuple_type, "RGB"); + + pnm_writepaminit(&pam); + + tuplerow = pnm_allocpamrow(&pam); + + perc = width * height * 0.01; /* 99th percentile white point */ + if (fuji_width) perc /= 2; + FORC3 { + int val; + for (val=0x2000, total=0; --val > 32; ) + if ((total += histogram[c][val]) > perc) break; + if (white < val) + white = val; + } + white *= 8 / cmdline.bright; + for (i=0; i < 0x10000; ++i) { + int val; + r = i / white; + val = 256 * ( !use_gamma ? r : + r <= 0.018 ? r*4.5 : pow(r,0.45)*1.099-0.099 ); + lut[i] = MIN(255, val); + } + + for (row = 0 + trim; row < height - trim; ++row) { + unsigned int col; + for (col = 0 + trim; col < width - trim; ++col) { + unsigned int plane; + for (plane = 0; plane < pam.depth; ++plane) { + sample const value = lut[image[row*width+col][plane]]; + unsigned int copy; + for (copy = 0; copy < xmag; ++copy) { + unsigned int const pamcol = xmag*(col-trim)+copy; + tuplerow[pamcol][plane] = value; + } + } + } + { + unsigned int copy; + for (copy = 0; copy < ymag; ++copy) + pnm_writepamrow(&pam, tuplerow); + } + } + pnm_freepamrow(tuplerow); } static void CLASS -writePam(FILE * const ofP, - bool const linear) { +writePam(FILE * const ofP, + Image const image, + bool const linear, + unsigned int const trim) { if (linear) - write_pam_linear(ofP); + writePamLinear(ofP, image, trim); else - write_pam_nonlinear(ofP); + writePamNonlinear(ofP, image, trim); } - static void CLASS -convertIt(FILE * const ifP, - FILE * const ofP, - loadRawFn const load_raw) { +convertIt(FILE * const ifP, + FILE * const ofP, + LoadRawFn * const load_raw) { + + Image image; + unsigned int trim; shrink = cmdline.half_size && filters; iheight = (height + shrink) >> shrink; iwidth = (width + shrink) >> shrink; - image = calloc (iheight*iwidth*sizeof *image + meta_length, 1); + image = calloc (iheight*iwidth*sizeof(*image) + meta_length, 1); merror (image, "main()"); meta_data = (char *) (image + iheight*iwidth); if (cmdline.verbose) @@ -809,43 +887,49 @@ convertIt(FILE * const ifP, ifp = ifP; /* Set global variable for (*load_raw)() */ - load_raw(); - bad_pixels(); + load_raw(image); + fixBadPixels(image); height = iheight; width = iwidth; if (is_foveon) { if (cmdline.verbose) pm_message ("Foveon interpolation..."); - foveon_interpolate(coeff); + foveon_interpolate(image, coeff); } else { - scale_colors(); + scaleColors(image); } - if (shrink) filters = 0; - trim = 0; + if (shrink) + filters = 0; + if (filters && !cmdline.document_mode) { trim = 1; if (cmdline.verbose) pm_message ("%s interpolation...", cmdline.quick_interpolate ? "Bilinear":"VNG"); - vng_interpolate(); - } - fuji_rotate(); - apply_profile(ifP, cmdline.profile); + vngInterpolate(image); + } else + trim = 0; + + fujiRotate(&image); + if (cmdline.verbose) pm_message ("Converting to RGB colorspace..."); - convert_to_rgb(); + convertToRgb(image, trim); if (flip) { if (cmdline.verbose) pm_message ("Flipping image %c:%c:%c...", flip & 1 ? 'H':'0', flip & 2 ? 'V':'0', flip & 4 ? 'T':'0'); - flip_image(); + flipImage(image); } - writePam(ofP, cmdline.linear); + writePam(ofP, image, cmdline.linear, trim); + + free(image); } + int main (int argc, char **argv) { @@ -853,7 +937,7 @@ main (int argc, char **argv) { FILE * ifP; int rc; - loadRawFn load_raw; + LoadRawFn * load_raw; pnm_init(&argc, argv); @@ -863,8 +947,6 @@ main (int argc, char **argv) { ifP = pm_openr(cmdline.inputFileName); - image = NULL; - rc = identify(ifP, cmdline.use_secondary, cmdline.use_camera_rgb, cmdline.red_scale, cmdline.blue_scale, @@ -883,7 +965,6 @@ main (int argc, char **argv) { } pm_close(ifP); pm_close(ofP); - free(image); return 0; } diff --git a/converter/other/cameratopam/cameratopam.h b/converter/other/cameratopam/cameratopam.h new file mode 100644 index 00000000..9ff33cb3 --- /dev/null +++ b/converter/other/cameratopam/cameratopam.h @@ -0,0 +1,6 @@ +#ifndef CAMERATOPAM_H_INCLUDED +#define CAMERATOPAM_H_INCLUDED + +typedef unsigned short (*Image)[4]; + +#endif diff --git a/converter/other/cameratopam/canon.c b/converter/other/cameratopam/canon.c index a34771d0..96a6210b 100644 --- a/converter/other/cameratopam/canon.c +++ b/converter/other/cameratopam/canon.c @@ -9,7 +9,7 @@ void -canon_600_load_raw(void) { +canon_600_load_raw(Image const image) { unsigned char data[1120], *dp; unsigned short pixel[896], *pix; int irow, orow, col; @@ -42,7 +42,7 @@ canon_600_load_raw(void) { void -canon_a5_load_raw(void) { +canon_a5_load_raw(Image const image) { unsigned char data[1940], *dp; unsigned short pixel[1552], *pix; int row, col; @@ -97,7 +97,7 @@ canon_has_lowbits() void -canon_compressed_load_raw(void) { +canon_compressed_load_raw(Image const image) { unsigned short *pixel, *prow; int lowbits, i, row, r, col, save, val; unsigned irow, icol; diff --git a/converter/other/cameratopam/canon.h b/converter/other/cameratopam/canon.h index 041cdc4d..fe6a5a08 100644 --- a/converter/other/cameratopam/canon.h +++ b/converter/other/cameratopam/canon.h @@ -1,13 +1,12 @@ #ifndef CANON_H_INCLUDED #define CANON_H_INCLUDED -void -canon_600_load_raw(void); +#include "camera.h" -void -canon_a5_load_raw(void); +LoadRawFn canon_600_load_raw; -void -canon_compressed_load_raw(void); +LoadRawFn canon_a5_load_raw; + +LoadRawFn canon_compressed_load_raw; #endif diff --git a/converter/other/cameratopam/dng.c b/converter/other/cameratopam/dng.c index 44d45b02..bddfd9f4 100644 --- a/converter/other/cameratopam/dng.c +++ b/converter/other/cameratopam/dng.c @@ -4,70 +4,105 @@ #include "dng.h" void -dng_coeff (double cc[4][4], double cm[4][3], double xyz[3]) -{ - static const double rgb_xyz[3][3] = { /* RGB from XYZ */ - { 3.240479, -1.537150, -0.498535 }, - { -0.969256, 1.875992, 0.041556 }, - { 0.055648, -0.204043, 1.057311 } }; +dng_coeff (double cc[4][4], + double cm[4][3], + double xyz[3]) { + static const double rgb_xyz[3][3] = { /* RGB from XYZ */ + { 3.240479, -1.537150, -0.498535 }, + { -0.969256, 1.875992, 0.041556 }, + { 0.055648, -0.204043, 1.057311 } }; #if 0 - static const double xyz_rgb[3][3] = { /* XYZ from RGB */ - { 0.412453, 0.357580, 0.180423 }, - { 0.212671, 0.715160, 0.072169 }, - { 0.019334, 0.119193, 0.950227 } }; + static const double xyz_rgb[3][3] = { /* XYZ from RGB */ + { 0.412453, 0.357580, 0.180423 }, + { 0.212671, 0.715160, 0.072169 }, + { 0.019334, 0.119193, 0.950227 } }; #endif - double cam_xyz[4][3], xyz_cam[3][4], invert[3][6], num; - int i, j, k; + double cam_xyz[4][3], xyz_cam[3][4], invert[3][6]; + unsigned int i; - memset (cam_xyz, 0, sizeof cam_xyz); - for (i=0; i < colors; i++) - for (j=0; j < 3; j++) - for (k=0; k < colors; k++) - cam_xyz[i][j] += cc[i][k] * cm[k][j] * xyz[j]; + for (i = 0; i < colors; ++i) { + unsigned int j; + for (j = 0; j < 3; ++j) { + unsigned int k; + for (k = 0, cam_xyz[i][j] = 0.0; k < colors; ++k) { + cam_xyz[i][j] += cc[i][k] * cm[k][j] * xyz[j]; + } + } + } + for (i = 0; i < colors; ++i) { + unsigned int j; + double camXyzSum; + + for (j = 0, camXyzSum = 0.0; j < 3; ++j) + camXyzSum += cam_xyz[i][j]; - for (i=0; i < colors; i++) { - for (num=j=0; j < 3; j++) - num += cam_xyz[i][j]; - for (j=0; j < 3; j++) - cam_xyz[i][j] /= num; - pre_mul[i] = 1 / num; - } - for (i=0; i < 3; i++) { - for (j=0; j < 6; j++) - invert[i][j] = j == i+3; - for (j=0; j < 3; j++) - for (k=0; k < colors; k++) - invert[i][j] += cam_xyz[k][i] * cam_xyz[k][j]; - } - for (i=0; i < 3; i++) { - num = invert[i][i]; - for (j=0; j < 6; j++) /* Normalize row i */ - invert[i][j] /= num; - for (k=0; k < 3; k++) { /* Subtract it from other rows */ - if (k==i) continue; - num = invert[k][i]; - for (j=0; j < 6; j++) - invert[k][j] -= invert[i][j] * num; + for (j = 0; j < 3; ++j) + cam_xyz[i][j] /= camXyzSum; + + pre_mul[i] = 1 / camXyzSum; + } + for (i = 0; i < 3; ++i) { + unsigned int j; + for (j = 0; j < 6; ++j) + invert[i][j] = j == i+3; + for (j = 0; j < 3; ++j) { + unsigned int k; + for (k = 0; k < colors; ++k) + invert[i][j] += cam_xyz[k][i] * cam_xyz[k][j]; + } } - } - memset (xyz_cam, 0, sizeof xyz_cam); - for (i=0; i < 3; i++) - for (j=0; j < colors; j++) - for (k=0; k < 3; k++) - xyz_cam[i][j] += invert[i][k+3] * cam_xyz[j][k]; + for (i = 0; i < 3; ++i) { + double const num = invert[i][i]; + unsigned int j; + unsigned int k; + for (j = 0; j < 6; ++j) /* Normalize row i */ + invert[i][j] /= num; + for (k = 0; k < 3; ++k) { /* Subtract it from other rows */ + if (k != i) { + double const num = invert[k][i]; + unsigned int j; + for (j = 0; j < 6; ++j) + invert[k][j] -= invert[i][j] * num; + } + } + } + + memset(xyz_cam, 0, sizeof xyz_cam); - memset (coeff, 0, sizeof coeff); - for (i=0; i < 3; i++) - for (j=0; j < colors; j++) - for (k=0; k < 3; k++) - coeff[i][j] += rgb_xyz[i][k] * xyz_cam[k][j]; + for (i = 0; i < 3; ++i) { + unsigned int j; + for (j = 0; j < colors; ++j) { + unsigned int k; + for (k = 0; k < 3; ++k) + xyz_cam[i][j] += invert[i][k+3] * cam_xyz[j][k]; + } + } + memset (coeff, 0, sizeof coeff); - for (num=j=0; j < colors; j++) - num += coeff[1][j]; - for (i=0; i < 3; i++) { - for (j=0; j < colors; j++) - coeff[i][j] /= num; - } - use_coeff = 1; + for (i = 0; i < 3; ++i) { + unsigned int j; + for (j = 0; j < colors; ++j) { + unsigned int k; + for (k = 0; k < 3; ++k) + coeff[i][j] += rgb_xyz[i][k] * xyz_cam[k][j]; + } + } + { + double greenSum; + unsigned int j; + unsigned int i; + + for (j = 0, greenSum = 0.0; j < colors; ++j) + greenSum += coeff[1][j]; + + for (i = 0; i < 3; ++i) { + unsigned int j; + for (j = 0; j < colors; ++j) + coeff[i][j] /= greenSum; + } + } + use_coeff = 1; } + + diff --git a/converter/other/cameratopam/dng.h b/converter/other/cameratopam/dng.h index 01e7e0a5..56293563 100644 --- a/converter/other/cameratopam/dng.h +++ b/converter/other/cameratopam/dng.h @@ -1,2 +1,4 @@ void -dng_coeff (double cc[4][4], double cm[4][3], double xyz[3]); +dng_coeff(double cc[4][4], + double cm[4][3], + double xyz[3]); diff --git a/converter/other/cameratopam/foveon.c b/converter/other/cameratopam/foveon.c index f6d074fb..a3e5449a 100644 --- a/converter/other/cameratopam/foveon.c +++ b/converter/other/cameratopam/foveon.c @@ -211,7 +211,7 @@ foveon_load_camf() { void -foveon_load_raw() { +foveon_load_raw(Image const image) { struct decode *dindex; short diff[1024], pred[3]; @@ -391,7 +391,8 @@ static int foveon_apply_curve (short *curve, int i) } void -foveon_interpolate(float coeff[3][4]) { +foveon_interpolate(Image const image, + float coeff[3][4]) { static const short hood[] = { -1,-1, -1,0, -1,1, 0,-1, 0,1, 1,-1, 1,0, 1,1 }; @@ -472,8 +473,8 @@ foveon_interpolate(float coeff[3][4]) { sgrow = calloc (dim[1], sizeof *sgrow); sgx = (width + dim[1]-2) / (dim[1]-1); - black = calloc (height, sizeof *black); - for (row=0; row < height; row++) { + black = calloc (height, sizeof(black[0])); + for (row=0; row < height; ++row) { unsigned int i; for (i=0; i < 3; ++i) { unsigned int j; @@ -486,8 +487,8 @@ foveon_interpolate(float coeff[3][4]) { foveon_avg (image[row*width]+c, dscr[1], cfilt) * 3 - ddft[0][c][0] ) / 4 - ddft[0][c][1]; } - memcpy (black, black+8, sizeof (*black)*8); - memcpy (black+height-11, black+height-22, 11*sizeof *black); + memcpy (black, black+8, 8 * sizeof(black[0])); + memcpy (black+height-11, black+height-22, 11*(sizeof black[0])); memcpy (last, black, sizeof last); for (row=1; row < height-1; row++) { diff --git a/converter/other/cameratopam/foveon.h b/converter/other/cameratopam/foveon.h index f3177e50..c9bf48a8 100644 --- a/converter/other/cameratopam/foveon.h +++ b/converter/other/cameratopam/foveon.h @@ -1,13 +1,16 @@ #include "pm.h" +#include "cameratopam.h" +#include "camera.h" + void parse_foveon(FILE * const ifp); void -foveon_interpolate(float coeff[3][4]); +foveon_interpolate(Image const image, + float coeff[3][4]); -void -foveon_load_raw(void); +LoadRawFn foveon_load_raw; void foveon_coeff(int * const useCoeffP, diff --git a/converter/other/cameratopam/global_variables.h b/converter/other/cameratopam/global_variables.h index c8732d5a..2bfc08c9 100644 --- a/converter/other/cameratopam/global_variables.h +++ b/converter/other/cameratopam/global_variables.h @@ -23,7 +23,6 @@ extern time_t timestamp; extern int is_foveon; extern int is_dng; extern int is_canon; -extern unsigned short (*image)[4]; extern int maximum; extern int clip_max; extern short order; diff --git a/converter/other/cameratopam/identify.c b/converter/other/cameratopam/identify.c index f0b21ce5..394ba0a7 100644 --- a/converter/other/cameratopam/identify.c +++ b/converter/other/cameratopam/identify.c @@ -2,6 +2,8 @@ #include <string.h> #include "pm.h" +#include "pm_c_util.h" +#include "nstring.h" #include "global_variables.h" #include "util.h" @@ -21,7 +23,6 @@ static bool const have64BitArithmetic = false; #endif -static loadRawFn load_raw; /* This does the same as the function of the same name in the GNU C library */ static const char *memmem_internal (const char *haystack, size_t haystacklen, @@ -34,16 +35,20 @@ static const char *memmem_internal (const char *haystack, size_t haystacklen, return NULL; } -/* - Thanks to Adobe for providing these excellent CAM -> XYZ matrices! -*/ + + static void -adobe_coeff() -{ - static const struct { - const char *prefix; +adobeCoeff(const char * const make, + const char * const model) { + /* + Thanks to Adobe for providing these excellent CAM -> XYZ matrices! + */ + struct CoeffTableEntry { + const char * prefix; short trans[12]; - } table[] = { + }; + + static struct CoeffTableEntry const table[] = { { "Canon EOS D2000C", { 24542,-10860,-3401,-1490,11370,-297,2858,-605,3225 } }, { "Canon EOS D30", @@ -229,26 +234,33 @@ adobe_coeff() double cm[4][3]; double xyz[] = { 1,1,1 }; char name[130]; - int i, j; + unsigned int i; - for (i=0; i < 4; i++) - for (j=0; j < 4; j++) - cc[i][j] = i == j; + /* Make an identity matrix (1's on the diagonal) */ + for (i = 0; i < 4; ++i) { + unsigned int j; + for (j = 0; j < 4; ++j) + cc[i][j] = (i == j); + } sprintf (name, "%s %s", make, model); - for (i=0; i < sizeof table / sizeof *table; i++) - if (!strncmp (name, table[i].prefix, strlen(table[i].prefix))) { + + for (i = 0; i < ARRAY_SIZE(table); ++i) { + const struct CoeffTableEntry * const entryP = &table[i]; + + if (strneq(name, entryP->prefix, strlen(entryP->prefix))) { unsigned int j; - for (j=0; j < 12; j++) - cm[j/4][j%4] = table[i].trans[j]; - dng_coeff (cc, cm, xyz); + for (j = 0; j < 12; ++j) + cm[j/4][j%4] = entryP->trans[j]; + dng_coeff(cc, cm, xyz); + break; } + } } -/* - Identify which camera created this file, and set global variables - accordingly. Return nonzero if the file cannot be decoded. -*/ + + + int identify(FILE * const ifp, bool const use_secondary, @@ -257,8 +269,11 @@ identify(FILE * const ifp, float const blue_scale, unsigned int const four_color_rgb, const char * const inputFileName, - loadRawFn * const loadRawFnP) -{ + LoadRawFn ** const loadRawFnP) { +/*---------------------------------------------------------------------------- + Identify which camera created this file, and set global variables + accordingly. Return nonzero if the file cannot be decoded. +-----------------------------------------------------------------------------*/ char head[32]; char * c; unsigned hlen, fsize, i; @@ -292,6 +307,7 @@ identify(FILE * const ifp, { "Canon", "NIKON", "EPSON", "Kodak", "OLYMPUS", "PENTAX", "MINOLTA", "Minolta", "Konica", "CASIO" }; float tmp; + LoadRawFn * load_raw; /* What format is this file? Set make[] if we recognize it. */ @@ -310,9 +326,6 @@ identify(FILE * const ifp, colors = 3; for (i=0; i < 0x1000; i++) curve[i] = i; maximum = 0xfff; -#ifdef USE_LCMS - profile_length = 0; -#endif order = get2(ifp); hlen = get4(ifp); @@ -412,6 +425,9 @@ identify(FILE * const ifp, memmove (model, model+i, 64-i); make[63] = model[63] = model2[63] = 0; + if (verbose) + fprintf(stderr, "Make = '%s', Model = '%s'\n", make, model); + if (make[0] == 0) { pm_message ("unrecognized file format."); return 1; @@ -442,7 +458,7 @@ identify(FILE * const ifp, goto dng_skip; } -/* We'll try to decode anything from Canon or Nikon. */ + /* We'll try to decode anything from Canon or Nikon. */ if (!filters) filters = 0x94949494; if ((is_canon = !strcmp(make,"Canon"))) @@ -452,7 +468,7 @@ identify(FILE * const ifp, load_raw = nikon_is_compressed() ? nikon_compressed_load_raw : nikon_load_raw; -/* Set parameters based on camera name (for non-DNG files). */ + /* Set parameters based on camera name (for non-DNG files). */ if (is_foveon) { if (!have64BitArithmetic) @@ -1145,7 +1161,8 @@ identify(FILE * const ifp, flip = 2; } } - if (!use_coeff) adobe_coeff(); + if (!use_coeff) + adobeCoeff(make, model); dng_skip: if (!load_raw || !height) { pm_message ("This program cannot handle data from %s %s.", diff --git a/converter/other/cameratopam/identify.h b/converter/other/cameratopam/identify.h index 012b807c..62c9aae5 100644 --- a/converter/other/cameratopam/identify.h +++ b/converter/other/cameratopam/identify.h @@ -1,4 +1,4 @@ -typedef void (*loadRawFn)(); +#include "camera.h" int identify(FILE * const ifp, @@ -8,4 +8,4 @@ identify(FILE * const ifp, float const blue_scale, unsigned int const four_color_rgb, const char * const inputFileName, - loadRawFn * const loadRawFnP); + LoadRawFn ** const loadRawFnP); diff --git a/converter/other/cameratopam/ljpeg.c b/converter/other/cameratopam/ljpeg.c index 18423f4f..29e4ff98 100644 --- a/converter/other/cameratopam/ljpeg.c +++ b/converter/other/cameratopam/ljpeg.c @@ -87,9 +87,10 @@ ljpeg_row (struct jhead *jh) } } + void -lossless_jpeg_load_raw(void) -{ +lossless_jpeg_load_raw(Image const image) { + int jwide, jrow, jcol, val, jidx, i, row, col; struct jhead jh; int min=INT_MAX; diff --git a/converter/other/cameratopam/ljpeg.h b/converter/other/cameratopam/ljpeg.h index 60832a3d..cfd68eb4 100644 --- a/converter/other/cameratopam/ljpeg.h +++ b/converter/other/cameratopam/ljpeg.h @@ -1,11 +1,12 @@ +#include "camera.h" + struct jhead { int bits, high, wide, clrs, vpred[4]; struct decode *huff[4]; unsigned short *row; }; -void -lossless_jpeg_load_raw(void); +LoadRawFn lossless_jpeg_load_raw; int ljpeg_start (FILE * ifp, struct jhead *jh); diff --git a/converter/other/fiasco/config.h b/converter/other/fiasco/config.h index 64b905f8..57b3518d 100644 --- a/converter/other/fiasco/config.h +++ b/converter/other/fiasco/config.h @@ -56,9 +56,6 @@ /* Define if you have the strcasecmp function. */ #define HAVE_STRCASECMP 1 -/* Define if you have the strdup function. */ -#define HAVE_STRDUP 1 - /* Define if you have the <X11/extensions/XShm.h> header file. */ /* #undef HAVE_X11_EXTENSIONS_XSHM_H */ diff --git a/converter/other/fiasco/lib/misc.c b/converter/other/fiasco/lib/misc.c index 11e2da54..782ed1e9 100644 --- a/converter/other/fiasco/lib/misc.c +++ b/converter/other/fiasco/lib/misc.c @@ -396,22 +396,6 @@ memmove (void *v_dst, const void *v_src, size_t n) } #endif /* not HAVE_MEMMOVE */ -#ifndef HAVE_STRDUP -char * -strdup (const char *s) -/* - * Duplicate given string 's'. - * - * Return value: - * pointer to new string value - */ -{ - assert (s); - - return strcpy (Calloc (strlen (s) + 1, sizeof (char)), s); -} -#endif /* not HAVE_STRDUP */ - /* Note that some systems have a "log2()" in the math library and some have a "log2" macro. So we name ours Log2. But to avoid lots of differences from the original fiasco source code, we define a diff --git a/converter/other/fiasco/lib/misc.h b/converter/other/fiasco/lib/misc.h index 29456590..28fd8b5a 100644 --- a/converter/other/fiasco/lib/misc.h +++ b/converter/other/fiasco/lib/misc.h @@ -72,10 +72,6 @@ memmove(void *dest, const void *src, size_t n); double Log2 (double x); -#ifndef HAVE_STRDUP -char * -strdup (const char *s); -#endif #ifndef HAVE_STRCASECMP bool_t strcaseeq (const char *s1, const char *s2); diff --git a/converter/other/giftopnm.c b/converter/other/giftopnm.c index 7d517aad..9a543532 100644 --- a/converter/other/giftopnm.c +++ b/converter/other/giftopnm.c @@ -19,6 +19,7 @@ describe the Lempel-Ziv base. */ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* for strcaseeq */ #include <string.h> #include <assert.h> diff --git a/converter/other/ipdb.c b/converter/other/ipdb.c index eec4495a..d6bd6ef5 100644 --- a/converter/other/ipdb.c +++ b/converter/other/ipdb.c @@ -19,6 +19,7 @@ * Authors: Eric A. Howe (mu@trends.net) * Bryan Henderson, 2010 */ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Ensure strdup() is in <string.h> */ #include <assert.h> #include <time.h> diff --git a/converter/other/jpeg2000/jpeg2ktopam.c b/converter/other/jpeg2000/jpeg2ktopam.c index 858c0fa4..405de9c9 100644 --- a/converter/other/jpeg2000/jpeg2ktopam.c +++ b/converter/other/jpeg2000/jpeg2ktopam.c @@ -9,8 +9,13 @@ *****************************************************************************/ #define _BSD_SOURCE 1 /* Make sure strdup() is in string.h */ -/* Make sure strdup() is in string.h and int_fast32_t is in inttypes.h */ -#define _XOPEN_SOURCE 600 +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ + /* In 2014.09, this was _XOPEN_SOURCE 600, with a comment saying it was + necessary to make <inttypes.h> define int_fast32_t, etc. on AIX. + <jasper/jasper.h> does use int_fast32_t and does include <inttypes.h>, + but plenty of source files of libjasper do to0, and they did not have + _XOPEN_SOURCE 600, so it would seem to be superfluous here too. + */ #include <string.h> #include <jasper/jasper.h> diff --git a/converter/other/jpeg2000/pamtojpeg2k.c b/converter/other/jpeg2000/pamtojpeg2k.c index 349018e1..b8905518 100644 --- a/converter/other/jpeg2000/pamtojpeg2k.c +++ b/converter/other/jpeg2000/pamtojpeg2k.c @@ -9,8 +9,14 @@ *****************************************************************************/ #define _BSD_SOURCE 1 /* Make sure strdup() is in string.h */ -/* Make sure strdup() is in string.h and int_fast32_t is in inttypes.h */ -#define _XOPEN_SOURCE 600 +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ + /* In 2014.09, this was _XOPEN_SOURCE 600, with a comment saying it was + necessary to make <inttypes.h> define int_fast32_t, etc. on AIX. + <jasper/jasper.h> does use int_fast32_t and does include <inttypes.h>, + but plenty of source files of libjasper do too, and they did not have + _XOPEN_SOURCE 600, so it would seem to be superfluous here too. + */ + #include <string.h> #include <jasper/jasper.h> diff --git a/converter/other/pamtopnm.c b/converter/other/pamtopnm.c index 9bb662b7..f043d721 100644 --- a/converter/other/pamtopnm.c +++ b/converter/other/pamtopnm.c @@ -17,23 +17,23 @@ #include "shhopt.h" #include "mallocvar.h" -struct cmdlineInfo { +struct CmdlineInfo { /* All the information the user supplied in the command line, in a form easy for the program to use. */ - const char *inputFilespec; /* Filespecs of input files */ - unsigned int assume; /* -assume option */ + const char * inputFileName; /* Name of input file */ + unsigned int assume; }; static void -parseCommandLine(int argc, char ** argv, - struct cmdlineInfo *cmdlineP) { +parseCommandLine(int argc, const char ** argv, + struct CmdlineInfo *cmdlineP) { /*---------------------------------------------------------------------------- Note that the file spec array we return is stored in the storage that was passed to us as the argv array. -----------------------------------------------------------------------------*/ - optEntry *option_def; + optEntry * option_def; /* Instructions to OptParseOptions3 on how to parse our options. */ optStruct3 opt; @@ -49,16 +49,18 @@ parseCommandLine(int argc, char ** argv, opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */ opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */ - pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0); + pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0); /* Uses and sets argc, argv, and some of *cmdlineP and others. */ if (argc-1 == 0) - cmdlineP->inputFilespec = "-"; + cmdlineP->inputFileName = "-"; else if (argc-1 != 1) pm_error("Program takes zero or one argument (filename). You " "specified %d", argc-1); else - cmdlineP->inputFilespec = argv[1]; + cmdlineP->inputFileName = argv[1]; + + free(option_def); } @@ -105,19 +107,19 @@ validateTupleType(struct pam const inpam, int -main(int argc, char *argv[]) { +main(int argc, const char **argv) { - struct cmdlineInfo cmdline; - FILE* ifP; + struct CmdlineInfo cmdline; + FILE * ifP; int eof; /* no more images in input stream */ struct pam inpam; /* Input PAM image */ struct pam outpam; /* Output PNM image */ - pnm_init(&argc, argv); + pm_proginit(&argc, argv); parseCommandLine(argc, argv, &cmdline); - ifP = pm_openr(cmdline.inputFilespec); + ifP = pm_openr(cmdline.inputFileName); eof = FALSE; while (!eof) { diff --git a/converter/other/pgmtoppm.c b/converter/other/pgmtoppm.c index b556e0d2..f8a69424 100644 --- a/converter/other/pgmtoppm.c +++ b/converter/other/pgmtoppm.c @@ -10,6 +10,7 @@ ** implied warranty. */ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Make sure strdup() is in <string.h> */ #include <string.h> diff --git a/converter/other/pstopnm.c b/converter/other/pstopnm.c index 554dc8f3..b253442f 100644 --- a/converter/other/pstopnm.c +++ b/converter/other/pstopnm.c @@ -116,7 +116,7 @@ parseCommandLine(int argc, char ** argv, OPTENT3(0, "nocrop", OPT_FLAG, NULL, &cmdlineP->nocrop, 0); OPTENT3(0, "pbm", OPT_FLAG, NULL, &pbmOpt , 0); OPTENT3(0, "pgm", OPT_FLAG, NULL, &pgmOpt, 0); - OPTENT3(0, "ppm", OPT_FLAG, NULL, &ppmOpt, 0); + OPTENT3(0, "ppm", OPT_FLAG, NULL, &ppmOpt, 0); OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0); OPTENT3(0, "xborder", OPT_FLOAT, &cmdlineP->xborder, NULL, 0); OPTENT3(0, "xmax", OPT_UINT, &cmdlineP->xmax, &xmaxSpec, 0); @@ -125,8 +125,8 @@ parseCommandLine(int argc, char ** argv, OPTENT3(0, "ymax", OPT_UINT, &cmdlineP->ymax, &ymaxSpec, 0); OPTENT3(0, "ysize", OPT_UINT, &cmdlineP->ysize, &ysizeSpec, 0); OPTENT3(0, "dpi", OPT_UINT, &cmdlineP->dpi, &dpiSpec, 0); - OPTENT3(0, "portrait", OPT_FLAG, NULL, &portraitOpt, 0); - OPTENT3(0, "landscape", OPT_FLAG, NULL, &landscapeOpt, 0); + OPTENT3(0, "portrait", OPT_FLAG, NULL, &portraitOpt, 0); + OPTENT3(0, "landscape", OPT_FLAG, NULL, &landscapeOpt, 0); OPTENT3(0, "stdout", OPT_FLAG, NULL, &cmdlineP->stdoutSpec, 0); OPTENT3(0, "textalphabits", OPT_UINT, &cmdlineP->textalphabits, &textalphabitsSpec, 0); diff --git a/converter/other/svgtopam.c b/converter/other/svgtopam.c index 26530b9b..137f4732 100644 --- a/converter/other/svgtopam.c +++ b/converter/other/svgtopam.c @@ -26,6 +26,7 @@ ============================================================================*/ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Make sure strdup() is in <string.h> */ #define _POSIX_SOURCE /* Make sure fileno() is in <stdio.h> */ #include <assert.h> diff --git a/converter/other/tifftopnm.c b/converter/other/tifftopnm.c index 214c02aa..595d4937 100644 --- a/converter/other/tifftopnm.c +++ b/converter/other/tifftopnm.c @@ -78,7 +78,7 @@ #define PHOTOMETRIC_DEPTH 32768 #endif -struct cmdlineInfo { +struct CmdlineInfo { /* All the information the user supplied in the command line, in a form easy for the program to use. */ @@ -96,7 +96,7 @@ struct cmdlineInfo { static void parseCommandLine(int argc, const char ** const argv, - struct cmdlineInfo * const cmdlineP) { + struct CmdlineInfo * const cmdlineP) { /*---------------------------------------------------------------------------- Note that many of the strings that this function returns in the *cmdlineP structure are actually in the supplied argv array. And @@ -219,6 +219,8 @@ tiffToImageDim(unsigned int const tiffCols, } } + + static void getTiffDimensions(TIFF * const tiffP, unsigned int * const colsP, @@ -338,15 +340,15 @@ readDirectory(TIFF * const tiffP, static void -readscanline(TIFF * const tif, - unsigned char scanbuf[], - int const row, - int const plane, - unsigned int const cols, - unsigned short const bps, - unsigned short const spp, - unsigned short const fillorder, - unsigned int * const samplebuf) { +readscanline(TIFF * const tif, + unsigned char * const scanbuf, + int const row, + int const plane, + unsigned int const cols, + unsigned short const bps, + unsigned short const spp, + unsigned short const fillorder, + unsigned int * const samplebuf) { /*---------------------------------------------------------------------------- Read one scanline out of the Tiff input and store it into samplebuf[]. Unlike the scanline returned by the Tiff library function, samplebuf[] @@ -440,8 +442,11 @@ readscanline(TIFF * const tif, static void -pick_cmyk_pixel(const unsigned int samplebuf[], const int sample_cursor, - xelval * const r_p, xelval * const b_p, xelval * const g_p) { +pick_cmyk_pixel(unsigned int const samplebuf[], + int const sampleCursor, + xelval * const redP, + xelval * const bluP, + xelval * const grnP) { /* Note that the TIFF spec does not say which of the 4 samples is which, but common sense says they're in order C,M,Y,K. Before @@ -449,10 +454,10 @@ pick_cmyk_pixel(const unsigned int samplebuf[], const int sample_cursor, But combined with a compensating error in the CMYK->RGB calculation, it had the same effect as C,M,Y,K. */ - unsigned int const c = samplebuf[sample_cursor+0]; - unsigned int const m = samplebuf[sample_cursor+1]; - unsigned int const y = samplebuf[sample_cursor+2]; - unsigned int const k = samplebuf[sample_cursor+3]; + unsigned int const c = samplebuf[sampleCursor + 0]; + unsigned int const m = samplebuf[sampleCursor + 1]; + unsigned int const y = samplebuf[sampleCursor + 2]; + unsigned int const k = samplebuf[sampleCursor + 3]; /* The CMYK->RGB formula used by TIFFRGBAImageGet() in the TIFF library is the following, (with some apparent confusion with @@ -470,9 +475,9 @@ pick_cmyk_pixel(const unsigned int samplebuf[], const int sample_cursor, Yellow ink removes blue light from what the white paper reflects. */ - *r_p = 255 - MIN(255, c + k); - *g_p = 255 - MIN(255, m + k); - *b_p = 255 - MIN(255, y + k); + *redP = 255 - MIN(255, c + k); + *grnP = 255 - MIN(255, m + k); + *bluP = 255 - MIN(255, y + k); } @@ -509,9 +514,9 @@ analyzeImageType(TIFF * const tif, unsigned short const photomet, xelval * const maxvalP, int * const formatP, - xel colormap[], + xel * const colormap, bool const headerdump, - struct cmdlineInfo const cmdline) { + struct CmdlineInfo const cmdline) { bool grayscale; @@ -1078,8 +1083,8 @@ pnmOut_writeRow(pnmOut * const pnmOutP, static void convertRow(unsigned int const samplebuf[], - xel xelrow[], - gray alpharow[], + xel * const xelrow, + gray * const alpharow, int const cols, xelval const maxval, unsigned short const photomet, @@ -1155,9 +1160,9 @@ convertRow(unsigned int const samplebuf[], static void -scale32to16(unsigned int samplebuf[], - unsigned int const cols, - unsigned int const spp) { +scale32to16(unsigned int * const samplebuf, + unsigned int const cols, + unsigned int const spp) { /*---------------------------------------------------------------------------- Convert every sample in samplebuf[] to something that can be expressed in 16 bits, assuming it takes 32 bits now. @@ -1170,9 +1175,9 @@ scale32to16(unsigned int samplebuf[], static void -convertMultiPlaneRow(TIFF * const tif, - xel xelrow[], - gray alpharow[], +convertMultiPlaneRow(TIFF * const tif, + xel * const xelrow, + gray * const alpharow, int const cols, xelval const maxval, int const row, @@ -1188,15 +1193,15 @@ convertMultiPlaneRow(TIFF * const tif, for the blues. */ - int col; - if (photomet != PHOTOMETRIC_RGB) pm_error("This is a multiple-plane file, but is not an RGB " "file. This program does not know how to handle that."); else { + unsigned int col; + /* First, clear the buffer so we can add red, green, and blue one at a time. - */ + */ for (col = 0; col < cols; ++col) PPM_ASSIGN(xelrow[col], 0, 0, 0); @@ -1249,8 +1254,8 @@ convertRasterByRows(pnmOut * const pnmOutP, bool const verbose) { /*---------------------------------------------------------------------------- With the TIFF header all processed (and relevant information from it in - our arguments), write out the TIFF raster to the file images *imageoutFile - and *alphaFile. + our arguments), write out the TIFF raster to the Netpbm output files + as described by *pnmOutP. Do this one row at a time, employing the TIFF library's TIFFReadScanline. @@ -1270,12 +1275,12 @@ convertRasterByRows(pnmOut * const pnmOutP, row we are presently converting. */ - int row; + unsigned int row; if (verbose) pm_message("Converting row by row ..."); - scanbuf = (unsigned char *) malloc(TIFFScanlineSize(tif)); + MALLOCARRAY(scanbuf, TIFFScanlineSize(tif)); if (scanbuf == NULL) pm_error("can't allocate memory for scanline buffer"); @@ -1409,20 +1414,23 @@ convertTiffRaster(uint32 * const raster, -enum convertDisp {CONV_DONE, CONV_OOM, CONV_UNABLE, CONV_FAILED, +enum convertDisp {CONV_DONE, + CONV_OOM, + CONV_UNABLE, + CONV_FAILED, CONV_NOTATTEMPTED}; static void -convertRasterInMemory(pnmOut * const pnmOutP, - xelval const maxval, - TIFF * const tif, - unsigned short const photomet, - unsigned short const planarconfig, - unsigned short const bps, - unsigned short const spp, - unsigned short const fillorder, - xel const colormap[], - bool const verbose, +convertRasterInMemory(pnmOut * const pnmOutP, + xelval const maxval, + TIFF * const tif, + unsigned short const photomet, + unsigned short const planarconfig, + unsigned short const bps, + unsigned short const spp, + unsigned short const fillorder, + xel const colormap[], + bool const verbose, enum convertDisp * const statusP) { /*---------------------------------------------------------------------------- With the TIFF header all processed (and relevant information from @@ -1512,6 +1520,7 @@ convertRaster(pnmOut * const pnmOutP, bool const verbose) { enum convertDisp status; + if (byrow || !flipOk) status = CONV_NOTATTEMPTED; else { @@ -1551,7 +1560,7 @@ static void convertImage(TIFF * const tifP, FILE * const alphaFileP, FILE * const imageoutFileP, - struct cmdlineInfo const cmdline) { + struct CmdlineInfo const cmdline) { struct tiffDirInfo tiffDir; int format; @@ -1588,7 +1597,7 @@ static void convertIt(TIFF * const tifP, FILE * const alphaFile, FILE * const imageoutFile, - struct cmdlineInfo const cmdline) { + struct CmdlineInfo const cmdline) { unsigned int imageSeq; bool eof; @@ -1613,7 +1622,7 @@ convertIt(TIFF * const tifP, int main(int argc, const char * argv[]) { - struct cmdlineInfo cmdline; + struct CmdlineInfo cmdline; TIFF * tif; FILE * alphaFile; FILE * imageoutFile; @@ -1654,6 +1663,7 @@ main(int argc, const char * argv[]) { pm_strfree(cmdline.inputFilename); /* If the program failed, it previously aborted with nonzero completion - code, via various function calls. */ + code, via various function calls. + */ return 0; } diff --git a/converter/pbm/pbmtonokia.c b/converter/pbm/pbmtonokia.c index 839e6cc1..bf3b9e41 100644 --- a/converter/pbm/pbmtonokia.c +++ b/converter/pbm/pbmtonokia.c @@ -4,6 +4,7 @@ Copyright information is at end of file. */ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Make sure strcaseeq() is in nstring.h */ #include <string.h> #include <assert.h> diff --git a/converter/ppm/ppmtompeg/gethostname.c b/converter/ppm/ppmtompeg/gethostname.c index 014b42e8..d20af17c 100644 --- a/converter/ppm/ppmtompeg/gethostname.c +++ b/converter/ppm/ppmtompeg/gethostname.c @@ -1,3 +1,4 @@ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Make sure strdup() is in string.h */ #include <string.h> diff --git a/converter/ppm/ppmtompeg/mpeg.c b/converter/ppm/ppmtompeg/mpeg.c index 86ce7c7a..5cd7b099 100644 --- a/converter/ppm/ppmtompeg/mpeg.c +++ b/converter/ppm/ppmtompeg/mpeg.c @@ -30,6 +30,7 @@ * HEADER FILES * *==============*/ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Make sure strdup() is in string.h */ #include "all.h" diff --git a/converter/ppm/ppmtompeg/ppmtompeg.c b/converter/ppm/ppmtompeg/ppmtompeg.c index b8ef37f1..bc788552 100644 --- a/converter/ppm/ppmtompeg/ppmtompeg.c +++ b/converter/ppm/ppmtompeg/ppmtompeg.c @@ -30,6 +30,7 @@ * HEADER FILES * *==============*/ +#define _XOPEN_SOURCE 500 /* Make sure strdup() is in string.h */ #define _BSD_SOURCE /* Make sure strdup() is in string.h */ #include <assert.h> diff --git a/converter/ppm/ppmtopict.c b/converter/ppm/ppmtopict.c index 7e19d755..36464b6c 100644 --- a/converter/ppm/ppmtopict.c +++ b/converter/ppm/ppmtopict.c @@ -193,32 +193,42 @@ putRect(FILE * const ifP, #define runtochar(c) (257-(c)) #define counttochar(c) ((c)-1) -static int -putRow(FILE * const ifP, - unsigned int const row, - unsigned int const cols, - pixel * const rowpixels, - char * const packed) { - +static void +putRow(FILE * const ofP, + unsigned int const row, + unsigned int const cols, + pixel * const rowpixels, + char * const outBuf, + unsigned int * const outCountP) { +/*---------------------------------------------------------------------------- + Write the row rowpixels[], which is 'cols' pixels wide and is row 'row' of + the image, to file *ofP in PICT format. + + Return as *outCountP the number of bytes we write to *ofP. + + Use buffer 'outBuf'. +-----------------------------------------------------------------------------*/ unsigned int i; unsigned int count; unsigned int run; unsigned int rep; - unsigned int oc; - pixel * pP; - pixel lastp; + unsigned int outCount; + pixel lastpix; char * p; - run = count = 0; - for (i = 0, pP = rowpixels + cols-1, p = packed, lastp = *pP; - i < cols; - ++i, lastp = *pP, --pP) { + run = 0; + count = 0; + lastpix = rowpixels[cols-1]; - if (PPM_EQUAL(lastp, *pP)) + for (i = 0, p = &outBuf[0]; i < cols; ++i) { + + pixel const pix = rowpixels[cols - 1 - i]; + + if (PPM_EQUAL(lastpix, pix)) ++run; else if (run < RUN_THRESH) { while (run > 0) { - *p++ = ppm_lookupcolor(cht, &lastp); + *p++ = ppm_lookupcolor(cht, &lastpix); --run; ++count; if (count == MAX_COUNT) { @@ -233,17 +243,18 @@ putRow(FILE * const ifP, count = 0; while (run > 0) { rep = MIN(run, MAX_RUN); - *p++ = ppm_lookupcolor(cht, &lastp); + *p++ = ppm_lookupcolor(cht, &lastpix); *p++ = runtochar(rep); assert(run >= rep); run -= rep; } run = 1; } + lastpix = pix; } if (run < RUN_THRESH) { while (run > 0) { - *p++ = ppm_lookupcolor(cht, &lastp); + *p++ = ppm_lookupcolor(cht, &lastpix); --run; ++count; if (count == MAX_COUNT) { @@ -257,7 +268,7 @@ putRow(FILE * const ifP, count = 0; while (run > 0) { rep = MIN(run, MAX_RUN); - *p++ = ppm_lookupcolor(cht, &lastp); + *p++ = ppm_lookupcolor(cht, &lastpix); *p++ = runtochar(rep); assert(run >= rep); run -= rep; @@ -268,22 +279,22 @@ putRow(FILE * const ifP, *p++ = counttochar(count); { - unsigned int const packcols = p - packed; + unsigned int const packcols = p - outBuf; /* How many we wrote */ if (cols-1 > 200) { - putShort(ifP, packcols); - oc = packcols + 2; + putShort(ofP, packcols); + outCount = packcols + 2; } else { - putc(packcols, ifP); - oc = packcols + 1; + putc(packcols, ofP); + outCount = packcols + 1; } } /* now write out the packed row */ - while(p != packed) { + while (p != outBuf) { --p; - putc(*p, ifP); + putc(*p, ofP); } - return oc; + *outCountP = outCount; } @@ -291,46 +302,44 @@ putRow(FILE * const ifP, # if 0 /* real dumb putRow with no compression */ -static unsigned int -putRow(FILE * const ifP, - unsigned int const row, - unsigned int const cols, - pixel * const rowpixels, - char * const packed) { +static void +putRow(FILE * const ifP, + unsigned int const row, + unsigned int const cols, + pixel * const rowpixels, + char * const outBuf, + unsigned int * const outCountP) { unsigned int const bc = cols + (cols + MAX_COUNT - 1) / MAX_COUNT; unsigned int i; - unsigned int oc; - pixel * pP; if (bc > 200) { putShort(ifP, bc); - oc = bc + 2; + *outCountP = bc + 2; } else { putc(bc, ifP); - oc = bc + 1; + *outCountP = bc + 1; } - for (i = 0, pP = rowpixels; i < cols;) { - if (cols - i > MAX_COUNT) { + for (col = 0; col < cols;) { + if (cols - col > MAX_COUNT) { unsigned int j; putc(MAX_COUNT - 1, ifP); for (j = 0; j < MAX_COUNT; ++j) { - putc(ppm_lookupcolor(cht, pP), ifP); - ++pP; + putc(ppm_lookupcolor(cht, &rowPixels[col]), ifP); + ++col } - i += MAX_COUNT; + col += MAX_COUNT; } else { unsigned int j; - putc(cols - i - 1, ifP); - for (j = 0; j < cols - i; ++j) { - putc(ppm_lookupcolor(cht, pP), ifP); + putc(cols - col - 1, ifP); + for (j = 0; j < cols - col; ++j) { + putc(ppm_lookupcolor(cht, &rowPixels[col]), ifP); ++pP; } - i = cols; + col = cols; } } - return oc; } #endif /* 0 */ @@ -346,7 +355,7 @@ main(int argc, const char ** argv) { int rows, cols; unsigned int row; pixel ** pixels; - char * packed; + char * outBuf; pixval maxval; long lmaxval, rval, gval, bval; colorhist_vector chv; @@ -441,10 +450,12 @@ main(int argc, const char ** argv) { putShort(stdout, 0); /* mode */ /* Finally, write out the data. */ - packed = malloc((unsigned)(cols+cols/MAX_COUNT+1)); - for (row = 0, oc = 0; row < rows; row++) - oc += putRow(stdout, row, cols, pixels[row], packed); - + outBuf = malloc((unsigned)(cols+cols/MAX_COUNT+1)); + for (row = 0, oc = 0; row < rows; ++row) { + unsigned int rowSize; + putRow(stdout, row, cols, pixels[row], outBuf, &rowSize); + oc += rowSize; + } /* if we wrote an odd number of pixdata bytes, pad */ if (oc & 0x1) putc(0, stdout); @@ -457,3 +468,5 @@ main(int argc, const char ** argv) { return 0; } + + |