/* -*- C++ -*-
 * File: libraw_internal_funcs.h
 * Copyright 2008-2025 LibRaw LLC (info@libraw.org)
 * Created: Sat Mar  14, 2008

LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:

1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
   (See file LICENSE.LGPL provided in LibRaw distribution archive for details).

2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
   (See file LICENSE.CDDL provided in LibRaw distribution archive for details).

 */

#ifndef _LIBRAW_INTERNAL_FUNCS_H
#define _LIBRAW_INTERNAL_FUNCS_H

#ifndef LIBRAW_LIBRARY_BUILD
#error "This file should be used only for libraw library build"
#else

/* inline functions */
	static int stread(char *buf, size_t len, LibRaw_abstract_datastream *fp);
	static int getwords(char *line, char *words[], int maxwords, int maxlen);
	static void remove_trailing_spaces(char *string, size_t len);
	static void remove_caseSubstr(char *string, char *remove);
	static void removeExcessiveSpaces(char *string);
	static void trimSpaces(char *s);
/* static tables/variables */
	static libraw_static_table_t tagtype_dataunit_bytes;
	static libraw_static_table_t Canon_wbi2std;
	static libraw_static_table_t Canon_KeyIsZero_Len2048_linenums_2_StdWBi;
	static libraw_static_table_t Canon_KeyIs0x0410_Len3072_linenums_2_StdWBi;
	static libraw_static_table_t Canon_KeyIs0x0410_Len2048_linenums_2_StdWBi;
	static libraw_static_table_t Canon_D30_linenums_2_StdWBi;
	static libraw_static_table_t Canon_G9_linenums_2_StdWBi;

	static libraw_static_table_t Fuji_wb_list1;
	static libraw_static_table_t FujiCCT_K;
	static libraw_static_table_t Fuji_wb_list2;

	static libraw_static_table_t Pentax_wb_list1;
	static libraw_static_table_t Pentax_wb_list2;

	static libraw_static_table_t Oly_wb_list1;
	static libraw_static_table_t Oly_wb_list2;

	static libraw_static_table_t Sony_SRF_wb_list;
	static libraw_static_table_t Sony_SR2_wb_list;
	static libraw_static_table_t Sony_SR2_wb_list1;
