cinelerra-5.1/cinelerra/dcraw.h

   1 /* CINELERRA dcraw.c */
   2
   3 #include <stdio.h>
   4 #include <stdint.h>
   5 #include <time.h>
   6
   7 #define CLASS DCRaw::
   8
   9 #if !defined(uchar)
  10 #define uchar unsigned char
  11 #endif
  12 #if !defined(ushort)
  13 #define ushort unsigned short
  14 #endif
  15
  16 class DCRaw {
  17         int fcol(int row,int col);
  18 #if 0
  19         char *my_memmem(char *haystack,size_t haystacklen,char *needle,size_t needlelen);
  20         char *my_strcasestr(char *haystack,const char *needle);
  21 #endif
  22         void merror(void *ptr,const char *where);
  23         void derror(void);
  24         ushort sget2(uchar *s);
  25         ushort get2(void);
  26         unsigned sget4(uchar *s);
  27         unsigned get4(void);
  28         unsigned getint(int type);
  29         float int_to_float(int i);
  30         double getreal(int type);
  31         void read_shorts(ushort *pixel,int count);
  32         void cubic_spline(const int *x_,const int *y_,const int len);
  33         void canon_600_fixed_wb(int temp);
  34         int canon_600_color(int ratio[2],int mar);
  35         void canon_600_auto_wb(void);
  36         void canon_600_coeff(void);
  37         void canon_600_load_raw(void);
  38         void canon_600_correct(void);
  39         int canon_s2is(void);
  40         unsigned getbithuff(int nbits,ushort *huff);
  41         ushort *make_decoder_ref(const uchar **source);
  42         ushort *make_decoder(const uchar *source);
  43         void crw_init_tables(unsigned table,ushort *huff[2]);
  44         int canon_has_lowbits(void);
  45         void canon_load_raw(void);
  46         int ljpeg_start(struct jhead *jh,int info_only);
  47         void ljpeg_end(struct jhead *jh);
  48         int ljpeg_diff(ushort *huff);
  49         ushort *ljpeg_row(int jrow,struct jhead *jh);
  50         void lossless_jpeg_load_raw(void);
  51         void canon_sraw_load_raw(void);
  52         void adobe_copy_pixel(unsigned row,unsigned col,ushort **rp);
  53         void ljpeg_idct(struct jhead *jh);
  54         void lossless_dng_load_raw(void);
  55         void packed_dng_load_raw(void);
  56         void pentax_load_raw(void);
  57         void nikon_load_raw(void);
  58         void nikon_yuv_load_raw(void);
  59         int nikon_e995(void);
  60         int nikon_e2100(void);
  61         void nikon_3700(void);
  62         int minolta_z2(void);
  63         void ppm_thumb(void);
  64         void ppm16_thumb(void);
  65         void layer_thumb(void);
  66         void rollei_thumb(void);
  67         void rollei_load_raw(void);
  68         int raw(unsigned row,unsigned col);
  69         void phase_one_flat_field(int is_float,int nc);
  70         void phase_one_correct(void);
  71         void phase_one_load_raw(void);
  72         unsigned ph1_bithuff(int nbits,ushort *huff);
  73         void phase_one_load_raw_c(void);
  74         void hasselblad_load_raw(void);
  75         void leaf_hdr_load_raw(void);
  76         void unpacked_load_raw(void);
  77         void sinar_4shot_load_raw(void);
  78         void imacon_full_load_raw(void);
  79         void packed_load_raw(void);
  80         void nokia_load_raw(void);
  81         void canon_rmf_load_raw(void);
  82         unsigned pana_bits(int nbits);
  83         void panasonic_load_raw(void);
  84         void olympus_load_raw(void);
  85         void minolta_rd175_load_raw(void);
  86         void quicktake_100_load_raw(void);
  87         void kodak_radc_load_raw(void);
  88         void kodak_jpeg_load_raw(void);
  89         void lossy_dng_load_raw(void);
  90 #ifndef NO_JPEG
  91         boolean fill_input_buffer(j_decompress_ptr cinfo);
  92 #endif
  93         void kodak_dc120_load_raw(void);
  94         void eight_bit_load_raw(void);
  95         void kodak_c330_load_raw(void);
  96         void kodak_c603_load_raw(void);
  97         void kodak_262_load_raw(void);
  98         int kodak_65000_decode(short *out,int bsize);
  99         void kodak_65000_load_raw(void);
 100         void kodak_ycbcr_load_raw(void);
 101         void kodak_rgb_load_raw(void);
 102         void kodak_thumb_load_raw(void);
 103         void sony_decrypt(unsigned *data,int len,int start,int key);
 104         void sony_load_raw(void);
 105         void sony_arw_load_raw(void);
 106         void sony_arw2_load_raw(void);
 107         void samsung_load_raw(void);
 108         void samsung2_load_raw(void);
 109         void samsung3_load_raw(void);
 110         void smal_decode_segment(unsigned seg[2][2],int holes);
 111         void smal_v6_load_raw(void);
 112         int median4(int *p);
 113         void fill_holes(int holes);
 114         void smal_v9_load_raw(void);
 115         void redcine_load_raw(void);
 116         void foveon_decoder(unsigned size,unsigned code);
 117         void foveon_thumb(void);
 118         void foveon_sd_load_raw(void);
 119         void foveon_huff(ushort *huff);
 120         void foveon_dp_load_raw(void);
 121         void foveon_load_camf(void);
 122         const char *foveon_camf_param(const char *block,const char *param);
 123         void *foveon_camf_matrix(unsigned dim[3],const char *name);
 124         int foveon_fixed(void *ptr,int size,const char *name);
 125         float foveon_avg(short *pix,int range[2],float cfilt);
 126         short *foveon_make_curve(double max,double mul,double filt);
 127         void foveon_make_curves(short **curvep,float dq[3],float div[3],float filt);
 128         int foveon_apply_curve(short *curve,int i);
 129         void foveon_interpolate(void);
 130         void crop_masked_pixels(void);
 131         void remove_zeroes(void);
 132         void bad_pixels(const char *cfname);
 133         void subtract(const char *fname);
 134         void gamma_curve(double pwr,double ts,int mode,int imax);
 135         void pseudoinverse (double (*in)[3],double (*out)[3],int size);
 136         void cam_xyz_coeff(float rgb_cam[3][4],double cam_xyz[4][3]);
 137 #ifdef COLORCHECK
 138         void colorcheck(void);
 139 #endif
 140         void hat_transform(float *temp,float *base,int st,int size,int sc);
 141         void wavelet_denoise(void);
 142         void scale_colors(void);
 143         void pre_interpolate(void);
 144         void border_interpolate(int border);
 145         void lin_interpolate(void);
 146         void vng_interpolate(void);
 147         void ppg_interpolate(void);
 148         void cielab(ushort rgb[3],short lab[3]);
 149         void xtrans_interpolate(int passes);
 150         void ahd_interpolate(void);
 151         void median_filter(void);
 152         void blend_highlights(void);
 153         void recover_highlights(void);
 154         void tiff_get(unsigned base,unsigned *tag,unsigned *type,unsigned *len,unsigned *save);
 155         void parse_thumb_note(int base,unsigned toff,unsigned tlen);
 156         void parse_makernote(int base,int uptag);
 157         void get_timestamp(int reversed);
 158         void parse_exif(int base);
 159         void parse_gps(int base);
 160         void romm_coeff(float romm_cam[3][3]);
 161         void parse_mos(int offset);
 162         void linear_table(unsigned len);
 163         void parse_kodak_ifd(int base);
 164         int parse_tiff_ifd(int base);
 165         int parse_tiff(int base);
 166         void apply_tiff(void);
 167         void parse_minolta(int base);
 168         void parse_external_jpeg(void);
 169         void ciff_block_1030(void);
 170         void parse_ciff(int offset,int length,int depth);
 171         void parse_rollei(void);
 172         void parse_sinar_ia(void);
 173         void parse_phase_one(int base);
 174         void parse_fuji(int offset);
 175         int parse_jpeg(int offset);
 176         void parse_riff(void);
 177         void parse_qt(int end);
 178         void parse_smal(int offset,int fsize);
 179         void parse_cine(void);
 180         void parse_redcine(void);
 181         char *foveon_gets(int offset,char *str,int len);
 182         void parse_foveon(void);
 183         void adobe_coeff(const char *make,const char *model);
 184         void simple_coeff(int index);
 185         short guess_byte_order(int words);
 186         float find_green(int bps,int bite,int off0,int off1);
 187         void identify(void);
 188 #ifndef NO_LCMS
 189         void apply_profile(const char *input,const char *output);
 190 #endif
 191         void convert_to_rgb(void);
 192         void fuji_rotate(void);
 193         void stretch(void);
 194         int flip_index(int row, int col);
 195         void tiff_set(struct tiff_hdr *th,ushort *ntag,ushort tag,ushort type,int count,int val);
 196         void tiff_head(struct tiff_hdr *th,int full);
 197         void jpeg_thumb(void);
 198         void write_ppm_tiff(void);
 199         void write_cinelerra(void);
 200         void reset();
 201
 202         FILE *ifp, *ofp;
 203         short order;
 204         const char *ifname;
 205         char *meta_data, xtrans[6][6], xtrans_abs[6][6];
 206         char cdesc[5], desc[512], make[64], model[64], model2[64], artist[64];
 207         float flash_used, canon_ev, iso_speed, shutter, aperture, focal_len;
 208         time_t timestamp;
 209         off_t strip_offset, data_offset;
 210         off_t thumb_offset, meta_offset, profile_offset;
 211         unsigned shot_order, kodak_cbpp, exif_cfa, unique_id;
 212         unsigned thumb_length, meta_length, profile_length;
 213         unsigned thumb_misc, *oprof, fuji_layout;
 214         unsigned tiff_nifds, tiff_samples, tiff_bps, tiff_compress;
 215         unsigned black, maximum, mix_green, raw_color, zero_is_bad;
 216         unsigned zero_after_ff, is_raw, dng_version, is_foveon, data_error;
 217         unsigned tile_width, tile_length, gpsdata[32], load_flags;
 218         unsigned flip, tiff_flip, filters, colors;
 219         ushort raw_height, raw_width, height, width, top_margin, left_margin;
 220         ushort shrink, iheight, iwidth, fuji_width, thumb_width, thumb_height;
 221         ushort *raw_image, (*image)[4], cblack[4102];
 222         ushort white[8][8], curve[0x10000], cr2_slice[3], sraw_mul[4];
 223
 224         unsigned shot_select, multi_out;
 225         double pixel_aspect, aber[4], gamm[6];
 226         float bright, user_mul[4], threshold;
 227         int mask[8][4];
 228         int half_size, four_color_rgb, document_mode, highlight;
 229         int verbose, use_auto_wb, use_camera_wb, use_camera_matrix;
 230         int output_color, output_bps, output_tiff, med_passes;
 231         int no_auto_bright;
 232         unsigned greybox[4];
 233         float cam_mul[4], pre_mul[4], cmatrix[3][4], rgb_cam[3][4];
 234         const double xyz_rgb[3][3] = {                  /* XYZ from RGB */
 235                 { 0.412453, 0.357580, 0.180423 },
 236                 { 0.212671, 0.715160, 0.072169 },
 237                 { 0.019334, 0.119193, 0.950227 } };
 238         const float d65_white[3] = { 0.950456, 1, 1.088754 };
 239         int histogram[4][0x2000];
 240         void (CLASS *write_thumb)(), (CLASS *write_fun)();
 241         void (CLASS *load_raw)(), (CLASS *thumb_load_raw)();
 242         jmp_buf failure;
 243
 244         struct decode {
 245                 struct decode *branch[2];
 246                 int leaf;
 247         } first_decode[2048], /* *second_decode, CINELERRA */ *free_decode;
 248
 249         struct tiff_ifd {
 250                 int width, height, bps, comp, phint, offset, flip, samples, bytes;
 251                 int tile_width, tile_length;
 252                 float shutter;
 253         } tiff_ifd[10];
 254
 255         struct ph1 {
 256                 int format, key_off, tag_21a;
 257                 int black, split_col, black_col, split_row, black_row;
 258                 float tag_210;
 259         } ph1;
 260
 261 // local static data
 262         unsigned gbh_bitbuf;
 263         int gbh_vbits, gbh_reset;
 264         uint64_t ph1_bitbuf;
 265         int ph1_vbits;
 266         float ljpeg_cs[106];
 267         unsigned sony_pad[128], sony_p;
 268         unsigned fov_huff[1024];
 269         float clb_cbrt[0x10000], clb_xyz_cam[3][4];
 270         uchar pana_buf[0x4000];  int pana_vbits;
 271
 272 public:
 273         DCRaw();
 274         ~DCRaw();
 275
 276         char info[1024];
 277         float **data;
 278         int alpha;
 279         float matrix[9];
 280         int main(int argc, const char **argv);
 281 };
 282
 283 struct jhead;
 284 struct tiff_tag;
 285 struct tiff_hdr;
 286