/*  */
	int	find_ifd_by_offset(INT64 );
	void 	libraw_swab(void *arr, int len);
	ushort	sget2 (uchar *s);
	ushort	sget2Rev(uchar *s);
	libraw_area_t	get_CanonArea();
	int	parseCR3(UINT64 oAtomList, UINT64 szAtomList, short &nesting, char *AtomNameStack, short& nTrack, short &TrackType, UINT64 filesz);
	void 	selectCRXTrack();
	void    parseCR3_Free();
	int     parseCR3_CTMD(short trackNum);
	int     selectCRXFrame(short trackNum, unsigned frameIndex);
	void	setCanonBodyFeatures (unsigned long long id);
	void	processCanonCameraInfo (unsigned long long id, uchar *CameraInfo, unsigned maxlen, unsigned type, unsigned dng_writer);
	static float _CanonConvertAperture(ushort in);
	void	Canon_CameraSettings(unsigned len);
	void	Canon_WBpresets (int skip1, int skip2);
	void	Canon_WBCTpresets (short WBCTversion);
	void	parseCanonMakernotes (unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	processNikonLensData (uchar *LensData, unsigned len);
	void	Nikon_NRW_WBtag (int wb, int skip);
	void	parseNikonMakernote (INT64 base, int uptag, unsigned dng_writer);
	void	parseEpsonMakernote (INT64 base, int uptag, unsigned dng_writer);
	void	parseSigmaMakernote (INT64 base, int uptag, unsigned dng_writer);
	void	setOlympusBodyFeatures (unsigned long long id);
	void	getOlympus_CameraType2 ();
	void	getOlympus_SensorTemperature (unsigned len);
	void	parseOlympus_Equipment (unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	parseOlympus_CameraSettings (INT64 base, unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	parseOlympus_ImageProcessing (unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	parseOlympus_RawInfo (unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void parseOlympusMakernotes (INT64 base, unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	setPhaseOneFeatures (unsigned long long id);
	void	setPentaxBodyFeatures (unsigned long long id);
	void	PentaxISO (ushort c);
	void	PentaxLensInfo (unsigned long long id, unsigned len);
	void	parsePentaxMakernotes(INT64 base, unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	parseRicohMakernotes(INT64 base, unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	parseSamsungMakernotes(INT64 base, unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	void	setSonyBodyFeatures (unsigned long long id);
	void	parseSonyLensType2 (uchar a, uchar b);
	void	parseSonyLensFeatures (uchar a, uchar b);
	void	process_Sony_0x0116 (uchar * buf, ushort, unsigned long long id);
	void	process_Sony_0x2010 (uchar * buf, ushort);
	void	process_Sony_0x9050 (uchar * buf, ushort, unsigned long long id);
	void	process_Sony_0x9400 (uchar * buf, ushort, unsigned long long id);
	void	process_Sony_0x9402 (uchar * buf, ushort);
	void	process_Sony_0x9403 (uchar * buf, ushort);
	void	process_Sony_0x9406 (uchar * buf, ushort);
	void	process_Sony_0x940c (uchar * buf, ushort);
	void	process_Sony_0x940e (uchar * buf, ushort, unsigned long long id);
	void	parseSonyMakernotes (INT64 base, unsigned tag, unsigned type, unsigned len, unsigned dng_writer,
                               uchar *&table_buf_0x0116, ushort &table_buf_0x0116_len,
                               uchar *&table_buf_0x2010, ushort &table_buf_0x2010_len,
                               uchar *&table_buf_0x9050, ushort &table_buf_0x9050_len,
                               uchar *&table_buf_0x9400, ushort &table_buf_0x9400_len,
                               uchar *&table_buf_0x9402, ushort &table_buf_0x9402_len,
                               uchar *&table_buf_0x9403, ushort &table_buf_0x9403_len,
                               uchar *&table_buf_0x9406, ushort &table_buf_0x9406_len,
                               uchar *&table_buf_0x940c, ushort &table_buf_0x940c_len,
                               uchar *&table_buf_0x940e, ushort &table_buf_0x940e_len);
	void	parseSonySR2 (uchar *cbuf_SR2, unsigned SR2SubIFDOffset, unsigned SR2SubIFDLength, unsigned dng_writer);
	void	parseSonySRF (unsigned len);
	void	parseFujiMakernotes (unsigned tag, unsigned type, unsigned len, unsigned dng_writer);
	const char* HassyRawFormat_idx2HR(unsigned idx);
	void	process_Hassy_Lens (int LensMount);
	void parseHassyModel ();

	void	setLeicaBodyFeatures(int LeicaMakernoteSignature);
	void	parseLeicaLensID();
	int 	parseLeicaLensName(unsigned len);
	int 	parseLeicaInternalBodySerial(unsigned len);
	void	parseLeicaMakernote(INT64 base, int uptag, unsigned MakernoteTagType);
	void	parseAdobePanoMakernote ();
	void	parseAdobeRAFMakernote ();
	void	GetNormalizedModel ();
	void	SetStandardIlluminants (unsigned, const char* );

	ushort      get2();
	unsigned    sget4 (uchar *s);
	unsigned    getint(int type);
	float       int_to_float (int i);
	double      getreal (int type);
	float		getrealf(int type) { return float(getreal(type)); }
	double      sgetreal(int type, uchar *s);
	void        read_shorts (ushort *pixel, unsigned count);

/* Canon P&S cameras */
	void        canon_600_fixed_wb (int temp);
	int         canon_600_color (int ratio[2], int mar);
	void        canon_600_auto_wb();
	void        canon_600_coeff();
	void        canon_600_load_raw();
	void        canon_600_correct();
	int         canon_s2is();
	void        parse_ciff (INT64 offset, int length, int);
	void        ciff_block_1030();


// LJPEG decoder
	unsigned    getbithuff (int nbits, ushort *huff);
	ushort*     make_decoder_ref (const uchar **source);
	ushort*     make_decoder (const uchar *source);
	int         ljpeg_start (struct jhead *jh, int info_only);
	void        ljpeg_end(struct jhead *jh);
	int         ljpeg_diff (ushort *huff);
	ushort *    ljpeg_row (int jrow, struct jhead *jh);
	ushort *    ljpeg_row_unrolled (int jrow, struct jhead *jh);
	void	    ljpeg_idct (struct jhead *jh);
	unsigned    ph1_bithuff (int nbits, ushort *huff);

// Canon DSLRs
	void        crw_init_tables (unsigned table, ushort *huff[2]);
	int         canon_has_lowbits();
	void        canon_load_raw();
	void        lossless_jpeg_load_raw();
	void        canon_sraw_load_raw();
// Adobe DNG
	void        adobe_copy_pixel (unsigned int row, unsigned int col, ushort **rp);
	void        lossless_dng_load_raw();
	void        deflate_dng_load_raw();
	void        packed_dng_load_raw();
    void        packed_tiled_dng_load_raw();
    void        uncompressed_fp_dng_load_raw();
	void        lossy_dng_load_raw();
//void        adobe_dng_load_raw_nc();

// Pentax
	void        pentax_load_raw();
	void	pentax_4shot_load_raw();

	void        pentax_tree();

// Nikon (and Minolta Z2)
	void        nikon_load_raw();
    void        nikon_he_load_raw();
	void        nikon_read_curve();
	void        nikon_load_striped_packed_raw();
	void        nikon_load_padded_packed_raw();
	void        nikon_load_sraw();
	void        nikon_yuv_load_raw();
	void        nikon_coolscan_load_raw();
	int         nikon_e995();
	int         nikon_e2100();
	void        nikon_3700();
	int         minolta_z2();
//	void        nikon_e2100_load_raw();

// Fuji
//	void        fuji_load_raw();
	int         guess_RAFDataGeneration (uchar *RAFData_start);
	void        parse_fuji (INT64 offset);
    void        parse_fuji_thumbnail(INT64 offset);

// Rollei
	void        rollei_load_raw();
	void        parse_rollei();

// Contax
	void        parse_kyocera ();

// MF backs
//int         bayer (unsigned row, unsigned col);
	int         p1raw(unsigned,unsigned);
	void        phase_one_flat_field (int is_float, int nc);
	int 	    p1rawc(unsigned row, unsigned col, unsigned& count);
	void 	    phase_one_fix_col_pixel_avg(unsigned row, unsigned col);
	void 	    phase_one_fix_pixel_grad(unsigned row, unsigned col);
	void        phase_one_load_raw();
	unsigned    ph1_bits (int nbits);
	void        phase_one_load_raw_c();
    void		phase_one_load_raw_s();
	void        hasselblad_load_raw();
	void        leaf_hdr_load_raw();
	void        sinar_4shot_load_raw();
	void        imacon_full_load_raw();
	void        hasselblad_full_load_raw();
	void        packed_load_raw();
	float       find_green(int,int,int,int);
	void        unpacked_load_raw();
	void        unpacked_load_raw_FujiDBP();
	void        unpacked_load_raw_reversed();
	void        unpacked_load_raw_fuji_f700s20();
	void        parse_sinar_ia();
	void        parse_phase_one (INT64 base);

// Misc P&S cameras
	void        parse_broadcom();
	void        broadcom_load_raw();
	void        nokia_load_raw();
	void        android_loose_load_raw();
	void        android_tight_load_raw();
	unsigned    pana_data (int nb, unsigned *bytes);
	void        panasonic_load_raw();
//	void        panasonic_16x10_load_raw();
	void        olympus_load_raw();
//	void        olympus_cseries_load_raw();
	void        minolta_rd175_load_raw();
	void        quicktake_100_load_raw();
	const int*  make_decoder_int (const int *source, int level);
	int         radc_token (int tree);
	void        kodak_radc_load_raw();
	void        kodak_jpeg_load_raw();
	void        kodak_dc120_load_raw();
	void        eight_bit_load_raw();
	void        smal_decode_segment (unsigned seg[2][2], int holes);
	void        smal_v6_load_raw();
	int         median4 (int *p);
	void        fill_holes (int holes);
	void        smal_v9_load_raw();
	void        parse_riff(int maxdepth);
	void        parse_cine();
	void        parse_smal (INT64 offset, INT64 fsize);
	int         parse_jpeg (INT64 offset);

// Kodak
	void        kodak_262_load_raw();
	int         kodak_65000_decode (short *out, int bsize);
	void        kodak_65000_load_raw();
	void        kodak_rgb_load_raw();
	void        kodak_ycbcr_load_raw();
//	void        kodak_yrgb_load_raw();
	void        kodak_c330_load_raw();
	void        kodak_c603_load_raw();
	void        kodak_rgb_load_thumb();
	void        kodak_ycbcr_load_thumb();
	void        vc5_dng_load_raw_placeholder();
	void        jxl_dng_load_raw_placeholder();
// It's a Sony (and K&M)
	void        sony_decrypt (unsigned *data, int len, int start, int key);
	void        sony_load_raw();
	void        sony_arw_load_raw();
	void        sony_arw2_load_raw();
	void        sony_arq_load_raw();
	void        sony_ljpeg_load_raw();
	void        sony_ycbcr_load_raw();
	void        samsung_load_raw();
	void        samsung2_load_raw();
	void        samsung3_load_raw();
	void        parse_minolta (INT64 base);

#ifdef USE_X3FTOOLS
// Foveon/Sigma
// We always have x3f code compiled in!
	void        parse_x3f();
	void        x3f_load_raw();
	void        x3f_dpq_interpolate_rg();
	void        x3f_dpq_interpolate_af(int xstep, int ystep, int scale); // 1x1 af pixels
	void        x3f_dpq_interpolate_af_sd(int xstart,int ystart, int xend, int yend, int xstep, int ystep, int scale); // sd Quattro interpolation
#else
	void        parse_x3f() {}
	void        x3f_load_raw(){}
#endif
#ifdef USE_6BY9RPI
	void		rpi_load_raw8();
	void		rpi_load_raw12();
	void		rpi_load_raw14();
	void		rpi_load_raw16();
	void		parse_raspberrypi();
#endif

	void kodak_thumb_loader();
	void dng_ycbcr_thumb_loader();
#ifdef USE_X3FTOOLS
    void x3f_thumb_loader();
    int x3f_thumb_size();
#endif
	
// CAM/RGB
	void        pseudoinverse (double (*in)[3], double (*out)[3], int size);
	void        simple_coeff (int index);

// Openp
	char** malloc_omp_buffers(int buffer_count, size_t buffer_size);
	void free_omp_buffers(char** buffers, int buffer_count);


// Tiff/Exif parsers
	void        tiff_get (INT64 base,unsigned *tag, unsigned *type, unsigned *len, INT64 *save);
	short       tiff_sget(unsigned save, uchar *buf, unsigned buf_len, INT64 *tag_offset,
                          unsigned *tag_id, unsigned *tag_type, INT64 *tag_dataoffset,
                          unsigned *tag_datalen, int *tag_dataunit_len);
	void        parse_thumb_note (INT64 base, unsigned toff, unsigned tlen);
	void        parse_makernote (INT64 base, int uptag);
	void        parse_makernote_0xc634(INT64 base, int uptag, unsigned dng_writer);
	void        parse_exif (INT64 base);
	void        parse_exif_interop(INT64 base);
	void        linear_table(unsigned len);
	void        Kodak_DCR_WBtags(int wb, unsigned type, int wbi);
	void        Kodak_KDC_WBtags(int wb, int wbi);
	short       KodakIllumMatrix (unsigned type, float *romm_camIllum);
	void        parse_kodak_ifd (INT64 base);
	int         parse_tiff_ifd (INT64 base);
	int         parse_tiff (INT64 base);
	void        apply_tiff(void);
	void        parse_gps (INT64 base);
	void        parse_gps_libraw(INT64 base);
	void        aRGB_coeff(double aRGB_cam[3][3]);
	void        romm_coeff(float romm_cam[3][3]);
	void        parse_mos (INT64 offset);
	void        parse_qt (INT64 end);
	void        get_timestamp (int reversed);

// The identify
    short       guess_byte_order (int words);
	void		identify_process_dng_fields();
	void		identify_finetune_pentax();
	void		identify_finetune_by_filesize(INT64);
	void		identify_finetune_dcr(char head[64],INT64,INT64);
// Tiff writer
	void        tiff_set(struct tiff_hdr *th, ushort *ntag,ushort tag, ushort type, int count, int val);
	void        tiff_head (struct tiff_hdr *th, int full);

// split AHD code
	void ahd_interpolate_green_h_and_v(int top, int left, ushort (*out_rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3]);
	void ahd_interpolate_r_and_b_in_rgb_and_convert_to_cielab(int top, int left, ushort (*inout_rgb)[LIBRAW_AHD_TILE][3], short (*out_lab)[LIBRAW_AHD_TILE][3]);
	void ahd_interpolate_r_and_b_and_convert_to_cielab(int top, int left, ushort (*inout_rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3], short (*out_lab)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3]);
	void ahd_interpolate_build_homogeneity_map(int top, int left, short (*lab)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3], char (*out_homogeneity_map)[LIBRAW_AHD_TILE][2]);
	void ahd_interpolate_combine_homogeneous_pixels(int top, int left, ushort (*rgb)[LIBRAW_AHD_TILE][LIBRAW_AHD_TILE][3], char (*homogeneity_map)[LIBRAW_AHD_TILE][2]);

	void init_fuji_compr(struct fuji_compressed_params* info);
	void init_fuji_block(struct fuji_compressed_block* info, const struct fuji_compressed_params *params, INT64 raw_offset, unsigned dsize);
	void copy_line_to_xtrans(struct fuji_compressed_block* info, int cur_line, int cur_block, int cur_block_width);
	void copy_line_to_bayer(struct fuji_compressed_block* info, int cur_line, int cur_block, int cur_block_width);
	void xtrans_decode_block(struct fuji_compressed_block* info, const struct fuji_compressed_params *params, int cur_line);
	void fuji_bayer_decode_block(struct fuji_compressed_block* info, const struct fuji_compressed_params *params, int cur_line);
	void fuji_compressed_load_raw();
	void fuji_14bit_load_raw();
	void parse_fuji_compressed_header();
	void crxLoadRaw();
	int  crxParseImageHeader(uchar *cmp1TagData, int nTrack, INT64 size);
	void panasonicC6_load_raw();
	void panasonicC7_load_raw();
	void panasonicC8_load_raw();

	void nikon_14bit_load_raw();

// DCB
	void  	dcb_pp();
	void  	dcb_copy_to_buffer(float (*image2)[3]);
	void  	dcb_restore_from_buffer(float (*image2)[3]);
	void  	dcb_color();
	void  	dcb_color_full();
	void  	dcb_map();
	void  	dcb_correction();
	void  	dcb_correction2();
	void  	dcb_refinement();
	void  	rgb_to_lch(double (*image3)[3]);
	void  	lch_to_rgb(double (*image3)[3]);
	void  	fbdd_correction();
	void  	fbdd_correction2(double (*image3)[3]);
	void  	fbdd_green();
	void  	dcb_ver(float (*image3)[3]);
	void 	dcb_hor(float (*image2)[3]);
	void 	dcb_color2(float (*image2)[3]);
	void 	dcb_color3(float (*image3)[3]);
	void 	dcb_decide(float (*image2)[3], float (*image3)[3]);
	void 	dcb_nyquist();
#endif

#endif
