pcompress/filters/packjpg/packjpg.cpp
Moinak Ghosh e90c52e516 Work in progress changes for packJPG encoding and decoding.
Enhance custom LibArchive filter functionlity.
2013-11-13 23:28:01 +05:30

7213 lines
210 KiB
C++

/*
packJPG v2.5g (09/14/2013)
~~~~~~~~~~~~~~~~~~~~~~~~~~
packJPG is a compression program specially designed for further
compression of JPEG images without causing any further loss. Typically
it reduces the file size of a JPEG file by 20%.
LGPL v3 license and special permissions
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
All programs in this package are free software; you can redistribute
them and/or modify them under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either version 3
of the License, or (at your option) any later version.
The package is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
General Public License for more details at
http://www.gnu.org/copyleft/lgpl.html.
If the LGPL v3 license is not compatible with your software project you
might contact us and ask for a special permission to use the packJPG
library under different conditions. In any case, usage of the packJPG
algorithm under the LGPL v3 or above is highly advised and special
permissions will only be given where necessary on a case by case basis.
This offer is aimed mainly at closed source freeware developers seeking
to add PJG support to their software projects.
Copyright 2006...2013 by HTW Aalen University and Matthias Stirner.
Usage of packJPG
~~~~~~~~~~~~~~~~
JPEG files are compressed and PJG files are decompressed using this
command:
"packJPG [file(s)]"
packJPG recognizes file types on its own and decides whether to compress
(JPG) or decompress (PJG). For unrecognized file types no action is
taken. Files are recognized by content, not by extension.
packJPG supports wildcards like "*.*" and drag and drop of multiple
files. Filenames for output files are created automatically. In default
mode, files are never overwritten. If a filename is already in use,
packJPG creates a new filename by adding underscores.
If "-" is used as a filename input from stdin is assumed and output is
written to stdout. This can be useful for example if jpegtran is to be
used as a preprocessor.
Usage examples:
"packJPG *.pjg"
"packJPG lena.jpg"
"packJPG kodim??.jpg"
"packJPG - < sail.pjg > sail.jpg"
Command line switches
~~~~~~~~~~~~~~~~~~~~~
-ver verify files after processing
-v? level of verbosity; 0,1 or 2 is allowed (default 0)
-np no pause after processing files
-o overwrite existing files
-p proceed on warnings
-d discard meta-info
By default, compression is cancelled on warnings. If warnings are
skipped by using "-p", most files with warnings can also be compressed,
but JPEG files reconstructed from PJG files might not be bitwise
identical with the original JPEG files. There won't be any loss to
image data or quality however.
Unnecessary meta information can be discarded using "-d". This reduces
compressed files' sizes. Be warned though, reconstructed files won't be
bitwise identical with the original files and meta information will be
lost forever. As with "-p" there won't be any loss to image data or
quality.
There is no known case in which a file compressed by packJPG (without
the "-p" option, see above) couldn't be reconstructed to exactly the
state it was before. If you want an additional layer of safety you can
also use the verify option "-ver". In this mode, files are compressed,
then decompressed and the decompressed file compared to the original
file. If this test doesn't pass there will be an error message and the
compressed file won't be written to the drive.
Please note that the "-ver" option should never be used in conjunction
with the "-d" and/or "-p" options. As stated above, the "-p" and "-d"
options will most likely lead to reconstructed JPG files not being
bitwise identical to the original JPG files. In turn, the verification
process may fail on various files although nothing actually went wrong.
Usage examples:
"packJPG -v1 -o baboon.pjg"
"packJPG -ver lena.jpg"
"packJPG -d tiffany.jpg"
"packJPG -p *.jpg"
Known Limitations
~~~~~~~~~~~~~~~~~
packJPG is a compression program specially for JPEG files, so it doesn't
compress other file types.
packJPG has low error tolerance. JPEG files might not work with packJPG
even if they work perfectly with other image processing software. The
command line switch "-p" can be used to increase error tolerance and
compatibility.
If you try to drag and drop to many files at once, there might be a
windowed error message about missing privileges. In that case you can
try it again with less files or consider using the command prompt.
packJPG has been tested to work perfectly with thousands of files from
the command line. This issue also happens with drag and drop in other
applications, so it might not be a limitation of packJPG but a
limitation of Windows.
Compressed PJG files are not compatible between different packJPG
versions. You will get an error message if you try to decompress PJG
files with a different version than the one used for compression. You
may download older versions of packJPG from:
http://www.elektronik.htw-aalen.de/packJPG/binaries/old/
Open source release / developer info
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The packJPG source codes is found inside the "source" subdirectory.
Additional documents aimed to developers, containing detailed
instructions on compiling the source code and using special
functionality, are included in the "packJPG" subdirectory.
History
~~~~~~~
v1.9a (04/20/2007) (non public)
- first released version
- only for testing purposes
v2.0 (05/28/2007) (public)
- first public version of packJPG
- minor improvements to overall compression
- minor bugfixes
v2.2 (08/05/2007) (public)
- around 40% faster compression & decompression
- major improvements to overall compression (around 2% on average)
- reading from stdin, writing to stdout
- smaller executable
- minor bugfixes
- various minor improvements
v2.3 (09/18/2007) (public)
- compatibility with JPEG progressive mode
- compatibility with JPEG extended sequential mode
- compatibility with the CMYK color space
- compatibility with older CPUs
- around 15% faster compression & decompression
- new switch: [-d] (discard meta-info)
- various bugfixes
v2.3a (11/21/2007) (public)
- crash issue with certain images fixed
- compatibility with packJPG v2.3 maintained
v2.3b (12/20/2007) (public)
- some minor errors in the packJPG library fixed
- compatibility with packJPG v2.3 maintained
v2.4 (03/24/2010) (public)
- major improvements (1%...2%) to overall compression
- around 10% faster compression & decompression
- major improvements to JPG compatibility
- size of executable reduced to ~33%
- new switch: [-ver] (verify file after processing)
- new switch: [-np] (no pause after processing)
- new progress bar output mode
- arithmetic coding routines rewritten from scratch
- various smaller improvements to numerous to list here
- new SFX (self extracting) archive format
v2.5 (11/11/2011) (public)
- improvements (~0.5%) to overall compression
- several minor bugfixes
- major code cleanup
- removed packJPX from the package
- added packARC to the package
- packJPG is now open source!
v2.5a (11/21/11) (public)
- source code compatibility improvements (Gerhard Seelmann)
- avoid some compiler warnings (Gerhard Seelmann)
- source code clean up (Gerhard Seelmann)
v2.5b (01/27/12) (public)
- further removal of redundant code
- some fixes for the packJPG static library
- compiler fix for Mac OS (thanks to Sergio Lopez)
- improved compression ratio calculation
- eliminated the need for temp files
v2.5c (04/13/12) (public)
- various source code optimizations
v2.5d (07/03/12) (public)
- fixed a rare bug with progressive JPEG
v2.5e (07/03/12) (public)
- some minor source code optimizations
- changed packJPG licensing to LGPL
- moved packARC to a separate package
v2.5f (02/24/13) (public)
- fixed a minor bug in the JPG parser (thanks to Stephan Busch)
v2.5g (09/14/13) (public)
- fixed a rare crash bug with manipulated JPEG files
Acknowledgements
~~~~~~~~~~~~~~~~
packJPG is the result of countless hours of research and development. It
is part of my final year project for Hochschule Aalen.
Prof. Dr. Gerhard Seelmann from Hochschule Aalen supported my
development of packJPG with his extensive knowledge in the field of data
compression. Without his advice, packJPG would not be possible.
The official homepage of packJPG is currently maintained by Hochschule
Aalen staff.
packJPG logo and icon are designed by Michael Kaufmann.
Contact
~~~~~~~
The official home of packJPG:
http://www.elektronik.htw-aalen.de/packjpg/
For questions and bug reports:
packjpg (at) htw-aalen.de
____________________________________
packJPG by Matthias Stirner, 09/2013
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctime>
#include "bitops.h"
#include "aricoder.h"
#include "pjpgtbl.h"
#include "dct8x8.h"
#if defined BUILD_DLL // define BUILD_LIB from the compiler options if you want to compile a DLL!
#define BUILD_LIB
#endif
#if defined BUILD_LIB // define BUILD_LIB as compiler option if you want to compile a library!
#include "packjpglib.h"
#endif
#define INTERN static
#define INIT_MODEL_S(a,b,c) new model_s( a, b, c, 255 )
#define INIT_MODEL_B(a,b) new model_b( a, b, 255 )
// #define USE_PLOCOI // uncomment to use loco-i predictor instead of 1DDCT predictor
// #define DEV_BUILD // uncomment to include developer functions
// #define DEV_INFOS // uncomment to include developer information
#define QUANT(cm,bp) ( cmpnfo[cm].qtable[ bp ] )
#define MAX_V(cm,bp) ( ( QUANT(cm,bp) > 0 ) ? ( ( freqmax[bp] + QUANT(cm,bp) - 1 ) / QUANT(cm,bp) ) : 0 )
// #define QUN_V(v,cm,bp) ( ( QUANT(cm,bp) > 0 ) ? ( ( v > 0 ) ? ( v + (QUANT(cm,bp)/2) ) / QUANT(cm,bp) : ( v - (QUANT(cm,bp)/2) ) / QUANT(cm,bp) ) : 0 )
#define ENVLI(s,v) ( ( v > 0 ) ? v : ( v - 1 ) + ( 1 << s ) )
#define DEVLI(s,n) ( ( n >= ( 1 << (s - 1) ) ) ? n : n + 1 - ( 1 << s ) )
#define E_ENVLI(s,v) ( v - ( 1 << s ) )
#define E_DEVLI(s,n) ( n + ( 1 << s ) )
#define ABS(v1) ( (v1 < 0) ? -v1 : v1 )
#define ABSDIFF(v1,v2) ( (v1 > v2) ? (v1 - v2) : (v2 - v1) )
#define IPOS(w,v,h) ( ( v * w ) + h )
#define NPOS(n1,n2,p) ( ( ( p / n1 ) * n2 ) + ( p % n1 ) )
#define ROUND_F(v1) ( (v1 < 0) ? (int) (v1 - 0.5) : (int) (v1 + 0.5) )
#define DIV_INT(v1,v2) ( (v1 < 0) ? (v1 - (v2>>1)) / v2 : (v1 + (v2>>1)) / v2 )
#define B_SHORT(v1,v2) ( ( ((int) v1) << 8 ) + ((int) v2) )
#define BITLEN1024P(v) ( pbitlen_0_1024[ v ] )
#define BITLEN2048N(v) ( (pbitlen_n2048_2047+2048)[ v ] )
#define CLAMPED(l,h,v) ( ( v < l ) ? l : ( v > h ) ? h : v )
#define MEM_ERRMSG "out of memory error"
#define FRD_ERRMSG "could not read file / file not found: %s"
#define FWR_ERRMSG "could not write file / file write-protected: %s"
#define MSG_SIZE 128
#define BARLEN 36
/* -----------------------------------------------
struct declarations
----------------------------------------------- */
struct componentInfo {
unsigned short* qtable; // quantization table
int huffdc; // no of huffman table (DC)
int huffac; // no of huffman table (AC)
int sfv; // sample factor vertical
int sfh; // sample factor horizontal
int mbs; // blocks in mcu
int bcv; // block count vertical (interleaved)
int bch; // block count horizontal (interleaved)
int bc; // block count (all) (interleaved)
int ncv; // block count vertical (non interleaved)
int nch; // block count horizontal (non interleaved)
int nc; // block count (all) (non interleaved)
int sid; // statistical identity
int jid; // jpeg internal id
};
struct huffCodes {
unsigned short cval[ 256 ];
unsigned short clen[ 256 ];
unsigned short max_eobrun;
};
struct huffTree {
unsigned short l[ 256 ];
unsigned short r[ 256 ];
};
/* -----------------------------------------------
function declarations: main interface
----------------------------------------------- */
#if !defined( BUILD_LIB )
INTERN void initialize_options( int argc, char** argv );
INTERN void process_ui( void );
INTERN inline const char* get_status( bool (*function)() );
INTERN void show_help( void );
#endif
INTERN void process_file( void );
INTERN void execute( bool (*function)() );
/* -----------------------------------------------
function declarations: main functions
----------------------------------------------- */
#if !defined( BUILD_LIB )
INTERN bool check_file( void );
INTERN bool swap_streams( void );
INTERN bool compare_output( void );
#endif
INTERN bool reset_buffers( void );
INTERN bool read_jpeg( void );
INTERN bool merge_jpeg( void );
INTERN bool decode_jpeg( void );
INTERN bool recode_jpeg( void );
INTERN bool adapt_icos( void );
INTERN bool predict_dc( void );
INTERN bool unpredict_dc( void );
INTERN bool check_value_range( void );
INTERN bool calc_zdst_lists( void );
INTERN bool pack_pjg( void );
INTERN bool unpack_pjg( void );
/* -----------------------------------------------
function declarations: jpeg-specific
----------------------------------------------- */
INTERN bool jpg_setup_imginfo( void );
INTERN bool jpg_parse_jfif( unsigned char type, unsigned int len, unsigned char* segment );
INTERN bool jpg_rebuild_header( void );
INTERN int jpg_decode_block_seq( abitreader* huffr, huffTree* dctree, huffTree* actree, short* block );
INTERN int jpg_encode_block_seq( abitwriter* huffw, huffCodes* dctbl, huffCodes* actbl, short* block );
INTERN int jpg_decode_dc_prg_fs( abitreader* huffr, huffTree* dctree, short* block );
INTERN int jpg_encode_dc_prg_fs( abitwriter* huffw, huffCodes* dctbl, short* block );
INTERN int jpg_decode_ac_prg_fs( abitreader* huffr, huffTree* actree, short* block,
int* eobrun, int from, int to );
INTERN int jpg_encode_ac_prg_fs( abitwriter* huffw, huffCodes* actbl, short* block,
int* eobrun, int from, int to );
INTERN int jpg_decode_dc_prg_sa( abitreader* huffr, short* block );
INTERN int jpg_encode_dc_prg_sa( abitwriter* huffw, short* block );
INTERN int jpg_decode_ac_prg_sa( abitreader* huffr, huffTree* actree, short* block,
int* eobrun, int from, int to );
INTERN int jpg_encode_ac_prg_sa( abitwriter* huffw, abytewriter* storw, huffCodes* actbl,
short* block, int* eobrun, int from, int to );
INTERN int jpg_decode_eobrun_sa( abitreader* huffr, short* block, int* eobrun, int from, int to );
INTERN int jpg_encode_eobrun( abitwriter* huffw, huffCodes* actbl, int* eobrun );
INTERN int jpg_encode_crbits( abitwriter* huffw, abytewriter* storw );
INTERN int jpg_next_huffcode( abitreader *huffw, huffTree *ctree );
INTERN int jpg_next_mcupos( int* mcu, int* cmp, int* csc, int* sub, int* dpos, int* rstw );
INTERN int jpg_next_mcuposn( int* cmp, int* dpos, int* rstw );
INTERN int jpg_skip_eobrun( int* cmp, int* dpos, int* rstw, int* eobrun );
INTERN void jpg_build_huffcodes( unsigned char *clen, unsigned char *cval,
huffCodes *hc, huffTree *ht );
/* -----------------------------------------------
function declarations: pjg-specific
----------------------------------------------- */
INTERN bool pjg_encode_zstscan( aricoder* enc, int cmp );
INTERN bool pjg_encode_zdst_high( aricoder* enc, int cmp );
INTERN bool pjg_encode_zdst_low( aricoder* enc, int cmp );
INTERN bool pjg_encode_dc( aricoder* enc, int cmp );
INTERN bool pjg_encode_ac_high( aricoder* enc, int cmp );
INTERN bool pjg_encode_ac_low( aricoder* enc, int cmp );
INTERN bool pjg_encode_generic( aricoder* enc, unsigned char* data, int len );
INTERN bool pjg_encode_bit( aricoder* enc, unsigned char bit );
INTERN bool pjg_decode_zstscan( aricoder* dec, int cmp );
INTERN bool pjg_decode_zdst_high( aricoder* dec, int cmp );
INTERN bool pjg_decode_zdst_low( aricoder* dec, int cmp );
INTERN bool pjg_decode_dc( aricoder* dec, int cmp );
INTERN bool pjg_decode_ac_high( aricoder* dec, int cmp );
INTERN bool pjg_decode_ac_low( aricoder* dec, int cmp );
INTERN bool pjg_decode_generic( aricoder* dec, unsigned char** data, int* len );
INTERN bool pjg_decode_bit( aricoder* dec, unsigned char* bit );
INTERN void pjg_get_zerosort_scan( unsigned char* sv, int cmp );
INTERN bool pjg_optimize_header( void );
INTERN bool pjg_unoptimize_header( void );
INTERN void pjg_aavrg_prepare( unsigned short** abs_coeffs, int* weights, unsigned short* abs_store, int cmp );
INTERN int pjg_aavrg_context( unsigned short** abs_coeffs, int* weights, int pos, int p_y, int p_x, int r_x );
INTERN int pjg_lakh_context( signed short** coeffs_x, signed short** coeffs_a, int* pred_cf, int pos );
INTERN void get_context_nnb( int pos, int w, int *a, int *b );
/* -----------------------------------------------
function declarations: DCT
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN int idct_2d_fst_8x8( int cmp, int dpos, int ix, int iy );
#endif
INTERN int idct_2d_fst_1x8( int cmp, int dpos, int ix, int iy );
INTERN int idct_2d_fst_8x1( int cmp, int dpos, int ix, int iy );
/* -----------------------------------------------
function declarations: prediction
----------------------------------------------- */
#if defined( USE_PLOCOI )
INTERN int dc_coll_predictor( int cmp, int dpos );
#else
INTERN int dc_1ddct_predictor( int cmp, int dpos );
#endif
INTERN inline int plocoi( int a, int b, int c );
INTERN inline int median_int( int* values, int size );
INTERN inline float median_float( float* values, int size );
/* -----------------------------------------------
function declarations: miscelaneous helpers
----------------------------------------------- */
#if !defined( BUILD_LIB )
INTERN inline void progress_bar( int current, int last );
INTERN inline char* create_filename( const char* base, const char* extension );
INTERN inline char* unique_filename( const char* base, const char* extension );
INTERN inline void set_extension( char* filename, const char* extension );
INTERN inline void add_underscore( char* filename );
#endif
INTERN inline bool file_exists( const char* filename );
/* -----------------------------------------------
function declarations: developers functions
----------------------------------------------- */
// these are developers functions, they are not needed
// in any way to compress jpg or decompress pjg
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN int collmode = 0; // write mode for collections: 0 -> std, 1 -> dhf, 2 -> squ, 3 -> unc
INTERN bool dump_hdr( void );
INTERN bool dump_huf( void );
INTERN bool dump_coll( void );
INTERN bool dump_zdst( void );
INTERN bool dump_file( const char* base, const char* ext, void* data, int bpv, int size );
INTERN bool dump_errfile( void );
INTERN bool dump_info( void );
INTERN bool dump_dist( void );
INTERN bool dump_pgm( void );
#endif
/* -----------------------------------------------
global variables: library only variables
----------------------------------------------- */
#if defined(BUILD_LIB)
INTERN int lib_in_type = -1;
INTERN int lib_out_type = -1;
#endif
/* -----------------------------------------------
global variables: data storage
----------------------------------------------- */
INTERN unsigned short qtables[4][64]; // quantization tables
INTERN huffCodes hcodes[2][4]; // huffman codes
INTERN huffTree htrees[2][4]; // huffman decoding trees
INTERN unsigned char htset[2][4]; // 1 if huffman table is set
INTERN unsigned char* grbgdata = NULL; // garbage data
INTERN unsigned char* hdrdata = NULL; // header data
INTERN unsigned char* huffdata = NULL; // huffman coded data
INTERN int hufs = 0 ; // size of huffman data
INTERN int hdrs = 0 ; // size of header
INTERN int grbs = 0 ; // size of garbage
INTERN unsigned int* rstp = NULL; // restart markers positions in huffdata
INTERN unsigned int* scnp = NULL; // scan start positions in huffdata
INTERN int rstc = 0 ; // count of restart markers
INTERN int scnc = 0 ; // count of scans
INTERN int rsti = 0 ; // restart interval
INTERN char padbit = -1 ; // padbit (for huffman coding)
INTERN unsigned char* rst_err = NULL; // number of wrong-set RST markers per scan
INTERN unsigned char* zdstdata[4] = { NULL }; // zero distribution (# of non-zeroes) lists (for higher 7x7 block)
INTERN unsigned char* eobxhigh[4] = { NULL }; // eob in x direction (for higher 7x7 block)
INTERN unsigned char* eobyhigh[4] = { NULL }; // eob in y direction (for higher 7x7 block)
INTERN unsigned char* zdstxlow[4] = { NULL }; // # of non zeroes for first row
INTERN unsigned char* zdstylow[4] = { NULL }; // # of non zeroes for first collumn
INTERN signed short* colldata[4][64] = {{NULL}}; // collection sorted DCT coefficients
INTERN unsigned char* freqscan[4] = { NULL }; // optimized order for frequency scans (only pointers to scans)
INTERN unsigned char zsrtscan[4][64]; // zero optimized frequency scan
INTERN int adpt_idct_8x8[ 4 ][ 8 * 8 * 8 * 8 ]; // precalculated/adapted values for idct (8x8)
INTERN int adpt_idct_1x8[ 4 ][ 1 * 1 * 8 * 8 ]; // precalculated/adapted values for idct (1x8)
INTERN int adpt_idct_8x1[ 4 ][ 8 * 8 * 1 * 1 ]; // precalculated/adapted values for idct (8x1)
/* -----------------------------------------------
global variables: info about image
----------------------------------------------- */
// seperate info for each color component
INTERN componentInfo cmpnfo[ 4 ];
INTERN int cmpc = 0; // component count
INTERN int imgwidth = 0; // width of image
INTERN int imgheight = 0; // height of image
INTERN int sfhm = 0; // max horizontal sample factor
INTERN int sfvm = 0; // max verical sample factor
INTERN int mcuv = 0; // mcus per line
INTERN int mcuh = 0; // mcus per collumn
INTERN int mcuc = 0; // count of mcus
/* -----------------------------------------------
global variables: info about current scan
----------------------------------------------- */
INTERN int cs_cmpc = 0 ; // component count in current scan
INTERN int cs_cmp[ 4 ] = { 0 }; // component numbers in current scan
INTERN int cs_from = 0 ; // begin - band of current scan ( inclusive )
INTERN int cs_to = 0 ; // end - band of current scan ( inclusive )
INTERN int cs_sah = 0 ; // successive approximation bit pos high
INTERN int cs_sal = 0 ; // successive approximation bit pos low
/* -----------------------------------------------
global variables: info about files
----------------------------------------------- */
INTERN char* jpgfilename = NULL; // name of JPEG file
INTERN char* pjgfilename = NULL; // name of PJG file
INTERN int jpgfilesize; // size of JPEG file
INTERN int pjgfilesize; // size of PJG file
INTERN int jpegtype = 0; // type of JPEG coding: 0->unknown, 1->sequential, 2->progressive
INTERN int filetype; // type of current file
INTERN iostream* str_in = NULL; // input stream
INTERN iostream* str_out = NULL; // output stream
#if !defined(BUILD_LIB)
INTERN iostream* str_str = NULL; // storage stream
INTERN char** filelist = NULL; // list of files to process
INTERN int file_cnt = 0; // count of files in list
INTERN int file_no = 0; // number of current file
INTERN char** err_list = NULL; // list of error messages
INTERN int* err_tp = NULL; // list of error types
#endif
#if defined(DEV_INFOS)
INTERN int dev_size_hdr = 0;
INTERN int dev_size_cmp[ 4 ] = { 0 };
INTERN int dev_size_zsr[ 4 ] = { 0 };
INTERN int dev_size_dc[ 4 ] = { 0 };
INTERN int dev_size_ach[ 4 ] = { 0 };
INTERN int dev_size_acl[ 4 ] = { 0 };
INTERN int dev_size_zdh[ 4 ] = { 0 };
INTERN int dev_size_zdl[ 4 ] = { 0 };
#endif
/* -----------------------------------------------
global variables: messages
----------------------------------------------- */
INTERN char errormessage [ MSG_SIZE ];
INTERN bool (*errorfunction)();
INTERN int errorlevel;
// meaning of errorlevel:
// -1 -> wrong input
// 0 -> no error
// 1 -> warning
// 2 -> fatal error
/* -----------------------------------------------
global variables: settings
----------------------------------------------- */
#if !defined( BUILD_LIB )
INTERN int verbosity = -1; // level of verbosity
INTERN bool overwrite = false; // overwrite files yes / no
INTERN bool wait_exit = true; // pause after finished yes / no
INTERN int verify_lv = 0; // verification level ( none (0), simple (1), detailed output (2) )
INTERN int err_tol = 1; // error threshold ( proceed on warnings yes (2) / no (1) )
INTERN bool disc_meta = false; // discard meta-info yes / no
INTERN bool developer = false; // allow developers functions yes/no
INTERN bool auto_set = true; // automatic find best settings yes/no
INTERN int action = A_COMPRESS;// what to do with JPEG/PJG files
INTERN FILE* msgout = stdout;// stream for output of messages
INTERN bool pipe_on = false; // use stdin/stdout instead of filelist
#else
INTERN int err_tol = 1; // error threshold ( proceed on warnings yes (2) / no (1) )
INTERN bool disc_meta = false; // discard meta-info yes / no
INTERN bool auto_set = true; // automatic find best settings yes/no
INTERN int action = A_COMPRESS;// what to do with JPEG/PJG files
#endif
INTERN unsigned char nois_trs[ 4 ] = {6,6,6,6}; // bit pattern noise threshold
INTERN unsigned char segm_cnt[ 4 ] = {10,10,10,10}; // number of segments
#if !defined( BUILD_LIB )
INTERN unsigned char orig_set[ 8 ] = { 0 }; // store array for settings
#endif
/* -----------------------------------------------
global variables: info about program
----------------------------------------------- */
INTERN const unsigned char appversion = 25;
INTERN const char* subversion = "g";
INTERN const char* apptitle = "packJPG";
INTERN const char* appname = "packjpg";
INTERN const char* versiondate = "09/14/2013";
INTERN const char* author = "Matthias Stirner / Se";
#if !defined(BUILD_LIB)
INTERN const char* website = "http://www.elektronik.htw-aalen.de/packjpg/";
INTERN const char* copyright = "2006-2013 HTW Aalen University & Matthias Stirner";
INTERN const char* email = "packjpg (at) htw-aalen.de";
INTERN const char* pjg_ext = "pjg";
INTERN const char* jpg_ext = "jpg";
#endif
INTERN const char pjg_magic[] = { 'J', 'S' };
/* -----------------------------------------------
main-function
----------------------------------------------- */
#if !defined(BUILD_LIB)
int main( int argc, char** argv )
{
sprintf( errormessage, "no errormessage specified" );
clock_t begin, end;
int error_cnt = 0;
int warn_cnt = 0;
double acc_jpgsize = 0;
double acc_pjgsize = 0;
int kbps;
double cr;
double total;
errorlevel = 0;
// read options from command line
initialize_options( argc, argv );
// write program info to screen
fprintf( msgout, "\n--> %s v%i.%i%s (%s) by %s <--\n",
apptitle, appversion / 10, appversion % 10, subversion, versiondate, author );
fprintf( msgout, "Copyright %s\nAll rights reserved\n\n", copyright );
// check if user input is wrong, show help screen if it is
if ( ( file_cnt == 0 ) ||
( ( !developer ) && ( (action != A_COMPRESS) || (!auto_set) || (verify_lv > 1) ) ) ) {
show_help();
return -1;
}
// display warning if not using automatic settings
if ( !auto_set ) {
fprintf( msgout, " custom compression settings: \n" );
fprintf( msgout, " -------------------------------------------------\n" );
fprintf( msgout, " no of segments -> %3i[0] %3i[1] %3i[2] %3i[3]\n",
segm_cnt[0], segm_cnt[1], segm_cnt[2], segm_cnt[3] );
fprintf( msgout, " noise threshold -> %3i[0] %3i[1] %3i[2] %3i[3]\n",
nois_trs[0], nois_trs[1], nois_trs[2], nois_trs[3] );
fprintf( msgout, " -------------------------------------------------\n\n" );
}
// (re)set program has to be done first
reset_buffers();
// process file(s) - this is the main function routine
begin = clock();
for ( file_no = 0; file_no < file_cnt; file_no++ ) {
// process current file
process_ui();
// store error message and type if any
if ( errorlevel > 0 ) {
err_list[ file_no ] = (char*) calloc( MSG_SIZE, sizeof( char ) );
err_tp[ file_no ] = errorlevel;
if ( err_list[ file_no ] != NULL )
strcpy( err_list[ file_no ], errormessage );
}
// count errors / warnings / file sizes
if ( errorlevel >= err_tol ) error_cnt++;
else {
if ( errorlevel == 1 ) warn_cnt++;
acc_jpgsize += jpgfilesize;
acc_pjgsize += pjgfilesize;
}
}
end = clock();
// errors summary: only needed for -v2 or progress bar
if ( ( verbosity == -1 ) || ( verbosity == 2 ) ) {
// print summary of errors to screen
if ( error_cnt > 0 ) {
fprintf( stderr, "\n\nfiles with errors:\n" );
fprintf( stderr, "------------------\n" );
for ( file_no = 0; file_no < file_cnt; file_no++ ) {
if ( err_tp[ file_no ] >= err_tol ) {
fprintf( stderr, "%s (%s)\n", filelist[ file_no ], err_list[ file_no ] );
}
}
}
// print summary of warnings to screen
if ( warn_cnt > 0 ) {
fprintf( stderr, "\n\nfiles with warnings:\n" );
fprintf( stderr, "------------------\n" );
for ( file_no = 0; file_no < file_cnt; file_no++ ) {
if ( err_tp[ file_no ] == 1 ) {
fprintf( stderr, "%s (%s)\n", filelist[ file_no ], err_list[ file_no ] );
}
}
}
}
// show statistics
fprintf( msgout, "\n\n-> %i file(s) processed, %i error(s), %i warning(s)\n",
file_cnt, error_cnt, warn_cnt );
if ( ( file_cnt > error_cnt ) && ( verbosity != 0 ) &&
( action == A_COMPRESS ) ) {
acc_jpgsize /= 1024.0; acc_pjgsize /= 1024.0;
total = (double) ( end - begin ) / CLOCKS_PER_SEC;
kbps = ( total > 0 ) ? ( acc_jpgsize / total ) : acc_jpgsize;
cr = ( acc_jpgsize > 0 ) ? ( 100.0 * acc_pjgsize / acc_jpgsize ) : 0;
fprintf( msgout, " --------------------------------- \n" );
if ( total >= 0 ) {
fprintf( msgout, " total time : %8.2f sec\n", total );
fprintf( msgout, " avrg. kbyte per s : %8i byte\n", kbps );
}
else {
fprintf( msgout, " total time : %8s sec\n", "N/A" );
fprintf( msgout, " avrg. kbyte per s : %8s byte\n", "N/A" );
}
fprintf( msgout, " avrg. comp. ratio : %8.2f %%\n", cr );
fprintf( msgout, " --------------------------------- \n" );
#if defined(DEV_INFOS)
if ( acc_jpgsize > 0 ) {
fprintf( msgout, " header %% : %8.2f %%\n", 100.0 * dev_size_hdr / acc_jpgsize );
if ( dev_size_cmp[0] > 0 ) fprintf( msgout, " component [0] %% : %8.2f %%\n", 100.0 * dev_size_cmp[0] / acc_jpgsize );
if ( dev_size_cmp[1] > 0 ) fprintf( msgout, " component [1] %% : %8.2f %%\n", 100.0 * dev_size_cmp[1] / acc_jpgsize );
if ( dev_size_cmp[2] > 0 ) fprintf( msgout, " component [2] %% : %8.2f %%\n", 100.0 * dev_size_cmp[2] / acc_jpgsize );
if ( dev_size_cmp[3] > 0 ) fprintf( msgout, " component [3] %% : %8.2f %%\n", 100.0 * dev_size_cmp[3] / acc_jpgsize );
fprintf( msgout, " --------------------------------- \n" );
for ( int i = 0; i < 4; i++ ) {
if ( dev_size_cmp[i] == 0 ) break;
fprintf( msgout, " ac coeffs h [%i] %% : %8.2f %%\n", i, 100.0 * dev_size_ach[i] / acc_jpgsize );
fprintf( msgout, " ac coeffs l [%i] %% : %8.2f %%\n", i, 100.0 * dev_size_acl[i] / acc_jpgsize );
fprintf( msgout, " dc coeffs [%i] %% : %8.2f %%\n", i, 100.0 * dev_size_dc[i] / acc_jpgsize );
fprintf( msgout, " zero dist h [%i] %% : %8.2f %%\n", i, 100.0 * dev_size_zdh[i] / acc_jpgsize );
fprintf( msgout, " zero dist l [%i] %% : %8.2f %%\n", i, 100.0 * dev_size_zdl[i] / acc_jpgsize );
fprintf( msgout, " zero sort [%i] %% : %8.2f %%\n", i, 100.0 * dev_size_zsr[i] / acc_jpgsize );
fprintf( msgout, " --------------------------------- \n" );
}
}
#endif
}
// pause before exit
if ( wait_exit && ( msgout != stderr ) ) {
fprintf( msgout, "\n\n< press ENTER >\n" );
fgetc( stdin );
}
return 0;
}
#endif
/* ----------------------- Begin of library only functions -------------------------- */
/* -----------------------------------------------
DLL export converter function
----------------------------------------------- */
#if defined(BUILD_LIB)
EXPORT bool pjglib_convert_stream2stream( char* msg )
{
// process in main function
return pjglib_convert_stream2mem( NULL, NULL, msg );
}
#endif
/* -----------------------------------------------
DLL export converter function
----------------------------------------------- */
#if defined(BUILD_LIB)
EXPORT bool pjglib_convert_file2file( char* in, char* out, char* msg )
{
// init streams
pjglib_init_streams( (void*) in, 0, 0, (void*) out, 0 );
// process in main function
return pjglib_convert_stream2mem( NULL, NULL, msg );
}
#endif
/* -----------------------------------------------
DLL export converter function
----------------------------------------------- */
#if defined(BUILD_LIB)
EXPORT bool pjglib_convert_stream2mem( unsigned char** out_file, unsigned int* out_size, char* msg )
{
clock_t begin, end;
int total;
float cr;
// use automatic settings
auto_set = true;
// (re)set buffers
reset_buffers();
action = A_COMPRESS;
// main compression / decompression routines
begin = clock();
// process one file
process_file();
// fetch pointer and size of output (only for memory output)
if ( ( errorlevel < err_tol ) && ( lib_out_type == 1 ) &&
( out_file != NULL ) && ( out_size != NULL ) ) {
*out_size = str_out->getsize();
*out_file = str_out->getptr();
}
// close iostreams
if ( str_in != NULL ) delete( str_in ); str_in = NULL;
if ( str_out != NULL ) delete( str_out ); str_out = NULL;
end = clock();
// copy errormessage / remove files if error (and output is file)
if ( errorlevel >= err_tol ) {
if ( lib_out_type == 0 ) {
if ( filetype == F_JPG ) {
if ( file_exists( pjgfilename ) ) remove( pjgfilename );
} else if ( filetype == F_PJG ) {
if ( file_exists( jpgfilename ) ) remove( jpgfilename );
}
}
if ( msg != NULL ) strcpy( msg, errormessage );
return false;
}
// get compression info
total = (int) ( (double) (( end - begin ) * 1000) / CLOCKS_PER_SEC );
cr = ( jpgfilesize > 0 ) ? ( 100.0 * pjgfilesize / jpgfilesize ) : 0;
// write success message else
if ( msg != NULL ) {
switch( filetype )
{
case F_JPG:
sprintf( msg, "Compressed to %s (%.2f%%) in %ims",
pjgfilename, cr, ( total >= 0 ) ? total : -1 );
break;
case F_PJG:
sprintf( msg, "Decompressed to %s (%.2f%%) in %ims",
jpgfilename, cr, ( total >= 0 ) ? total : -1 );
break;
case F_UNK:
sprintf( msg, "Unknown filetype" );
break;
}
}
return true;
}
#endif
/* -----------------------------------------------
DLL export init input (file/mem)
----------------------------------------------- */
#if defined(BUILD_LIB)
EXPORT void pjglib_init_streams( void* in_src, int in_type, int in_size, void* out_dest, int out_type )
{
/* a short reminder about input/output stream types:
if input is file
----------------
in_scr -> name of input file
in_type -> 0
in_size -> ignore
if input is memory
------------------
in_scr -> array containg data
in_type -> 1
in_size -> size of data array
if input is *FILE (f.e. stdin)
------------------------------
in_src -> stream pointer
in_type -> 2
in_size -> ignore
vice versa for output streams! */
unsigned char buffer[ 2 ];
// (re)set errorlevel
errorfunction = NULL;
errorlevel = 0;
jpgfilesize = 0;
pjgfilesize = 0;
// open input stream, check for errors
str_in = new iostream( in_src, in_type, in_size, 0 );
if ( str_in->chkerr() ) {
sprintf( errormessage, "error opening input stream" );
errorlevel = 2;
return;
}
// open output stream, check for errors
str_out = new iostream( out_dest, out_type, 0, 1 );
if ( str_out->chkerr() ) {
sprintf( errormessage, "error opening output stream" );
errorlevel = 2;
return;
}
// free memory from filenames if needed
if ( jpgfilename != NULL ) free( jpgfilename ); jpgfilename = NULL;
if ( pjgfilename != NULL ) free( pjgfilename ); pjgfilename = NULL;
// check input stream
str_in->read( buffer, 1, 2 );
if ( ( buffer[0] == 0xFF ) && ( buffer[1] == 0xD8 ) ) {
// file is JPEG
filetype = F_JPG;
// copy filenames
jpgfilename = (char*) calloc( ( in_type == 0 ) ? strlen( (char*) in_src ) + 1 : 32, sizeof( char ) );
pjgfilename = (char*) calloc( ( out_type == 0 ) ? strlen( (char*) out_dest ) + 1 : 32, sizeof( char ) );
strcpy( jpgfilename, ( in_type == 0 ) ? (char*) in_src : "JPG in memory" );
strcpy( pjgfilename, ( out_type == 0 ) ? (char*) out_dest : "PJG in memory" );
}
else if ( (buffer[0] == pjg_magic[0]) && (buffer[1] == pjg_magic[1]) ) {
// file is PJG
filetype = F_PJG;
// copy filenames
pjgfilename = (char*) calloc( ( in_type == 0 ) ? strlen( (char*) in_src ) + 1 : 32, sizeof( char ) );
jpgfilename = (char*) calloc( ( out_type == 0 ) ? strlen( (char*) out_dest ) + 1 : 32, sizeof( char ) );
strcpy( pjgfilename, ( in_type == 0 ) ? (char*) in_src : "PJG in memory" );
strcpy( jpgfilename, ( out_type == 0 ) ? (char*) out_dest : "JPG in memory" );
}
else {
// file is neither
filetype = F_UNK;
sprintf( errormessage, "filetype of input stream is unknown" );
errorlevel = 2;
return;
}
// store types of in-/output
lib_in_type = in_type;
lib_out_type = out_type;
}
#endif
/* -----------------------------------------------
DLL export version information
----------------------------------------------- */
#if defined(BUILD_LIB)
EXPORT const char* pjglib_version_info( void )
{
static char v_info[ 256 ];
// copy version info to string
sprintf( v_info, "--> %s library v%i.%i%s (%s) by %s <--",
apptitle, appversion / 10, appversion % 10, subversion, versiondate, author );
return (const char*) v_info;
}
#endif
/* -----------------------------------------------
DLL export version information
----------------------------------------------- */
#if defined(BUILD_LIB)
EXPORT const char* pjglib_short_name( void )
{
static char v_name[ 256 ];
// copy version info to string
sprintf( v_name, "%s v%i.%i%s",
apptitle, appversion / 10, appversion % 10, subversion );
return (const char*) v_name;
}
#endif
/* ----------------------- End of libary only functions -------------------------- */
/* ----------------------- Begin of main interface functions -------------------------- */
/* -----------------------------------------------
reads in commandline arguments
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN void initialize_options( int argc, char** argv )
{
int tmp_val;
char** tmp_flp;
int i;
// get memory for filelist & preset with NULL
filelist = (char**) calloc( argc, sizeof( char* ) );
for ( i = 0; i < argc; i++ )
filelist[ i ] = NULL;
// preset temporary filelist pointer
tmp_flp = filelist;
// read in arguments
while ( --argc > 0 ) {
argv++;
// switches begin with '-'
if ( strcmp((*argv), "-p" ) == 0 ) {
err_tol = 2;
}
else if ( strcmp((*argv), "-d" ) == 0 ) {
disc_meta = true;
}
else if ( strcmp((*argv), "-ver" ) == 0 ) {
verify_lv = ( verify_lv < 1 ) ? 1 : verify_lv;
}
else if ( sscanf( (*argv), "-v%i", &tmp_val ) == 1 ){
verbosity = tmp_val;
verbosity = ( verbosity < 0 ) ? 0 : verbosity;
verbosity = ( verbosity > 2 ) ? 2 : verbosity;
}
else if ( strcmp((*argv), "-vp" ) == 0 ) {
verbosity = -1;
}
else if ( strcmp((*argv), "-np" ) == 0 ) {
wait_exit = false;
}
else if ( strcmp((*argv), "-o" ) == 0 ) {
overwrite = true;
}
#if defined(DEV_BUILD)
else if ( strcmp((*argv), "-dev") == 0 ) {
developer = true;
}
else if ( strcmp((*argv), "-test") == 0 ) {
verify_lv = 2;
}
else if ( sscanf( (*argv), "-t%i,%i", &i, &tmp_val ) == 2 ) {
i = ( i < 0 ) ? 0 : i;
i = ( i > 3 ) ? 3 : i;
tmp_val = ( tmp_val < 0 ) ? 0 : tmp_val;
tmp_val = ( tmp_val > 10 ) ? 10 : tmp_val;
nois_trs[ i ] = tmp_val;
auto_set = false;
}
else if ( sscanf( (*argv), "-s%i,%i", &i, &tmp_val ) == 2 ) {
i = ( i < 0 ) ? 0 : i;
i = ( i > 3 ) ? 3 : i;
tmp_val = ( tmp_val < 1 ) ? 1 : tmp_val;
tmp_val = ( tmp_val > 49 ) ? 49 : tmp_val;
segm_cnt[ i ] = tmp_val;
auto_set = false;
}
else if ( sscanf( (*argv), "-t%i", &tmp_val ) == 1 ) {
tmp_val = ( tmp_val < 0 ) ? 0 : tmp_val;
tmp_val = ( tmp_val > 10 ) ? 10 : tmp_val;
nois_trs[0] = tmp_val;
nois_trs[1] = tmp_val;
nois_trs[2] = tmp_val;
nois_trs[3] = tmp_val;
auto_set = false;
}
else if ( sscanf( (*argv), "-s%i", &tmp_val ) == 1 ) {
tmp_val = ( tmp_val < 1 ) ? 1 : tmp_val;
tmp_val = ( tmp_val > 64 ) ? 64 : tmp_val;
segm_cnt[0] = tmp_val;
segm_cnt[1] = tmp_val;
segm_cnt[2] = tmp_val;
segm_cnt[3] = tmp_val;
auto_set = false;
}
else if ( sscanf( (*argv), "-coll%i", &tmp_val ) == 1 ) {
tmp_val = ( tmp_val < 0 ) ? 0 : tmp_val;
tmp_val = ( tmp_val > 5 ) ? 5 : tmp_val;
collmode = tmp_val;
action = A_COLL_DUMP;
}
else if ( sscanf( (*argv), "-fcol%i", &tmp_val ) == 1 ) {
tmp_val = ( tmp_val < 0 ) ? 0 : tmp_val;
tmp_val = ( tmp_val > 5 ) ? 5 : tmp_val;
collmode = tmp_val;
action = A_FCOLL_DUMP;
}
else if ( strcmp((*argv), "-split") == 0 ) {
action = A_SPLIT_DUMP;
}
else if ( strcmp((*argv), "-zdst") == 0 ) {
action = A_ZDST_DUMP;
}
else if ( strcmp((*argv), "-info") == 0 ) {
action = A_TXT_INFO;
}
else if ( strcmp((*argv), "-dist") == 0 ) {
action = A_DIST_INFO;
}
else if ( strcmp((*argv), "-pgm") == 0 ) {
action = A_PGM_DUMP;
}
else if ( ( strcmp((*argv), "-comp") == 0) ) {
action = A_COMPRESS;
}
#endif
else if ( strcmp((*argv), "-") == 0 ) {
// switch standard message out stream
msgout = stderr;
// use "-" as placeholder for stdin
*(tmp_flp++) = (char*) "-";
}
else {
// if argument is not switch, it's a filename
*(tmp_flp++) = *argv;
}
}
// count number of files (or filenames) in filelist
for ( file_cnt = 0; filelist[ file_cnt ] != NULL; file_cnt++ );
// alloc arrays for error messages and types storage
err_list = (char**) calloc( file_cnt, sizeof( char* ) );
err_tp = (int*) calloc( file_cnt, sizeof( int ) );
// backup settings - needed to restore original setting later
if ( !auto_set ) {
orig_set[ 0 ] = nois_trs[ 0 ];
orig_set[ 1 ] = nois_trs[ 1 ];
orig_set[ 2 ] = nois_trs[ 2 ];
orig_set[ 3 ] = nois_trs[ 3 ];
orig_set[ 4 ] = segm_cnt[ 0 ];
orig_set[ 5 ] = segm_cnt[ 1 ];
orig_set[ 6 ] = segm_cnt[ 2 ];
orig_set[ 7 ] = segm_cnt[ 3 ];
}
else {
for ( i = 0; i < 8; i++ )
orig_set[ i ] = 0;
}
}
#endif
/* -----------------------------------------------
UI for processing one file
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN void process_ui( void )
{
clock_t begin, end;
const char* actionmsg = NULL;
const char* errtypemsg = NULL;
int total, bpms;
float cr;
errorfunction = NULL;
errorlevel = 0;
jpgfilesize = 0;
pjgfilesize = 0;
#if !defined(DEV_BUILD)
action = A_COMPRESS;
#endif
// compare file name, set pipe if needed
if ( ( strcmp( filelist[ file_no ], "-" ) == 0 ) && ( action == A_COMPRESS ) ) {
pipe_on = true;
filelist[ file_no ] = (char*) "STDIN";
}
else {
pipe_on = false;
}
if ( verbosity >= 0 ) { // standard UI
fprintf( msgout, "\nProcessing file %i of %i \"%s\" -> ",
file_no + 1, file_cnt, filelist[ file_no ] );
if ( verbosity > 1 )
fprintf( msgout, "\n----------------------------------------" );
// check input file and determine filetype
execute( check_file );
// get specific action message
if ( filetype == F_UNK ) actionmsg = "unknown filetype";
else switch ( action ) {
case A_COMPRESS: actionmsg = ( filetype == F_JPG ) ? "Compressing" : "Decompressing"; break;
case A_SPLIT_DUMP: actionmsg = "Splitting"; break;
case A_COLL_DUMP: actionmsg = "Extracting Colls"; break;
case A_FCOLL_DUMP: actionmsg = "Extracting FColls"; break;
case A_ZDST_DUMP: actionmsg = "Extracting ZDST lists"; break;
case A_TXT_INFO: actionmsg = "Extracting info"; break;
case A_DIST_INFO: actionmsg = "Extracting distributions"; break;
case A_PGM_DUMP: actionmsg = "Converting"; break;
}
if ( verbosity < 2 ) fprintf( msgout, "%s -> ", actionmsg );
}
else { // progress bar UI
// update progress message
fprintf( msgout, "Processing file %2i of %2i ", file_no + 1, file_cnt );
progress_bar( file_no, file_cnt );
fprintf( msgout, "\r" );
execute( check_file );
}
fflush( msgout );
// main function routine
begin = clock();
// streams are initiated, start processing file
process_file();
// close iostreams
if ( str_in != NULL ) delete( str_in ); str_in = NULL;
if ( str_out != NULL ) delete( str_out ); str_out = NULL;
if ( str_str != NULL ) delete( str_str ); str_str = NULL;
// delete if broken or if output not needed
if ( ( !pipe_on ) && ( ( errorlevel >= err_tol ) || ( action != A_COMPRESS ) ) ) {
if ( filetype == F_JPG ) {
if ( file_exists( pjgfilename ) ) remove( pjgfilename );
} else if ( filetype == F_PJG ) {
if ( file_exists( jpgfilename ) ) remove( jpgfilename );
}
}
end = clock();
// speed and compression ratio calculation
total = (int) ( (double) (( end - begin ) * 1000) / CLOCKS_PER_SEC );
bpms = ( total > 0 ) ? ( jpgfilesize / total ) : jpgfilesize;
cr = ( jpgfilesize > 0 ) ? ( 100.0 * pjgfilesize / jpgfilesize ) : 0;
if ( verbosity >= 0 ) { // standard UI
if ( verbosity > 1 )
fprintf( msgout, "\n----------------------------------------" );
// display success/failure message
switch ( verbosity ) {
case 0:
if ( errorlevel < err_tol ) {
if ( action == A_COMPRESS ) fprintf( msgout, "%.2f%%", cr );
else fprintf( msgout, "DONE" );
}
else fprintf( msgout, "ERROR" );
if ( errorlevel > 0 ) fprintf( msgout, "\n" );
break;
case 1:
fprintf( msgout, "%s\n", ( errorlevel < err_tol ) ? "DONE" : "ERROR" );
break;
case 2:
if ( errorlevel < err_tol ) fprintf( msgout, "\n-> %s OK\n", actionmsg );
else fprintf( msgout, "\n-> %s ERROR\n", actionmsg );
break;
}
// set type of error message
switch ( errorlevel ) {
case 0: errtypemsg = "none"; break;
case 1: errtypemsg = ( err_tol > 1 ) ? "warning (ignored)" : "warning (skipped file)"; break;
case 2: errtypemsg = "fatal error"; break;
}
// error/ warning message
if ( errorlevel > 0 ) {
fprintf( msgout, " %s -> %s:\n", get_status( errorfunction ), errtypemsg );
fprintf( msgout, " %s\n", errormessage );
}
if ( (verbosity > 0) && (errorlevel < err_tol) && (action == A_COMPRESS) ) {
if ( total >= 0 ) {
fprintf( msgout, " time taken : %7i msec\n", total );
fprintf( msgout, " byte per ms : %7i byte\n", bpms );
}
else {
fprintf( msgout, " time taken : %7s msec\n", "N/A" );
fprintf( msgout, " byte per ms : %7s byte\n", "N/A" );
}
fprintf( msgout, " comp. ratio : %7.2f %%\n", cr );
}
if ( ( verbosity > 1 ) && ( action == A_COMPRESS ) )
fprintf( msgout, "\n" );
}
else { // progress bar UI
// if this is the last file, update progress bar one last time
if ( file_no + 1 == file_cnt ) {
// update progress message
fprintf( msgout, "Processed %2i of %2i files ", file_no + 1, file_cnt );
progress_bar( 1, 1 );
fprintf( msgout, "\r" );
}
}
}
#endif
/* -----------------------------------------------
gets statusmessage for function
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN inline const char* get_status( bool (*function)() )
{
if ( function == NULL ) {
return "unknown action";
} else if ( function == *check_file ) {
return "Determining filetype";
} else if ( function == *read_jpeg ) {
return "Reading header & image data";
} else if ( function == *merge_jpeg ) {
return "Merging header & image data";
} else if ( function == *decode_jpeg ) {
return "Decompressing JPEG image data";
} else if ( function == *recode_jpeg ) {
return "Recompressing JPEG image data";
} else if ( function == *adapt_icos ) {
return "Adapting DCT precalc. tables";
} else if ( function == *predict_dc ) {
return "Applying prediction to DC";
} else if ( function == *unpredict_dc ) {
return "Removing prediction from DC";
} else if ( function == *check_value_range ) {
return "Checking values range";
} else if ( function == *calc_zdst_lists ) {
return "Calculating zero dist lists";
} else if ( function == *pack_pjg ) {
return "Compressing data to PJG";
} else if ( function == *unpack_pjg ) {
return "Uncompressing data from PJG";
} else if ( function == *swap_streams ) {
return "Swapping input/output streams";
} else if ( function == *compare_output ) {
return "Verifying output stream";
} else if ( function == *reset_buffers ) {
return "Resetting program";
}
#if defined(DEV_BUILD)
else if ( function == *dump_hdr ) {
return "Writing header data to file";
} else if ( function == *dump_huf ) {
return "Writing huffman data to file";
} else if ( function == *dump_coll ) {
return "Writing collections to files";
} else if ( function == *dump_zdst ) {
return "Writing zdist lists to files";
} else if ( function == *dump_errfile ) {
return "Writing error info to file";
} else if ( function == *dump_info ) {
return "Writing info to files";
} else if ( function == *dump_dist ) {
return "Writing distributions to files";
} else if ( function == *dump_pgm ) {
return "Writing converted image to pgm";
}
#endif
else {
return "Function description missing!";
}
}
#endif
/* -----------------------------------------------
shows help in case of wrong input
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN void show_help( void )
{
fprintf( msgout, "\n" );
fprintf( msgout, "Website: %s\n", website );
fprintf( msgout, "Email : %s\n", email );
fprintf( msgout, "\n" );
fprintf( msgout, "Usage: %s [switches] [filename(s)]", appname );
fprintf( msgout, "\n" );
fprintf( msgout, "\n" );
fprintf( msgout, " [-ver] verify files after processing\n" );
fprintf( msgout, " [-v?] set level of verbosity (max: 2) (def: 0)\n" );
fprintf( msgout, " [-np] no pause after processing files\n" );
fprintf( msgout, " [-o] overwrite existing files\n" );
fprintf( msgout, " [-p] proceed on warnings\n" );
fprintf( msgout, " [-d] discard meta-info\n" );
#if defined(DEV_BUILD)
if ( developer ) {
fprintf( msgout, "\n" );
fprintf( msgout, " [-s?] set global number of segments (1<=s<=49)\n" );
fprintf( msgout, " [-t?] set global noise threshold (0<=t<=10)\n" );
fprintf( msgout, "\n" );
fprintf( msgout, " [-s?,?] set number of segments for component\n" );
fprintf( msgout, " [-t?,?] set noise threshold for component\n" );
fprintf( msgout, "\n" );
fprintf( msgout, " [-test] test algorithms, alert if error\n" );
fprintf( msgout, " [-split] split jpeg (to header & image data)\n" );
fprintf( msgout, " [-coll?] write collections (0=std,1=dhf,2=squ,3=unc)\n" );
fprintf( msgout, " [-fcol?] write predicted collections (see above)\n" );
fprintf( msgout, " [-zdst] write zero distribution lists\n" );
fprintf( msgout, " [-info] write debug info to .nfo file\n" );
fprintf( msgout, " [-dist] write distribution data to file\n" );
fprintf( msgout, " [-pgm] convert and write to pgm files\n" );
}
#endif
fprintf( msgout, "\n" );
fprintf( msgout, "Examples: \"%s -v1 -o baboon.%s\"\n", appname, pjg_ext );
fprintf( msgout, " \"%s -p *.%s\"\n", appname, jpg_ext );
}
#endif
/* -----------------------------------------------
processes one file
----------------------------------------------- */
INTERN void process_file( void )
{
if ( filetype == F_JPG ) {
switch ( action ) {
case A_COMPRESS:
execute( read_jpeg );
execute( decode_jpeg );
execute( check_value_range );
execute( adapt_icos );
execute( predict_dc );
execute( calc_zdst_lists );
execute( pack_pjg );
#if !defined(BUILD_LIB)
if ( verify_lv > 0 ) { // verifcation
execute( reset_buffers );
execute( swap_streams );
execute( unpack_pjg );
execute( adapt_icos );
execute( unpredict_dc );
execute( recode_jpeg );
execute( merge_jpeg );
execute( compare_output );
}
#endif
break;
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
case A_SPLIT_DUMP:
execute( read_jpeg );
execute( dump_hdr );
execute( dump_huf );
break;
case A_COLL_DUMP:
execute( read_jpeg );
execute( decode_jpeg );
execute( dump_coll );
break;
case A_FCOLL_DUMP:
execute( read_jpeg );
execute( decode_jpeg );
execute( check_value_range );
execute( adapt_icos );
execute( predict_dc );
execute( dump_coll );
break;
case A_ZDST_DUMP:
execute( read_jpeg );
execute( decode_jpeg );
execute( check_value_range );
execute( adapt_icos );
execute( predict_dc );
execute( calc_zdst_lists );
execute( dump_zdst );
break;
case A_TXT_INFO:
execute( read_jpeg );
execute( dump_info );
break;
case A_DIST_INFO:
execute( read_jpeg );
execute( decode_jpeg );
execute( check_value_range );
execute( adapt_icos );
execute( predict_dc );
execute( dump_dist );
break;
case A_PGM_DUMP:
execute( read_jpeg );
execute( decode_jpeg );
execute( adapt_icos );
execute( dump_pgm );
break;
#else
default:
break;
#endif
}
}
else if ( filetype == F_PJG ) {
switch ( action )
{
case A_COMPRESS:
execute( unpack_pjg );
execute( adapt_icos );
execute( unpredict_dc );
execute( recode_jpeg );
execute( merge_jpeg );
#if !defined(BUILD_LIB)
if ( verify_lv > 0 ) { // verify
execute( reset_buffers );
execute( swap_streams );
execute( read_jpeg );
execute( decode_jpeg );
execute( check_value_range );
execute( adapt_icos );
execute( predict_dc );
execute( calc_zdst_lists );
execute( pack_pjg );
execute( compare_output );
}
#endif
break;
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
case A_SPLIT_DUMP:
execute( unpack_pjg );
execute( adapt_icos );
execute( unpredict_dc );
execute( recode_jpeg );
execute( dump_hdr );
execute( dump_huf );
break;
case A_COLL_DUMP:
execute( unpack_pjg );
execute( adapt_icos );
execute( unpredict_dc );
execute( dump_coll );
break;
case A_FCOLL_DUMP:
execute( unpack_pjg );
execute( dump_coll );
break;
case A_ZDST_DUMP:
execute( unpack_pjg );
execute( dump_zdst );
break;
case A_TXT_INFO:
execute( unpack_pjg );
execute( dump_info );
break;
case A_DIST_INFO:
execute( unpack_pjg );
execute( dump_dist );
break;
case A_PGM_DUMP:
execute( unpack_pjg );
execute( adapt_icos );
execute( unpredict_dc );
execute( dump_pgm );
break;
#else
default:
break;
#endif
}
}
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
// write error file if verify lv > 1
if ( ( verify_lv > 1 ) && ( errorlevel >= err_tol ) )
dump_errfile();
#endif
// reset buffers
reset_buffers();
}
/* -----------------------------------------------
main-function execution routine
----------------------------------------------- */
INTERN void execute( bool (*function)() )
{
if ( errorlevel < err_tol ) {
#if !defined BUILD_LIB
clock_t begin, end;
bool success;
int total;
// write statusmessage
if ( verbosity == 2 ) {
fprintf( msgout, "\n%s ", get_status( function ) );
for ( int i = strlen( get_status( function ) ); i <= 30; i++ )
fprintf( msgout, " " );
}
// set starttime
begin = clock();
// call function
success = ( *function )();
// set endtime
end = clock();
if ( ( errorlevel > 0 ) && ( errorfunction == NULL ) )
errorfunction = function;
// write time or failure notice
if ( success ) {
total = (int) ( (double) (( end - begin ) * 1000) / CLOCKS_PER_SEC );
if ( verbosity == 2 ) fprintf( msgout, "%6ims", ( total >= 0 ) ? total : -1 );
}
else {
errorfunction = function;
if ( verbosity == 2 ) fprintf( msgout, "%8s", "ERROR" );
}
#else
// call function
( *function )();
// store errorfunction if needed
if ( ( errorlevel > 0 ) && ( errorfunction == NULL ) )
errorfunction = function;
#endif
}
}
/* ----------------------- End of main interface functions -------------------------- */
/* ----------------------- Begin of main functions -------------------------- */
/* -----------------------------------------------
check file and determine filetype
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN bool check_file( void )
{
unsigned char fileid[ 2 ] = { 0, 0 };
const char* filename = filelist[ file_no ];
// open input stream, check for errors
str_in = new iostream( (void*) filename, ( !pipe_on ) ? 0 : 2, 0, 0 );
if ( str_in->chkerr() ) {
sprintf( errormessage, FRD_ERRMSG, filename );
errorlevel = 2;
return false;
}
// free memory from filenames if needed
if ( jpgfilename != NULL ) free( jpgfilename ); jpgfilename = NULL;
if ( pjgfilename != NULL ) free( pjgfilename ); pjgfilename = NULL;
// immediately return error if 2 bytes can't be read
if ( str_in->read( fileid, 1, 2 ) != 2 ) {
filetype = F_UNK;
sprintf( errormessage, "file doesn't contain enough data" );
errorlevel = 2;
return false;
}
// check file id, determine filetype
if ( ( fileid[0] == 0xFF ) && ( fileid[1] == 0xD8 ) ) {
// file is JPEG
filetype = F_JPG;
// create filenames
if ( !pipe_on ) {
jpgfilename = (char*) calloc( strlen( filename ) + 1, sizeof( char ) );
strcpy( jpgfilename, filename );
pjgfilename = ( overwrite ) ?
create_filename( filename, (char*) pjg_ext ) :
unique_filename( filename, (char*) pjg_ext );
}
else {
jpgfilename = create_filename( "STDIN", NULL );
pjgfilename = create_filename( "STDOUT", NULL );
}
// open output stream, check for errors
str_out = new iostream( (void*) pjgfilename, ( !pipe_on ) ? 0 : 2, 0, 1 );
if ( str_out->chkerr() ) {
sprintf( errormessage, FWR_ERRMSG, pjgfilename );
errorlevel = 2;
return false;
}
// JPEG specific settings - restore original settings
if ( orig_set[ 0 ] == 0 )
auto_set = true;
else {
nois_trs[ 0 ] = orig_set[ 0 ];
nois_trs[ 1 ] = orig_set[ 1 ];
nois_trs[ 2 ] = orig_set[ 2 ];
nois_trs[ 3 ] = orig_set[ 3 ];
segm_cnt[ 0 ] = orig_set[ 4 ];
segm_cnt[ 1 ] = orig_set[ 5 ];
segm_cnt[ 2 ] = orig_set[ 6 ];
segm_cnt[ 3 ] = orig_set[ 7 ];
auto_set = false;
}
}
else if ( ( fileid[0] == pjg_magic[0] ) && ( fileid[1] == pjg_magic[1] ) ) {
// file is PJG
filetype = F_PJG;
// create filenames
if ( !pipe_on ) {
pjgfilename = (char*) calloc( strlen( filename ) + 1, sizeof( char ) );
strcpy( pjgfilename, filename );
jpgfilename = ( overwrite ) ?
create_filename( filename, (char*) jpg_ext ) :
unique_filename( filename, (char*) jpg_ext );
}
else {
jpgfilename = create_filename( "STDOUT", NULL );
pjgfilename = create_filename( "STDIN", NULL );
}
// open output stream, check for errors
str_out = new iostream( (void*) jpgfilename, ( !pipe_on ) ? 0 : 2, 0, 1 );
if ( str_out->chkerr() ) {
sprintf( errormessage, FWR_ERRMSG, jpgfilename );
errorlevel = 2;
return false;
}
// PJG specific settings - auto unless specified otherwise
auto_set = true;
}
else {
// file is neither
filetype = F_UNK;
sprintf( errormessage, "filetype of file \"%s\" is unknown", filename );
errorlevel = 2;
return false;
}
return true;
}
#endif
/* -----------------------------------------------
swap streams / init verification
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN bool swap_streams( void )
{
char dmp[ 2 ];
// store input stream
str_str = str_in;
str_str->rewind();
// replace input stream by output stream / switch mode for reading / read first bytes
str_in = str_out;
str_in->switch_mode();
str_in->read( dmp, 1, 2 );
// open new stream for output / check for errors
str_out = new iostream( NULL, 1, 0, 1 );
if ( str_out->chkerr() ) {
sprintf( errormessage, "error opening comparison stream" );
errorlevel = 2;
return false;
}
return true;
}
#endif
/* -----------------------------------------------
comparison between input & output
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN bool compare_output( void )
{
unsigned char* buff_ori;
unsigned char* buff_cmp;
int bsize = 1024;
int dsize;
int i, b;
// init buffer arrays
buff_ori = ( unsigned char* ) calloc( bsize, sizeof( char ) );
buff_cmp = ( unsigned char* ) calloc( bsize, sizeof( char ) );
if ( ( buff_ori == NULL ) || ( buff_cmp == NULL ) ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// switch output stream mode / check for stream errors
str_out->switch_mode();
while ( true ) {
if ( str_out->chkerr() )
sprintf( errormessage, "error in comparison stream" );
else if ( str_in->chkerr() )
sprintf( errormessage, "error in output stream" );
else if ( str_str->chkerr() )
sprintf( errormessage, "error in input stream" );
else break;
errorlevel = 2;
return false;
}
// compare sizes
dsize = str_str->getsize();
if ( str_out->getsize() != dsize ) {
sprintf( errormessage, "file sizes do not match" );
errorlevel = 2;
return false;
}
// compare files byte by byte
for ( i = 0; i < dsize; i++ ) {
b = i % bsize;
if ( b == 0 ) {
str_str->read( buff_ori, sizeof( char ), bsize );
str_out->read( buff_cmp, sizeof( char ), bsize );
}
if ( buff_ori[ b ] != buff_cmp[ b ] ) {
sprintf( errormessage, "difference found at 0x%X", i );
errorlevel = 2;
return false;
}
}
// free buffers
free( buff_ori );
free( buff_cmp );
return true;
}
#endif
/* -----------------------------------------------
set each variable to its initial value
----------------------------------------------- */
INTERN bool reset_buffers( void )
{
int cmp, bpos;
int i;
// -- free buffers --
// free buffers & set pointers NULL
if ( hdrdata != NULL ) free ( hdrdata );
if ( huffdata != NULL ) free ( huffdata );
if ( grbgdata != NULL ) free ( grbgdata );
if ( rst_err != NULL ) free ( rst_err );
if ( rstp != NULL ) free ( rstp );
if ( scnp != NULL ) free ( scnp );
hdrdata = NULL;
huffdata = NULL;
grbgdata = NULL;
rst_err = NULL;
rstp = NULL;
scnp = NULL;
// free image arrays
for ( cmp = 0; cmp < 4; cmp++ ) {
if ( zdstdata[ cmp ] != NULL ) free( zdstdata[cmp] );
if ( eobxhigh[ cmp ] != NULL ) free( eobxhigh[cmp] );
if ( eobyhigh[ cmp ] != NULL ) free( eobyhigh[cmp] );
if ( zdstxlow[ cmp ] != NULL ) free( zdstxlow[cmp] );
if ( zdstylow[ cmp ] != NULL ) free( zdstylow[cmp] );
zdstdata[ cmp ] = NULL;
eobxhigh[ cmp ] = NULL;
eobyhigh[ cmp ] = NULL;
zdstxlow[ cmp ] = NULL;
zdstylow[ cmp ] = NULL;
freqscan[ cmp ] = (unsigned char*) stdscan;
for ( bpos = 0; bpos < 64; bpos++ ) {
if ( colldata[ cmp ][ bpos ] != NULL ) free( colldata[cmp][bpos] );
colldata[ cmp ][ bpos ] = NULL;
}
}
// -- set variables --
// preset componentinfo
for ( cmp = 0; cmp < 4; cmp++ ) {
cmpnfo[ cmp ].sfv = -1;
cmpnfo[ cmp ].sfh = -1;
cmpnfo[ cmp ].mbs = -1;
cmpnfo[ cmp ].bcv = -1;
cmpnfo[ cmp ].bch = -1;
cmpnfo[ cmp ].bc = -1;
cmpnfo[ cmp ].ncv = -1;
cmpnfo[ cmp ].nch = -1;
cmpnfo[ cmp ].nc = -1;
cmpnfo[ cmp ].sid = -1;
cmpnfo[ cmp ].jid = -1;
cmpnfo[ cmp ].qtable = NULL;
cmpnfo[ cmp ].huffdc = -1;
cmpnfo[ cmp ].huffac = -1;
}
// preset imgwidth / imgheight / component count
imgwidth = 0;
imgheight = 0;
cmpc = 0;
// preset mcu info variables / restart interval
sfhm = 0;
sfvm = 0;
mcuc = 0;
mcuh = 0;
mcuv = 0;
rsti = 0;
// reset quantization / huffman tables
for ( i = 0; i < 4; i++ ) {
htset[ 0 ][ i ] = 0;
htset[ 1 ][ i ] = 0;
for ( bpos = 0; bpos < 64; bpos++ )
qtables[ i ][ bpos ] = 0;
}
// preset jpegtype
jpegtype = 0;
// reset padbit
padbit = -1;
return true;
}
/* -----------------------------------------------
Read in header & image data
----------------------------------------------- */
INTERN bool read_jpeg( void )
{
unsigned char* segment = NULL; // storage for current segment
unsigned int ssize = 1024; // current size of segment array
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int crst = 0; // current rst marker counter
unsigned int cpos = 0; // rst marker counter
unsigned char tmp;
abytewriter* huffw;
abytewriter* hdrw;
abytewriter* grbgw;
// preset count of scans
scnc = 0;
// start headerwriter
hdrw = new abytewriter( 4096 );
hdrs = 0; // size of header data, start with 0
// start huffman writer
huffw = new abytewriter( 0 );
hufs = 0; // size of image data, start with 0
// alloc memory for segment data first
segment = ( unsigned char* ) calloc( ssize, sizeof( char ) );
if ( segment == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// JPEG reader loop
while ( true ) {
if ( type == 0xDA ) { // if last marker was sos
// switch to huffman data reading mode
cpos = 0;
crst = 0;
while ( true ) {
// read byte from imagedata
if ( str_in->read( &tmp, 1, 1 ) == 0 )
break;
// non-0xFF loop
if ( tmp != 0xFF ) {
crst = 0;
while ( tmp != 0xFF ) {
huffw->write( tmp );
if ( str_in->read( &tmp, 1, 1 ) == 0 )
break;
}
}
// treatment of 0xFF
if ( tmp == 0xFF ) {
if ( str_in->read( &tmp, 1, 1 ) == 0 )
break; // read next byte & check
if ( tmp == 0x00 ) {
crst = 0;
// no zeroes needed -> ignore 0x00. write 0xFF
huffw->write( 0xFF );
}
else if ( tmp == 0xD0 + ( cpos % 8 ) ) { // restart marker
// increment rst counters
cpos++;
crst++;
}
else { // in all other cases leave it to the header parser routines
// store number of wrongly set rst markers
if ( crst > 0 ) {
if ( rst_err == NULL ) {
rst_err = (unsigned char*) calloc( scnc + 1, sizeof( char ) );
if ( rst_err == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
}
}
if ( rst_err != NULL ) {
// realloc and set only if needed
rst_err = ( unsigned char* ) realloc( rst_err, ( scnc + 1 ) * sizeof( char ) );
if ( rst_err == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
if ( crst > 255 ) {
sprintf( errormessage, "Severe false use of RST markers (%i)", crst );
errorlevel = 1;
crst = 255;
}
rst_err[ scnc ] = crst;
}
// end of current scan
scnc++;
// on with the header parser routines
segment[ 0 ] = 0xFF;
segment[ 1 ] = tmp;
break;
}
}
else {
// otherwise this means end-of-file, so break out
break;
}
}
}
else {
// read in next marker
if ( str_in->read( segment, 1, 2 ) != 2 ) break;
if ( segment[ 0 ] != 0xFF ) {
// ugly fix for incorrect marker segment sizes
sprintf( errormessage, "size mismatch in marker segment FF %2X", type );
errorlevel = 2;
if ( type == 0xFE ) { // if last marker was COM try again
if ( str_in->read( segment, 1, 2 ) != 2 ) break;
if ( segment[ 0 ] == 0xFF ) errorlevel = 1;
}
if ( errorlevel == 2 ) {
delete ( hdrw );
delete ( huffw );
free ( segment );
return false;
}
}
}
// read segment type
type = segment[ 1 ];
// if EOI is encountered make a quick exit
if ( type == 0xD9 ) {
// get pointer for header data & size
hdrdata = hdrw->getptr();
hdrs = hdrw->getpos();
// get pointer for huffman data & size
huffdata = huffw->getptr();
hufs = huffw->getpos();
// everything is done here now
break;
}
// read in next segments' length and check it
if ( str_in->read( segment + 2, 1, 2 ) != 2 ) break;
len = 2 + B_SHORT( segment[ 2 ], segment[ 3 ] );
if ( len < 4 ) break;
// realloc segment data if needed
if ( ssize < len ) {
segment = ( unsigned char* ) realloc( segment, len );
if ( segment == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
delete ( hdrw );
delete ( huffw );
return false;
}
ssize = len;
}
// read rest of segment, store back in header writer
if ( str_in->read( ( segment + 4 ), 1, ( len - 4 ) ) !=
( unsigned short ) ( len - 4 ) ) break;
hdrw->write_n( segment, len );
}
// JPEG reader loop end
// free writers
delete ( hdrw );
delete ( huffw );
// check if everything went OK
if ( ( hdrs == 0 ) || ( hufs == 0 ) ) {
sprintf( errormessage, "unexpected end of data encountered" );
errorlevel = 2;
return false;
}
// store garbage after EOI if needed
grbs = str_in->read( &tmp, 1, 1 );
if ( grbs > 0 ) {
grbgw = new abytewriter( 1024 );
grbgw->write( tmp );
while( true ) {
len = str_in->read( segment, 1, ssize );
if ( len == 0 ) break;
grbgw->write_n( segment, len );
}
grbgdata = grbgw->getptr();
grbs = grbgw->getpos();
delete ( grbgw );
}
// free segment
free( segment );
// get filesize
jpgfilesize = str_in->getsize();
// parse header for image info
if ( !jpg_setup_imginfo() ) {
return false;
}
return true;
}
/* -----------------------------------------------
Merges header & image data to jpeg
----------------------------------------------- */
INTERN bool merge_jpeg( void )
{
unsigned char SOI[ 2 ] = { 0xFF, 0xD8 }; // SOI segment
unsigned char EOI[ 2 ] = { 0xFF, 0xD9 }; // EOI segment
unsigned char mrk = 0xFF; // marker start
unsigned char stv = 0x00; // 0xFF stuff value
unsigned char rst = 0xD0; // restart marker
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // current position in header
unsigned int ipos = 0; // current position in imagedata
unsigned int rpos = 0; // current restart marker position
unsigned int cpos = 0; // in scan corrected rst marker position
unsigned int scan = 1; // number of current scan
unsigned int tmp; // temporary storage variable
// write SOI
str_out->write( SOI, 1, 2 );
// JPEG writing loop
while ( true )
{
// store current header position
tmp = hpos;
// seek till start-of-scan
for ( type = 0x00; type != 0xDA; ) {
if ( ( int ) hpos >= hdrs ) break;
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
hpos += len;
}
// write header data to file
str_out->write( hdrdata + tmp, 1, ( hpos - tmp ) );
// get out if last marker segment type was not SOS
if ( type != 0xDA ) break;
// (re)set corrected rst pos
cpos = 0;
// write & expand huffman coded image data
for ( ipos = scnp[ scan - 1 ]; ipos < scnp[ scan ]; ipos++ ) {
// write current byte
str_out->write( huffdata + ipos, 1, 1 );
// check current byte, stuff if needed
if ( huffdata[ ipos ] == 0xFF )
str_out->write( &stv, 1, 1 );
// insert restart markers if needed
if ( rstp != NULL ) {
if ( ipos == rstp[ rpos ] ) {
rst = 0xD0 + ( cpos % 8 );
str_out->write( &mrk, 1, 1 );
str_out->write( &rst, 1, 1 );
rpos++; cpos++;
}
}
}
// insert false rst markers at end if needed
if ( rst_err != NULL ) {
while ( rst_err[ scan - 1 ] > 0 ) {
rst = 0xD0 + ( cpos % 8 );
str_out->write( &mrk, 1, 1 );
str_out->write( &rst, 1, 1 );
cpos++; rst_err[ scan - 1 ]--;
}
}
// proceed with next scan
scan++;
}
// write EOI
str_out->write( EOI, 1, 2 );
// write garbage if needed
if ( grbs > 0 )
str_out->write( grbgdata, 1, grbs );
// errormessage if write error
if ( str_out->chkerr() ) {
sprintf( errormessage, "write error, possibly drive is full" );
errorlevel = 2;
return false;
}
// get filesize
jpgfilesize = str_out->getsize();
return true;
}
/* -----------------------------------------------
JPEG decoding routine
----------------------------------------------- */
INTERN bool decode_jpeg( void )
{
abitreader* huffr; // bitwise reader for image data
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // current position in header
int lastdc[ 4 ]; // last dc for each component
short block[ 64 ]; // store block for coeffs
int peobrun; // previous eobrun
int eobrun; // run of eobs
int rstw; // restart wait counter
int cmp, bpos, dpos;
int mcu, sub, csc;
int eob, sta;
// open huffman coded image data for input in abitreader
huffr = new abitreader( huffdata, hufs );
// preset count of scans
scnc = 0;
// JPEG decompression loop
while ( true )
{
// seek till start-of-scan, parse only DHT, DRI and SOS
for ( type = 0x00; type != 0xDA; ) {
if ( ( int ) hpos >= hdrs ) break;
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
if ( ( type == 0xC4 ) || ( type == 0xDA ) || ( type == 0xDD ) ) {
if ( !jpg_parse_jfif( type, len, &( hdrdata[ hpos ] ) ) ) {
return false;
}
}
hpos += len;
}
// get out if last marker segment type was not SOS
if ( type != 0xDA ) break;
// check if huffman tables are available
for ( csc = 0; csc < cs_cmpc; csc++ ) {
cmp = cs_cmp[ csc ];
if ( ( ( cs_sal == 0 ) && ( htset[ 0 ][ cmpnfo[cmp].huffdc ] == 0 ) ) ||
( ( cs_sah > 0 ) && ( htset[ 1 ][ cmpnfo[cmp].huffac ] == 0 ) ) ) {
sprintf( errormessage, "huffman table missing in scan%i", scnc );
delete huffr;
errorlevel = 2;
return false;
}
}
// intial variables set for decoding
cmp = cs_cmp[ 0 ];
csc = 0;
mcu = 0;
sub = 0;
dpos = 0;
// JPEG imagedata decoding routines
while ( true )
{
// (re)set last DCs for diff coding
lastdc[ 0 ] = 0;
lastdc[ 1 ] = 0;
lastdc[ 2 ] = 0;
lastdc[ 3 ] = 0;
// (re)set status
eob = 0;
sta = 0;
// (re)set eobrun
eobrun = 0;
peobrun = 0;
// (re)set rst wait counter
rstw = rsti;
// decoding for interleaved data
if ( cs_cmpc > 1 )
{
if ( jpegtype == 1 ) {
// ---> sequential interleaved decoding <---
while ( sta == 0 ) {
// decode block
eob = jpg_decode_block_seq( huffr,
&(htrees[ 0 ][ cmpnfo[cmp].huffdc ]),
&(htrees[ 1 ][ cmpnfo[cmp].huffdc ]),
block );
// fix dc
block[ 0 ] += lastdc[ cmp ];
lastdc[ cmp ] = block[ 0 ];
// copy to colldata
for ( bpos = 0; bpos < eob; bpos++ )
colldata[ cmp ][ bpos ][ dpos ] = block[ bpos ];
// check for errors, proceed if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcupos( &mcu, &cmp, &csc, &sub, &dpos, &rstw );
}
}
else if ( cs_sah == 0 ) {
// ---> progressive interleaved DC decoding <---
// ---> succesive approximation first stage <---
while ( sta == 0 ) {
sta = jpg_decode_dc_prg_fs( huffr,
&(htrees[ 0 ][ cmpnfo[cmp].huffdc ]),
block );
// fix dc for diff coding
colldata[cmp][0][dpos] = block[0] + lastdc[ cmp ];
lastdc[ cmp ] = colldata[cmp][0][dpos];
// bitshift for succesive approximation
colldata[cmp][0][dpos] <<= cs_sal;
// next mcupos if no error happened
if ( sta != -1 )
sta = jpg_next_mcupos( &mcu, &cmp, &csc, &sub, &dpos, &rstw );
}
}
else {
// ---> progressive interleaved DC decoding <---
// ---> succesive approximation later stage <---
while ( sta == 0 ) {
// decode next bit
sta = jpg_decode_dc_prg_sa( huffr,
block );
// shift in next bit
colldata[cmp][0][dpos] += block[0] << cs_sal;
// next mcupos if no error happened
if ( sta != -1 )
sta = jpg_next_mcupos( &mcu, &cmp, &csc, &sub, &dpos, &rstw );
}
}
}
else // decoding for non interleaved data
{
if ( jpegtype == 1 ) {
// ---> sequential non interleaved decoding <---
while ( sta == 0 ) {
// decode block
eob = jpg_decode_block_seq( huffr,
&(htrees[ 0 ][ cmpnfo[cmp].huffdc ]),
&(htrees[ 1 ][ cmpnfo[cmp].huffdc ]),
block );
// fix dc
block[ 0 ] += lastdc[ cmp ];
lastdc[ cmp ] = block[ 0 ];
// copy to colldata
for ( bpos = 0; bpos < eob; bpos++ )
colldata[ cmp ][ bpos ][ dpos ] = block[ bpos ];
// check for errors, proceed if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
else if ( cs_to == 0 ) {
if ( cs_sah == 0 ) {
// ---> progressive non interleaved DC decoding <---
// ---> succesive approximation first stage <---
while ( sta == 0 ) {
sta = jpg_decode_dc_prg_fs( huffr,
&(htrees[ 0 ][ cmpnfo[cmp].huffdc ]),
block );
// fix dc for diff coding
colldata[cmp][0][dpos] = block[0] + lastdc[ cmp ];
lastdc[ cmp ] = colldata[cmp][0][dpos];
// bitshift for succesive approximation
colldata[cmp][0][dpos] <<= cs_sal;
// check for errors, increment dpos otherwise
if ( sta != -1 )
sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
else {
// ---> progressive non interleaved DC decoding <---
// ---> succesive approximation later stage <---
while( sta == 0 ) {
// decode next bit
sta = jpg_decode_dc_prg_sa( huffr,
block );
// shift in next bit
colldata[cmp][0][dpos] += block[0] << cs_sal;
// check for errors, increment dpos otherwise
if ( sta != -1 )
sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
}
else {
if ( cs_sah == 0 ) {
// ---> progressive non interleaved AC decoding <---
// ---> succesive approximation first stage <---
while ( sta == 0 ) {
if ( eobrun == 0 ) {
// decode block
eob = jpg_decode_ac_prg_fs( huffr,
&(htrees[ 1 ][ cmpnfo[cmp].huffac ]),
block, &eobrun, cs_from, cs_to );
if ( eobrun > 0 ) {
// check for non optimal coding
if ( ( eob == cs_from ) && ( peobrun > 0 ) &&
( peobrun < hcodes[ 1 ][ cmpnfo[cmp].huffac ].max_eobrun - 1 ) ) {
sprintf( errormessage,
"reconstruction of non optimal coding not supported" );
errorlevel = 1;
}
peobrun = eobrun;
eobrun--;
} else peobrun = 0;
// copy to colldata
for ( bpos = cs_from; bpos < eob; bpos++ )
colldata[ cmp ][ bpos ][ dpos ] = block[ bpos ] << cs_sal;
} else eobrun--;
// check for errors
if ( eob < 0 ) sta = -1;
else sta = jpg_skip_eobrun( &cmp, &dpos, &rstw, &eobrun );
// proceed only if no error encountered
if ( sta == 0 )
sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
else {
// ---> progressive non interleaved AC decoding <---
// ---> succesive approximation later stage <---
while ( sta == 0 ) {
// copy from colldata
for ( bpos = cs_from; bpos <= cs_to; bpos++ )
block[ bpos ] = colldata[ cmp ][ bpos ][ dpos ];
if ( eobrun == 0 ) {
// decode block (long routine)
eob = jpg_decode_ac_prg_sa( huffr,
&(htrees[ 1 ][ cmpnfo[cmp].huffac ]),
block, &eobrun, cs_from, cs_to );
if ( eobrun > 0 ) {
// check for non optimal coding
if ( ( eob == cs_from ) && ( peobrun > 0 ) &&
( peobrun < hcodes[ 1 ][ cmpnfo[cmp].huffac ].max_eobrun - 1 ) ) {
sprintf( errormessage,
"reconstruction of non optimal coding not supported" );
errorlevel = 1;
}
// store eobrun
peobrun = eobrun;
eobrun--;
} else peobrun = 0;
}
else {
// decode block (short routine)
eob = jpg_decode_eobrun_sa( huffr,
block, &eobrun, cs_from, cs_to );
eobrun--;
}
// copy back to colldata
for ( bpos = cs_from; bpos <= cs_to; bpos++ )
colldata[ cmp ][ bpos ][ dpos ] += block[ bpos ] << cs_sal;
// proceed only if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
}
}
// unpad huffman reader / check padbit
if ( padbit != -1 ) {
if ( padbit != huffr->unpad( padbit ) ) {
sprintf( errormessage, "inconsistent use of padbits" );
padbit = 1;
errorlevel = 1;
}
}
else {
padbit = huffr->unpad( padbit );
}
// evaluate status
if ( sta == -1 ) { // status -1 means error
sprintf( errormessage, "decode error in scan%i / mcu%i",
scnc, ( cs_cmpc > 1 ) ? mcu : dpos );
delete huffr;
errorlevel = 2;
return false;
}
else if ( sta == 2 ) { // status 2/3 means done
scnc++; // increment scan counter
break; // leave decoding loop, everything is done here
}
// else if ( sta == 1 ); // status 1 means restart - so stay in the loop
}
}
// check for missing data
if ( huffr->peof ) {
sprintf( errormessage, "coded image data truncated / too short" );
errorlevel = 1;
}
// check for surplus data
if ( !huffr->eof ) {
sprintf( errormessage, "surplus data found after coded image data" );
errorlevel = 1;
}
// clean up
delete( huffr );
return true;
}
/* -----------------------------------------------
JPEG encoding routine
----------------------------------------------- */
INTERN bool recode_jpeg( void )
{
abitwriter* huffw; // bitwise writer for image data
abytewriter* storw; // bytewise writer for storage of correction bits
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // current position in header
int lastdc[ 4 ]; // last dc for each component0
short block[ 64 ]; // store block for coeffs
int eobrun; // run of eobs
int rstw; // restart wait counter
int cmp, bpos, dpos;
int mcu, sub, csc;
int eob, sta;
int tmp;
// open huffman coded image data in abitwriter
huffw = new abitwriter( 0 );
huffw->fillbit = padbit;
// init storage writer
storw = new abytewriter( 0 );
// preset count of scans and restarts
scnc = 0;
rstc = 0;
// JPEG decompression loop
while ( true )
{
// seek till start-of-scan, parse only DHT, DRI and SOS
for ( type = 0x00; type != 0xDA; ) {
if ( ( int ) hpos >= hdrs ) break;
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
if ( ( type == 0xC4 ) || ( type == 0xDA ) || ( type == 0xDD ) ) {
if ( !jpg_parse_jfif( type, len, &( hdrdata[ hpos ] ) ) ) {
return false;
}
hpos += len;
}
else {
hpos += len;
continue;
}
}
// get out if last marker segment type was not SOS
if ( type != 0xDA ) break;
// (re)alloc scan positons array
if ( scnp == NULL ) scnp = ( unsigned int* ) calloc( scnc + 2, sizeof( int ) );
else scnp = ( unsigned int* ) realloc( scnp, ( scnc + 2 ) * sizeof( int ) );
if ( scnp == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// (re)alloc restart marker positons array if needed
if ( rsti > 0 ) {
tmp = rstc + ( ( cs_cmpc > 1 ) ?
( mcuc / rsti ) : ( cmpnfo[ cs_cmp[ 0 ] ].bc / rsti ) );
if ( rstp == NULL ) rstp = ( unsigned int* ) calloc( tmp + 1, sizeof( int ) );
else rstp = ( unsigned int* ) realloc( rstp, ( tmp + 1 ) * sizeof( int ) );
if ( rstp == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
}
// intial variables set for encoding
cmp = cs_cmp[ 0 ];
csc = 0;
mcu = 0;
sub = 0;
dpos = 0;
// store scan position
scnp[ scnc ] = huffw->getpos();
// JPEG imagedata encoding routines
while ( true )
{
// (re)set last DCs for diff coding
lastdc[ 0 ] = 0;
lastdc[ 1 ] = 0;
lastdc[ 2 ] = 0;
lastdc[ 3 ] = 0;
// (re)set status
sta = 0;
// (re)set eobrun
eobrun = 0;
// (re)set rst wait counter
rstw = rsti;
// encoding for interleaved data
if ( cs_cmpc > 1 )
{
if ( jpegtype == 1 ) {
// ---> sequential interleaved encoding <---
while ( sta == 0 ) {
// copy from colldata
for ( bpos = 0; bpos < 64; bpos++ )
block[ bpos ] = colldata[ cmp ][ bpos ][ dpos ];
// diff coding for dc
block[ 0 ] -= lastdc[ cmp ];
lastdc[ cmp ] = colldata[ cmp ][ 0 ][ dpos ];
// encode block
eob = jpg_encode_block_seq( huffw,
&(hcodes[ 0 ][ cmpnfo[cmp].huffac ]),
&(hcodes[ 1 ][ cmpnfo[cmp].huffac ]),
block );
// check for errors, proceed if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcupos( &mcu, &cmp, &csc, &sub, &dpos, &rstw );
}
}
else if ( cs_sah == 0 ) {
// ---> progressive interleaved DC encoding <---
// ---> succesive approximation first stage <---
while ( sta == 0 ) {
// diff coding & bitshifting for dc
tmp = colldata[ cmp ][ 0 ][ dpos ] >> cs_sal;
block[ 0 ] = tmp - lastdc[ cmp ];
lastdc[ cmp ] = tmp;
// encode dc
sta = jpg_encode_dc_prg_fs( huffw,
&(hcodes[ 0 ][ cmpnfo[cmp].huffdc ]),
block );
// next mcupos if no error happened
if ( sta != -1 )
sta = jpg_next_mcupos( &mcu, &cmp, &csc, &sub, &dpos, &rstw );
}
}
else {
// ---> progressive interleaved DC encoding <---
// ---> succesive approximation later stage <---
while ( sta == 0 ) {
// fetch bit from current bitplane
block[ 0 ] = BITN( colldata[ cmp ][ 0 ][ dpos ], cs_sal );
// encode dc correction bit
sta = jpg_encode_dc_prg_sa( huffw, block );
// next mcupos if no error happened
if ( sta != -1 )
sta = jpg_next_mcupos( &mcu, &cmp, &csc, &sub, &dpos, &rstw );
}
}
}
else // encoding for non interleaved data
{
if ( jpegtype == 1 ) {
// ---> sequential non interleaved encoding <---
while ( sta == 0 ) {
// copy from colldata
for ( bpos = 0; bpos < 64; bpos++ )
block[ bpos ] = colldata[ cmp ][ bpos ][ dpos ];
// diff coding for dc
block[ 0 ] -= lastdc[ cmp ];
lastdc[ cmp ] = colldata[ cmp ][ 0 ][ dpos ];
// encode block
eob = jpg_encode_block_seq( huffw,
&(hcodes[ 0 ][ cmpnfo[cmp].huffac ]),
&(hcodes[ 1 ][ cmpnfo[cmp].huffac ]),
block );
// check for errors, proceed if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
else if ( cs_to == 0 ) {
if ( cs_sah == 0 ) {
// ---> progressive non interleaved DC encoding <---
// ---> succesive approximation first stage <---
while ( sta == 0 ) {
// diff coding & bitshifting for dc
tmp = colldata[ cmp ][ 0 ][ dpos ] >> cs_sal;
block[ 0 ] = tmp - lastdc[ cmp ];
lastdc[ cmp ] = tmp;
// encode dc
sta = jpg_encode_dc_prg_fs( huffw,
&(hcodes[ 0 ][ cmpnfo[cmp].huffdc ]),
block );
// check for errors, increment dpos otherwise
if ( sta != -1 )
sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
else {
// ---> progressive non interleaved DC encoding <---
// ---> succesive approximation later stage <---
while ( sta == 0 ) {
// fetch bit from current bitplane
block[ 0 ] = BITN( colldata[ cmp ][ 0 ][ dpos ], cs_sal );
// encode dc correction bit
sta = jpg_encode_dc_prg_sa( huffw, block );
// next mcupos if no error happened
if ( sta != -1 )
sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
}
}
else {
if ( cs_sah == 0 ) {
// ---> progressive non interleaved AC encoding <---
// ---> succesive approximation first stage <---
while ( sta == 0 ) {
// copy from colldata
for ( bpos = cs_from; bpos <= cs_to; bpos++ )
block[ bpos ] =
FDIV2( colldata[ cmp ][ bpos ][ dpos ], cs_sal );
// encode block
eob = jpg_encode_ac_prg_fs( huffw,
&(hcodes[ 1 ][ cmpnfo[cmp].huffac ]),
block, &eobrun, cs_from, cs_to );
// check for errors, proceed if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
// encode remaining eobrun
jpg_encode_eobrun( huffw,
&(hcodes[ 1 ][ cmpnfo[cmp].huffac ]),
&eobrun );
}
else {
// ---> progressive non interleaved AC encoding <---
// ---> succesive approximation later stage <---
while ( sta == 0 ) {
// copy from colldata
for ( bpos = cs_from; bpos <= cs_to; bpos++ )
block[ bpos ] =
FDIV2( colldata[ cmp ][ bpos ][ dpos ], cs_sal );
// encode block
eob = jpg_encode_ac_prg_sa( huffw, storw,
&(hcodes[ 1 ][ cmpnfo[cmp].huffac ]),
block, &eobrun, cs_from, cs_to );
// check for errors, proceed if no error encountered
if ( eob < 0 ) sta = -1;
else sta = jpg_next_mcuposn( &cmp, &dpos, &rstw );
}
// encode remaining eobrun
jpg_encode_eobrun( huffw,
&(hcodes[ 1 ][ cmpnfo[cmp].huffac ]),
&eobrun );
// encode remaining correction bits
jpg_encode_crbits( huffw, storw );
}
}
}
// pad huffman writer
huffw->pad( padbit );
// evaluate status
if ( sta == -1 ) { // status -1 means error
sprintf( errormessage, "encode error in scan%i / mcu%i",
scnc, ( cs_cmpc > 1 ) ? mcu : dpos );
delete huffw;
errorlevel = 2;
return false;
}
else if ( sta == 2 ) { // status 2 means done
scnc++; // increment scan counter
break; // leave decoding loop, everything is done here
}
else if ( sta == 1 ) { // status 1 means restart
if ( rsti > 0 ) // store rstp & stay in the loop
rstp[ rstc++ ] = huffw->getpos() - 1;
}
}
}
// safety check for error in huffwriter
if ( huffw->error ) {
delete huffw;
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// get data into huffdata
huffdata = huffw->getptr();
hufs = huffw->getpos();
delete huffw;
// remove storage writer
delete storw;
// store last scan & restart positions
scnp[ scnc ] = hufs;
if ( rstp != NULL )
rstp[ rstc ] = hufs;
return true;
}
/* -----------------------------------------------
adapt ICOS tables for quantizer tables
----------------------------------------------- */
INTERN bool adapt_icos( void )
{
unsigned short quant[ 64 ]; // local copy of quantization
int ipos;
int cmp;
for ( cmp = 0; cmp < cmpc; cmp++ ) {
// make a local copy of the quantization values, check
for ( ipos = 0; ipos < 64; ipos++ ) {
quant[ ipos ] = QUANT( cmp, zigzag[ ipos ] );
if ( quant[ ipos ] >= 2048 ) // if this is true, it can be safely assumed (for 8 bit JPEG), that all coefficients are zero
quant[ ipos ] = 0;
}
// adapt idct 8x8 table
for ( ipos = 0; ipos < 64 * 64; ipos++ )
adpt_idct_8x8[ cmp ][ ipos ] = icos_idct_8x8[ ipos ] * quant[ ipos % 64 ];
// adapt idct 1x8 table
for ( ipos = 0; ipos < 8 * 8; ipos++ )
adpt_idct_1x8[ cmp ][ ipos ] = icos_idct_1x8[ ipos ] * quant[ ( ipos % 8 ) * 8 ];
// adapt idct 8x1 table
for ( ipos = 0; ipos < 8 * 8; ipos++ )
adpt_idct_8x1[ cmp ][ ipos ] = icos_idct_1x8[ ipos ] * quant[ ipos % 8 ];
}
return true;
}
/* -----------------------------------------------
filter DC coefficients
----------------------------------------------- */
INTERN bool predict_dc( void )
{
signed short* coef;
int absmaxp;
int absmaxn;
int corr_f;
int cmp, dpos;
// apply prediction, store prediction error instead of DC
for ( cmp = 0; cmp < cmpc; cmp++ ) {
absmaxp = MAX_V( cmp, 0 );
absmaxn = -absmaxp;
corr_f = ( ( 2 * absmaxp ) + 1 );
for ( dpos = cmpnfo[cmp].bc - 1; dpos > 0; dpos-- ) {
coef = &(colldata[cmp][0][dpos]);
#if defined( USE_PLOCOI )
(*coef) -= dc_coll_predictor( cmp, dpos ); // loco-i predictor
#else
(*coef) -= dc_1ddct_predictor( cmp, dpos ); // 1d dct
#endif
// fix range
if ( (*coef) > absmaxp ) (*coef) -= corr_f;
else if ( (*coef) < absmaxn ) (*coef) += corr_f;
}
}
return true;
}
/* -----------------------------------------------
unpredict DC coefficients
----------------------------------------------- */
INTERN bool unpredict_dc( void )
{
signed short* coef;
int absmaxp;
int absmaxn;
int corr_f;
int cmp, dpos;
// remove prediction, store DC instead of prediction error
for ( cmp = 0; cmp < cmpc; cmp++ ) {
absmaxp = MAX_V( cmp, 0 );
absmaxn = -absmaxp;
corr_f = ( ( 2 * absmaxp ) + 1 );
for ( dpos = 1; dpos < cmpnfo[cmp].bc; dpos++ ) {
coef = &(colldata[cmp][0][dpos]);
#if defined( USE_PLOCOI )
(*coef) += dc_coll_predictor( cmp, dpos ); // loco-i predictor
#else
(*coef) += dc_1ddct_predictor( cmp, dpos ); // 1d dct predictor
#endif
// fix range
if ( (*coef) > absmaxp ) (*coef) -= corr_f;
else if ( (*coef) < absmaxn ) (*coef) += corr_f;
}
}
return true;
}
/* -----------------------------------------------
checks range of values, error if out of bounds
----------------------------------------------- */
INTERN bool check_value_range( void )
{
int absmax;
int cmp, bpos, dpos;
// out of range should never happen with unmodified JPEGs
for ( cmp = 0; cmp < cmpc; cmp++ )
for ( bpos = 0; bpos < 64; bpos++ ) {
absmax = MAX_V( cmp, bpos );
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ )
if ( ( colldata[cmp][bpos][dpos] > absmax ) ||
( colldata[cmp][bpos][dpos] < -absmax ) ) {
sprintf( errormessage, "value out of range error: cmp%i, frq%i, val %i, max %i",
cmp, bpos, colldata[cmp][bpos][dpos], absmax );
errorlevel = 2;
return false;
}
}
return true;
}
/* -----------------------------------------------
calculate zero distribution lists
----------------------------------------------- */
INTERN bool calc_zdst_lists( void )
{
int cmp, bpos, dpos;
int b_x, b_y;
// this functions counts, for each DCT block, the number of non-zero coefficients
for ( cmp = 0; cmp < cmpc; cmp++ )
{
// preset zdstlist
memset( zdstdata[cmp], 0, cmpnfo[cmp].bc * sizeof( char ) );
// calculate # on non-zeroes per block (separately for lower 7x7 block & first row/collumn)
for ( bpos = 1; bpos < 64; bpos++ ) {
b_x = unzigzag[ bpos ] % 8;
b_y = unzigzag[ bpos ] / 8;
if ( b_x == 0 ) {
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ )
if ( colldata[cmp][bpos][dpos] != 0 ) zdstylow[cmp][dpos]++;
}
else if ( b_y == 0 ) {
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ )
if ( colldata[cmp][bpos][dpos] != 0 ) zdstxlow[cmp][dpos]++;
}
else {
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ )
if ( colldata[cmp][bpos][dpos] != 0 ) zdstdata[cmp][dpos]++;
}
}
}
return true;
}
/* -----------------------------------------------
packs all parts to compressed pjg
----------------------------------------------- */
INTERN bool pack_pjg( void )
{
aricoder* encoder;
unsigned char hcode;
int cmp;
#if defined(DEV_INFOS)
int dev_size = 0;
#endif
// PJG-Header
str_out->write( (void*) pjg_magic, 1, 2 );
// store settings if not auto
if ( !auto_set ) {
hcode = 0x00;
str_out->write( &hcode, 1, 1 );
str_out->write( nois_trs, 1, 4 );
str_out->write( segm_cnt, 1, 4 );
}
// store version number
hcode = appversion;
str_out->write( &hcode, 1, 1 );
// init arithmetic compression
encoder = new aricoder( str_out, 1 );
// discard meta information from header if option set
if ( disc_meta )
if ( !jpg_rebuild_header() ) return false;
// optimize header for compression
if ( !pjg_optimize_header() ) return false;
// set padbit to 1 if previously unset
if ( padbit == -1 ) padbit = 1;
// encode JPG header
#if !defined(DEV_INFOS)
if ( !pjg_encode_generic( encoder, hdrdata, hdrs ) ) return false;
#else
dev_size = str_out->getpos();
if ( !pjg_encode_generic( encoder, hdrdata, hdrs ) ) return false;
dev_size_hdr += str_out->getpos() - dev_size;
#endif
// store padbit (padbit can't be retrieved from the header)
if ( !pjg_encode_bit( encoder, padbit ) ) return false;
// also encode one bit to signal false/correct use of RST markers
if ( !pjg_encode_bit( encoder, ( rst_err == NULL ) ? 0 : 1 ) ) return false;
// encode # of false set RST markers per scan
if ( rst_err != NULL )
if ( !pjg_encode_generic( encoder, rst_err, scnc ) ) return false;
// encode actual components data
for ( cmp = 0; cmp < cmpc; cmp++ ) {
#if !defined(DEV_INFOS)
// encode frequency scan ('zero-sort-scan')
if ( !pjg_encode_zstscan( encoder, cmp ) ) return false;
// encode zero-distribution-lists for higher (7x7) ACs
if ( !pjg_encode_zdst_high( encoder, cmp ) ) return false;
// encode coefficients for higher (7x7) ACs
if ( !pjg_encode_ac_high( encoder, cmp ) ) return false;
// encode zero-distribution-lists for lower ACs
if ( !pjg_encode_zdst_low( encoder, cmp ) ) return false;
// encode coefficients for first row / collumn ACs
if ( !pjg_encode_ac_low( encoder, cmp ) ) return false;
// encode coefficients for DC
if ( !pjg_encode_dc( encoder, cmp ) ) return false;
#else
dev_size = str_out->getpos();
// encode frequency scan ('zero-sort-scan')
if ( !pjg_encode_zstscan( encoder, cmp ) ) return false;
dev_size_zsr[ cmp ] += str_out->getpos() - dev_size;
dev_size = str_out->getpos();
// encode zero-distribution-lists for higher (7x7) ACs
if ( !pjg_encode_zdst_high( encoder, cmp ) ) return false;
dev_size_zdh[ cmp ] += str_out->getpos() - dev_size;
dev_size = str_out->getpos();
// encode coefficients for higher (7x7) ACs
if ( !pjg_encode_ac_high( encoder, cmp ) ) return false;
dev_size_ach[ cmp ] += str_out->getpos() - dev_size;
dev_size = str_out->getpos();
// encode zero-distribution-lists for lower ACs
if ( !pjg_encode_zdst_low( encoder, cmp ) ) return false;
dev_size_zdl[ cmp ] += str_out->getpos() - dev_size;
dev_size = str_out->getpos();
// encode coefficients for first row / collumn ACs
if ( !pjg_encode_ac_low( encoder, cmp ) ) return false;
dev_size_acl[ cmp ] += str_out->getpos() - dev_size;
dev_size = str_out->getpos();
// encode coefficients for DC
if ( !pjg_encode_dc( encoder, cmp ) ) return false;
dev_size_dc[ cmp ] += str_out->getpos() - dev_size;
dev_size_cmp[ cmp ] =
dev_size_zsr[ cmp ] + dev_size_zdh[ cmp ] + dev_size_zdl[ cmp ] +
dev_size_ach[ cmp ] + dev_size_acl[ cmp ] + dev_size_dc[ cmp ];
#endif
}
// encode checkbit for garbage (0 if no garbage, 1 if garbage has to be coded)
if ( !pjg_encode_bit( encoder, ( grbs > 0 ) ? 1 : 0 ) ) return false;
// encode garbage data only if needed
if ( grbs > 0 )
if ( !pjg_encode_generic( encoder, grbgdata, grbs ) ) return false;
// finalize arithmetic compression
delete( encoder );
// errormessage if write error
if ( str_out->chkerr() ) {
sprintf( errormessage, "write error, possibly drive is full" );
errorlevel = 2;
return false;
}
// get filesize
pjgfilesize = str_out->getsize();
return true;
}
/* -----------------------------------------------
unpacks compressed pjg to colldata
----------------------------------------------- */
INTERN bool unpack_pjg( void )
{
aricoder* decoder;
unsigned char hcode;
unsigned char cb;
int cmp;
// check header codes ( maybe position in other function ? )
while( true ) {
str_in->read( &hcode, 1, 1 );
if ( hcode == 0x00 ) {
// retrieve compression settings from file
str_in->read( nois_trs, 1, 4 );
str_in->read( segm_cnt, 1, 4 );
auto_set = false;
}
else if ( hcode >= 0x14 ) {
// compare version number
if ( hcode != appversion ) {
sprintf( errormessage, "incompatible file, use %s v%i.%i",
appname, hcode / 10, hcode % 10 );
errorlevel = 2;
return false;
}
else break;
}
else {
sprintf( errormessage, "unknown header code, use newer version of %s", appname );
errorlevel = 2;
return false;
}
}
// init arithmetic compression
decoder = new aricoder( str_in, 0 );
// decode JPG header
if ( !pjg_decode_generic( decoder, &hdrdata, &hdrs ) ) return false;
// retrieve padbit from stream
if ( !pjg_decode_bit( decoder, &cb ) ) return false; padbit = cb;
// decode one bit that signals false /correct use of RST markers
if ( !pjg_decode_bit( decoder, &cb ) ) return false;
// decode # of false set RST markers per scan only if available
if ( cb == 1 )
if ( !pjg_decode_generic( decoder, &rst_err, NULL ) ) return false;
// undo header optimizations
if ( !pjg_unoptimize_header() ) return false;
// discard meta information from header if option set
if ( disc_meta )
if ( !jpg_rebuild_header() ) return false;
// parse header for image-info
if ( !jpg_setup_imginfo() ) return false;
// decode actual components data
for ( cmp = 0; cmp < cmpc; cmp++ ) {
// decode frequency scan ('zero-sort-scan')
if ( !pjg_decode_zstscan( decoder, cmp ) ) return false;
// decode zero-distribution-lists for higher (7x7) ACs
if ( !pjg_decode_zdst_high( decoder, cmp ) ) return false;
// decode coefficients for higher (7x7) ACs
if ( !pjg_decode_ac_high( decoder, cmp ) ) return false;
// decode zero-distribution-lists for lower ACs
if ( !pjg_decode_zdst_low( decoder, cmp ) ) return false;
// decode coefficients for first row / collumn ACs
if ( !pjg_decode_ac_low( decoder, cmp ) ) return false;
// decode coefficients for DC
if ( !pjg_decode_dc( decoder, cmp ) ) return false;
}
// retrieve checkbit for garbage (0 if no garbage, 1 if garbage has to be coded)
if ( !pjg_decode_bit( decoder, &cb ) ) return false;
// decode garbage data only if available
if ( cb == 0 ) grbs = 0;
else if ( !pjg_decode_generic( decoder, &grbgdata, &grbs ) ) return false;
// finalize arithmetic compression
delete( decoder );
// get filesize
pjgfilesize = str_in->getsize();
return true;
}
/* ----------------------- End of main functions -------------------------- */
/* ----------------------- Begin of JPEG specific functions -------------------------- */
/* -----------------------------------------------
Parses header for imageinfo
----------------------------------------------- */
INTERN bool jpg_setup_imginfo( void )
{
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // position in header
int cmp, bpos;
int i;
// header parser loop
while ( ( int ) hpos < hdrs ) {
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
// do not parse DHT & DRI
if ( ( type != 0xDA ) && ( type != 0xC4 ) && ( type != 0xDD ) ) {
if ( !jpg_parse_jfif( type, len, &( hdrdata[ hpos ] ) ) )
return false;
}
hpos += len;
}
// check if information is complete
if ( cmpc == 0 ) {
sprintf( errormessage, "header contains incomplete information" );
errorlevel = 2;
return false;
}
for ( cmp = 0; cmp < cmpc; cmp++ ) {
if ( ( cmpnfo[cmp].sfv == 0 ) ||
( cmpnfo[cmp].sfh == 0 ) ||
( cmpnfo[cmp].qtable == NULL ) ||
( cmpnfo[cmp].qtable[0] == 0 ) ||
( jpegtype == 0 ) ) {
sprintf( errormessage, "header information is incomplete" );
errorlevel = 2;
return false;
}
}
// do all remaining component info calculations
for ( cmp = 0; cmp < cmpc; cmp++ ) {
if ( cmpnfo[ cmp ].sfh > sfhm ) sfhm = cmpnfo[ cmp ].sfh;
if ( cmpnfo[ cmp ].sfv > sfvm ) sfvm = cmpnfo[ cmp ].sfv;
}
mcuv = ( int ) ceil( (float) imgheight / (float) ( 8 * sfhm ) );
mcuh = ( int ) ceil( (float) imgwidth / (float) ( 8 * sfvm ) );
mcuc = mcuv * mcuh;
for ( cmp = 0; cmp < cmpc; cmp++ ) {
cmpnfo[ cmp ].mbs = cmpnfo[ cmp ].sfv * cmpnfo[ cmp ].sfh;
cmpnfo[ cmp ].bcv = mcuv * cmpnfo[ cmp ].sfh;
cmpnfo[ cmp ].bch = mcuh * cmpnfo[ cmp ].sfv;
cmpnfo[ cmp ].bc = cmpnfo[ cmp ].bcv * cmpnfo[ cmp ].bch;
cmpnfo[ cmp ].ncv = ( int ) ceil( (float) imgheight *
( (float) cmpnfo[ cmp ].sfh / ( 8.0 * sfhm ) ) );
cmpnfo[ cmp ].nch = ( int ) ceil( (float) imgwidth *
( (float) cmpnfo[ cmp ].sfv / ( 8.0 * sfvm ) ) );
cmpnfo[ cmp ].nc = cmpnfo[ cmp ].ncv * cmpnfo[ cmp ].nch;
}
// decide components' statistical ids
if ( cmpc <= 3 ) {
for ( cmp = 0; cmp < cmpc; cmp++ ) cmpnfo[ cmp ].sid = cmp;
}
else {
for ( cmp = 0; cmp < cmpc; cmp++ ) cmpnfo[ cmp ].sid = 0;
}
// alloc memory for further operations
for ( cmp = 0; cmp < cmpc; cmp++ )
{
// alloc memory for colls
for ( bpos = 0; bpos < 64; bpos++ ) {
colldata[cmp][bpos] = (short int*) calloc ( cmpnfo[cmp].bc, sizeof( short ) );
if (colldata[cmp][bpos] == NULL) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
}
// alloc memory for zdstlist / eob x / eob y
zdstdata[cmp] = (unsigned char*) calloc( cmpnfo[cmp].bc, sizeof( char ) );
eobxhigh[cmp] = (unsigned char*) calloc( cmpnfo[cmp].bc, sizeof( char ) );
eobyhigh[cmp] = (unsigned char*) calloc( cmpnfo[cmp].bc, sizeof( char ) );
zdstxlow[cmp] = (unsigned char*) calloc( cmpnfo[cmp].bc, sizeof( char ) );
zdstylow[cmp] = (unsigned char*) calloc( cmpnfo[cmp].bc, sizeof( char ) );
if ( ( zdstdata[cmp] == NULL ) ||
( eobxhigh[cmp] == NULL ) || ( eobyhigh[cmp] == NULL ) ||
( zdstxlow[cmp] == NULL ) || ( zdstylow[cmp] == NULL ) ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
}
// also decide automatic settings here
if ( auto_set ) {
for ( cmp = 0; cmp < cmpc; cmp++ ) {
for ( i = 0;
conf_sets[ i ][ cmpnfo[cmp].sid ] > (unsigned int) cmpnfo[ cmp ].bc;
i++ );
segm_cnt[ cmp ] = conf_segm[ i ][ cmpnfo[cmp].sid ];
nois_trs[ cmp ] = conf_ntrs[ i ][ cmpnfo[cmp].sid ];
}
}
return true;
}
/* -----------------------------------------------
Parse routines for JFIF segments
----------------------------------------------- */
INTERN bool jpg_parse_jfif( unsigned char type, unsigned int len, unsigned char* segment )
{
unsigned int hpos = 4; // current position in segment, start after segment header
int lval, rval; // temporary variables
int skip;
int cmp;
int i;
switch ( type )
{
case 0xC4: // DHT segment
// build huffman trees & codes
while ( hpos < len ) {
lval = LBITS( segment[ hpos ], 4 );
rval = RBITS( segment[ hpos ], 4 );
if ( ((lval < 0) || (lval >= 2)) || ((rval < 0) || (rval >= 4)) )
break;
hpos++;
// build huffman codes & trees
jpg_build_huffcodes( &(segment[ hpos + 0 ]), &(segment[ hpos + 16 ]),
&(hcodes[ lval ][ rval ]), &(htrees[ lval ][ rval ]) );
htset[ lval ][ rval ] = 1;
skip = 16;
for ( i = 0; i < 16; i++ )
skip += ( int ) segment[ hpos + i ];
hpos += skip;
}
if ( hpos != len ) {
// if we get here, something went wrong
sprintf( errormessage, "size mismatch in dht marker" );
errorlevel = 2;
return false;
}
return true;
case 0xDB: // DQT segment
// copy quantization tables to internal memory
while ( hpos < len ) {
lval = LBITS( segment[ hpos ], 4 );
rval = RBITS( segment[ hpos ], 4 );
if ( (lval < 0) || (lval >= 2) ) break;
if ( (rval < 0) || (rval >= 4) ) break;
hpos++;
if ( lval == 0 ) { // 8 bit precision
for ( i = 0; i < 64; i++ ) {
qtables[ rval ][ i ] = ( unsigned short ) segment[ hpos + i ];
if ( qtables[ rval ][ i ] == 0 ) break;
}
hpos += 64;
}
else { // 16 bit precision
for ( i = 0; i < 64; i++ ) {
qtables[ rval ][ i ] =
B_SHORT( segment[ hpos + (2*i) ], segment[ hpos + (2*i) + 1 ] );
if ( qtables[ rval ][ i ] == 0 ) break;
}
hpos += 128;
}
}
if ( hpos != len ) {
// if we get here, something went wrong
sprintf( errormessage, "size mismatch in dqt marker" );
errorlevel = 2;
return false;
}
return true;
case 0xDD: // DRI segment
// define restart interval
rsti = B_SHORT( segment[ hpos ], segment[ hpos + 1 ] );
return true;
case 0xDA: // SOS segment
// prepare next scan
cs_cmpc = segment[ hpos ];
if ( cs_cmpc > cmpc ) {
sprintf( errormessage, "%i components in scan, only %i are allowed",
cs_cmpc, cmpc );
errorlevel = 2;
return false;
}
hpos++;
for ( i = 0; i < cs_cmpc; i++ ) {
for ( cmp = 0; ( segment[ hpos ] != cmpnfo[ cmp ].jid ) && ( cmp < cmpc ); cmp++ );
if ( cmp == cmpc ) {
sprintf( errormessage, "component id mismatch in start-of-scan" );
errorlevel = 2;
return false;
}
cs_cmp[ i ] = cmp;
cmpnfo[ cmp ].huffdc = LBITS( segment[ hpos + 1 ], 4 );
cmpnfo[ cmp ].huffac = RBITS( segment[ hpos + 1 ], 4 );
if ( ( cmpnfo[ cmp ].huffdc < 0 ) || ( cmpnfo[ cmp ].huffdc >= 4 ) ||
( cmpnfo[ cmp ].huffac < 0 ) || ( cmpnfo[ cmp ].huffac >= 4 ) ) {
sprintf( errormessage, "huffman table number mismatch" );
errorlevel = 2;
return false;
}
hpos += 2;
}
cs_from = segment[ hpos + 0 ];
cs_to = segment[ hpos + 1 ];
cs_sah = LBITS( segment[ hpos + 2 ], 4 );
cs_sal = RBITS( segment[ hpos + 2 ], 4 );
// check for errors
if ( ( cs_from > cs_to ) || ( cs_from > 63 ) || ( cs_to > 63 ) ) {
sprintf( errormessage, "spectral selection parameter out of range" );
errorlevel = 2;
return false;
}
if ( ( cs_sah >= 12 ) || ( cs_sal >= 12 ) ) {
sprintf( errormessage, "successive approximation parameter out of range" );
errorlevel = 2;
return false;
}
return true;
case 0xC0: // SOF0 segment
// coding process: baseline DCT
case 0xC1: // SOF1 segment
// coding process: extended sequential DCT
case 0xC2: // SOF2 segment
// coding process: progressive DCT
// set JPEG coding type
if ( type == 0xC2 )
jpegtype = 2;
else
jpegtype = 1;
// check data precision, only 8 bit is allowed
lval = segment[ hpos ];
if ( lval != 8 ) {
sprintf( errormessage, "%i bit data precision is not supported", lval );
errorlevel = 2;
return false;
}
// image size, height & component count
imgheight = B_SHORT( segment[ hpos + 1 ], segment[ hpos + 2 ] );
imgwidth = B_SHORT( segment[ hpos + 3 ], segment[ hpos + 4 ] );
cmpc = segment[ hpos + 5 ];
if ( cmpc > 4 ) {
sprintf( errormessage, "image has %i components, max 4 are supported", cmpc );
errorlevel = 2;
return false;
}
hpos += 6;
// components contained in image
for ( cmp = 0; cmp < cmpc; cmp++ ) {
cmpnfo[ cmp ].jid = segment[ hpos ];
cmpnfo[ cmp ].sfv = LBITS( segment[ hpos + 1 ], 4 );
cmpnfo[ cmp ].sfh = RBITS( segment[ hpos + 1 ], 4 );
cmpnfo[ cmp ].qtable = qtables[ segment[ hpos + 2 ] ];
hpos += 3;
}
return true;
case 0xC3: // SOF3 segment
// coding process: lossless sequential
sprintf( errormessage, "sof3 marker found, image is coded lossless" );
errorlevel = 2;
return false;
case 0xC5: // SOF5 segment
// coding process: differential sequential DCT
sprintf( errormessage, "sof5 marker found, image is coded diff. sequential" );
errorlevel = 2;
return false;
case 0xC6: // SOF6 segment
// coding process: differential progressive DCT
sprintf( errormessage, "sof6 marker found, image is coded diff. progressive" );
errorlevel = 2;
return false;
case 0xC7: // SOF7 segment
// coding process: differential lossless
sprintf( errormessage, "sof7 marker found, image is coded diff. lossless" );
errorlevel = 2;
return false;
case 0xC9: // SOF9 segment
// coding process: arithmetic extended sequential DCT
sprintf( errormessage, "sof9 marker found, image is coded arithm. sequential" );
errorlevel = 2;
return false;
case 0xCA: // SOF10 segment
// coding process: arithmetic extended sequential DCT
sprintf( errormessage, "sof10 marker found, image is coded arithm. progressive" );
errorlevel = 2;
return false;
case 0xCB: // SOF11 segment
// coding process: arithmetic extended sequential DCT
sprintf( errormessage, "sof11 marker found, image is coded arithm. lossless" );
errorlevel = 2;
return false;
case 0xCD: // SOF13 segment
// coding process: arithmetic differntial sequential DCT
sprintf( errormessage, "sof13 marker found, image is coded arithm. diff. sequential" );
errorlevel = 2;
return false;
case 0xCE: // SOF14 segment
// coding process: arithmetic differential progressive DCT
sprintf( errormessage, "sof14 marker found, image is coded arithm. diff. progressive" );
errorlevel = 2;
return false;
case 0xCF: // SOF15 segment
// coding process: arithmetic differntial lossless
sprintf( errormessage, "sof15 marker found, image is coded arithm. diff. lossless" );
errorlevel = 2;
return false;
case 0xE0: // APP0 segment
case 0xE1: // APP1 segment
case 0xE2: // APP2 segment
case 0xE3: // APP3 segment
case 0xE4: // APP4 segment
case 0xE5: // APP5 segment
case 0xE6: // APP6 segment
case 0xE7: // APP7 segment
case 0xE8: // APP8 segment
case 0xE9: // APP9 segment
case 0xEA: // APP10 segment
case 0xEB: // APP11 segment
case 0xEC: // APP12segment
case 0xED: // APP13 segment
case 0xEE: // APP14 segment
case 0xEF: // APP15 segment
case 0xFE: // COM segment
// do nothing - return true
return true;
case 0xD0: // RST0 segment
case 0xD1: // RST1segment
case 0xD2: // RST2 segment
case 0xD3: // RST3 segment
case 0xD4: // RST4 segment
case 0xD5: // RST5 segment
case 0xD6: // RST6 segment
case 0xD7: // RST7 segment
// return errormessage - RST is out of place here
sprintf( errormessage, "rst marker found out of place" );
errorlevel = 2;
return false;
case 0xD8: // SOI segment
// return errormessage - start-of-image is out of place here
sprintf( errormessage, "soi marker found out of place" );
errorlevel = 2;
return false;
case 0xD9: // EOI segment
// return errormessage - end-of-image is out of place here
sprintf( errormessage, "eoi marker found out of place" );
errorlevel = 2;
return false;
default: // unknown marker segment
// return warning
sprintf( errormessage, "unknown marker found: FF %2X", type );
errorlevel = 1;
return true;
}
}
/* -----------------------------------------------
JFIF header rebuilding routine
----------------------------------------------- */
INTERN bool jpg_rebuild_header( void )
{
abytewriter* hdrw; // new header writer
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // position in header
// start headerwriter
hdrw = new abytewriter( 4096 );
// header parser loop
while ( ( int ) hpos < hdrs ) {
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
// discard any unneeded meta info
if ( ( type == 0xDA ) || ( type == 0xC4 ) || ( type == 0xDB ) ||
( type == 0xC0 ) || ( type == 0xC1 ) || ( type == 0xC2 ) ||
( type == 0xDD ) ) {
hdrw->write_n( &(hdrdata[ hpos ]), len );
}
hpos += len;
}
// replace current header with the new one
free( hdrdata );
hdrdata = hdrw->getptr();
hdrs = hdrw->getpos();
delete( hdrw );
return true;
}
/* -----------------------------------------------
sequential block decoding routine
----------------------------------------------- */
INTERN int jpg_decode_block_seq( abitreader* huffr, huffTree* dctree, huffTree* actree, short* block )
{
unsigned short n;
unsigned char s;
unsigned char z;
int eob = 64;
int bpos;
int hc;
// decode dc
hc = jpg_next_huffcode( huffr, dctree );
if ( hc < 0 ) return -1; // return error
else s = ( unsigned char ) hc;
n = huffr->read( s );
block[ 0 ] = DEVLI( s, n );
// decode ac
for ( bpos = 1; bpos < 64; )
{
// decode next
hc = jpg_next_huffcode( huffr, actree );
// analyse code
if ( hc > 0 ) {
z = LBITS( hc, 4 );
s = RBITS( hc, 4 );
n = huffr->read( s );
if ( ( z + bpos ) >= 64 )
return -1; // run is to long
while ( z > 0 ) { // write zeroes
block[ bpos++ ] = 0;
z--;
}
block[ bpos++ ] = ( short ) DEVLI( s, n ); // decode cvli
}
else if ( hc == 0 ) { // EOB
eob = bpos;
// while( bpos < 64 ) // fill remaining block with zeroes
// block[ bpos++ ] = 0;
break;
}
else {
return -1; // return error
}
}
// return position of eob
return eob;
}
/* -----------------------------------------------
sequential block encoding routine
----------------------------------------------- */
INTERN int jpg_encode_block_seq( abitwriter* huffw, huffCodes* dctbl, huffCodes* actbl, short* block )
{
unsigned short n;
unsigned char s;
unsigned char z;
int bpos;
int hc;
// encode DC
s = BITLEN2048N( block[ 0 ] );
n = ENVLI( s, block[ 0 ] );
huffw->write( dctbl->cval[ s ], dctbl->clen[ s ] );
huffw->write( n, s );
// encode AC
z = 0;
for ( bpos = 1; bpos < 64; bpos++ )
{
// if nonzero is encountered
if ( block[ bpos ] != 0 ) {
// write remaining zeroes
while ( z >= 16 ) {
huffw->write( actbl->cval[ 0xF0 ], actbl->clen[ 0xF0 ] );
z -= 16;
}
// vli encode
s = BITLEN2048N( block[ bpos ] );
n = ENVLI( s, block[ bpos ] );
hc = ( ( z << 4 ) + s );
// write to huffman writer
huffw->write( actbl->cval[ hc ], actbl->clen[ hc ] );
huffw->write( n, s );
// reset zeroes
z = 0;
}
else { // increment zero counter
z++;
}
}
// write eob if needed
if ( z > 0 )
huffw->write( actbl->cval[ 0x00 ], actbl->clen[ 0x00 ] );
return 64 - z;
}
/* -----------------------------------------------
progressive DC decoding routine
----------------------------------------------- */
INTERN int jpg_decode_dc_prg_fs( abitreader* huffr, huffTree* dctree, short* block )
{
unsigned short n;
unsigned char s;
int hc;
// decode dc
hc = jpg_next_huffcode( huffr, dctree );
if ( hc < 0 ) return -1; // return error
else s = ( unsigned char ) hc;
n = huffr->read( s );
block[ 0 ] = DEVLI( s, n );
// return 0 if everything is ok
return 0;
}
/* -----------------------------------------------
progressive DC encoding routine
----------------------------------------------- */
INTERN int jpg_encode_dc_prg_fs( abitwriter* huffw, huffCodes* dctbl, short* block )
{
unsigned short n;
unsigned char s;
// encode DC
s = BITLEN2048N( block[ 0 ] );
n = ENVLI( s, block[ 0 ] );
huffw->write( dctbl->cval[ s ], dctbl->clen[ s ] );
huffw->write( n, s );
// return 0 if everything is ok
return 0;
}
/* -----------------------------------------------
progressive AC decoding routine
----------------------------------------------- */
INTERN int jpg_decode_ac_prg_fs( abitreader* huffr, huffTree* actree, short* block, int* eobrun, int from, int to )
{
unsigned short n;
unsigned char s;
unsigned char z;
int eob = to + 1;
int bpos;
int hc;
int l;
int r;
// decode ac
for ( bpos = from; bpos <= to; )
{
// decode next
hc = jpg_next_huffcode( huffr, actree );
if ( hc < 0 ) return -1;
l = LBITS( hc, 4 );
r = RBITS( hc, 4 );
// analyse code
if ( ( l == 15 ) || ( r > 0 ) ) { // decode run/level combination
z = l;
s = r;
n = huffr->read( s );
if ( ( z + bpos ) > to )
return -1; // run is to long
while ( z > 0 ) { // write zeroes
block[ bpos++ ] = 0;
z--;
}
block[ bpos++ ] = ( short ) DEVLI( s, n ); // decode cvli
}
else { // decode eobrun
eob = bpos;
s = l;
n = huffr->read( s );
(*eobrun) = E_DEVLI( s, n );
// while( bpos <= to ) // fill remaining block with zeroes
// block[ bpos++ ] = 0;
break;
}
}
// return position of eob
return eob;
}
/* -----------------------------------------------
progressive AC encoding routine
----------------------------------------------- */
INTERN int jpg_encode_ac_prg_fs( abitwriter* huffw, huffCodes* actbl, short* block, int* eobrun, int from, int to )
{
unsigned short n;
unsigned char s;
unsigned char z;
int bpos;
int hc;
// encode AC
z = 0;
for ( bpos = from; bpos <= to; bpos++ )
{
// if nonzero is encountered
if ( block[ bpos ] != 0 ) {
// encode eobrun
jpg_encode_eobrun( huffw, actbl, eobrun );
// write remaining zeroes
while ( z >= 16 ) {
huffw->write( actbl->cval[ 0xF0 ], actbl->clen[ 0xF0 ] );
z -= 16;
}
// vli encode
s = BITLEN2048N( block[ bpos ] );
n = ENVLI( s, block[ bpos ] );
hc = ( ( z << 4 ) + s );
// write to huffman writer
huffw->write( actbl->cval[ hc ], actbl->clen[ hc ] );
huffw->write( n, s );
// reset zeroes
z = 0;
}
else { // increment zero counter
z++;
}
}
// check eob, increment eobrun if needed
if ( z > 0 ) {
(*eobrun)++;
// check eobrun, encode if needed
if ( (*eobrun) == actbl->max_eobrun )
jpg_encode_eobrun( huffw, actbl, eobrun );
return 1 + to - z;
}
else {
return 1 + to;
}
}
/* -----------------------------------------------
progressive DC SA decoding routine
----------------------------------------------- */
INTERN int jpg_decode_dc_prg_sa( abitreader* huffr, short* block )
{
// decode next bit of dc coefficient
block[ 0 ] = huffr->read( 1 );
// return 0 if everything is ok
return 0;
}
/* -----------------------------------------------
progressive DC SA encoding routine
----------------------------------------------- */
INTERN int jpg_encode_dc_prg_sa( abitwriter* huffw, short* block )
{
// enocode next bit of dc coefficient
huffw->write( block[ 0 ], 1 );
// return 0 if everything is ok
return 0;
}
/* -----------------------------------------------
progressive AC SA decoding routine
----------------------------------------------- */
INTERN int jpg_decode_ac_prg_sa( abitreader* huffr, huffTree* actree, short* block, int* eobrun, int from, int to )
{
unsigned short n;
unsigned char s;
signed char z;
signed char v;
int bpos = from;
int eob = to;
int hc;
int l;
int r;
// decode AC succesive approximation bits
if ( (*eobrun) == 0 ) while ( bpos <= to )
{
// decode next
hc = jpg_next_huffcode( huffr, actree );
if ( hc < 0 ) return -1;
l = LBITS( hc, 4 );
r = RBITS( hc, 4 );
// analyse code
if ( ( l == 15 ) || ( r > 0 ) ) { // decode run/level combination
z = l;
s = r;
if ( s == 0 ) v = 0;
else if ( s == 1 ) {
n = huffr->read( 1 );
v = ( n == 0 ) ? -1 : 1; // fast decode vli
}
else return -1; // decoding error
// write zeroes / write correction bits
while ( true ) {
if ( block[ bpos ] == 0 ) { // skip zeroes / write value
if ( z > 0 ) z--;
else {
block[ bpos++ ] = v;
break;
}
}
else { // read correction bit
n = huffr->read( 1 );
block[ bpos ] = ( block[ bpos ] > 0 ) ? n : -n;
}
if ( bpos++ >= to ) return -1; // error check
}
}
else { // decode eobrun
eob = bpos;
s = l;
n = huffr->read( s );
(*eobrun) = E_DEVLI( s, n );
break;
}
}
// read after eob correction bits
if ( (*eobrun) > 0 ) {
for ( ; bpos <= to; bpos++ ) {
if ( block[ bpos ] != 0 ) {
n = huffr->read( 1 );
block[ bpos ] = ( block[ bpos ] > 0 ) ? n : -n;
}
}
}
// return eob
return eob;
}
/* -----------------------------------------------
progressive AC SA encoding routine
----------------------------------------------- */
INTERN int jpg_encode_ac_prg_sa( abitwriter* huffw, abytewriter* storw, huffCodes* actbl, short* block, int* eobrun, int from, int to )
{
unsigned short n;
unsigned char s;
unsigned char z;
int eob = from;
int bpos;
int hc;
// check if block contains any newly nonzero coefficients and find out position of eob
for ( bpos = to; bpos >= from; bpos-- ) {
if ( ( block[ bpos ] == 1 ) || ( block[ bpos ] == -1 ) ) {
eob = bpos + 1;
break;
}
}
// encode eobrun if needed
if ( ( eob > from ) && ( (*eobrun) > 0 ) ) {
jpg_encode_eobrun( huffw, actbl, eobrun );
jpg_encode_crbits( huffw, storw );
}
// encode AC
z = 0;
for ( bpos = from; bpos < eob; bpos++ )
{
// if zero is encountered
if ( block[ bpos ] == 0 ) {
z++; // increment zero counter
if ( z == 16 ) { // write zeroes if needed
huffw->write( actbl->cval[ 0xF0 ], actbl->clen[ 0xF0 ] );
jpg_encode_crbits( huffw, storw );
z = 0;
}
}
// if nonzero is encountered
else if ( ( block[ bpos ] == 1 ) || ( block[ bpos ] == -1 ) ) {
// vli encode
s = BITLEN2048N( block[ bpos ] );
n = ENVLI( s, block[ bpos ] );
hc = ( ( z << 4 ) + s );
// write to huffman writer
huffw->write( actbl->cval[ hc ], actbl->clen[ hc ] );
huffw->write( n, s );
// write correction bits
jpg_encode_crbits( huffw, storw );
// reset zeroes
z = 0;
}
else { // store correction bits
n = block[ bpos ] & 0x1;
storw->write( n );
}
}
// fast processing after eob
for ( ;bpos <= to; bpos++ )
{
if ( block[ bpos ] != 0 ) { // store correction bits
n = block[ bpos ] & 0x1;
storw->write( n );
}
}
// check eob, increment eobrun if needed
if ( eob <= to ) {
(*eobrun)++;
// check eobrun, encode if needed
if ( (*eobrun) == actbl->max_eobrun ) {
jpg_encode_eobrun( huffw, actbl, eobrun );
jpg_encode_crbits( huffw, storw );
}
}
// return eob
return eob;
}
/* -----------------------------------------------
run of EOB SA decoding routine
----------------------------------------------- */
INTERN int jpg_decode_eobrun_sa( abitreader* huffr, short* block, int* eobrun, int from, int to )
{
unsigned short n;
int bpos;
// fast eobrun decoding routine for succesive approximation
for ( bpos = from; bpos <= to; bpos++ ) {
if ( block[ bpos ] != 0 ) {
n = huffr->read( 1 );
block[ bpos ] = ( block[ bpos ] > 0 ) ? n : -n;
}
}
return 0;
}
/* -----------------------------------------------
run of EOB encoding routine
----------------------------------------------- */
INTERN int jpg_encode_eobrun( abitwriter* huffw, huffCodes* actbl, int* eobrun )
{
unsigned short n;
unsigned char s;
int hc;
if ( (*eobrun) > 0 ) {
while ( (*eobrun) > actbl->max_eobrun ) {
huffw->write( actbl->cval[ 0xE0 ], actbl->clen[ 0xE0 ] );
huffw->write( E_ENVLI( 14, 32767 ), 14 );
(*eobrun) -= actbl->max_eobrun;
}
BITLEN( s, (*eobrun) );
s--;
n = E_ENVLI( s, (*eobrun) );
hc = ( s << 4 );
huffw->write( actbl->cval[ hc ], actbl->clen[ hc ] );
huffw->write( n, s );
(*eobrun) = 0;
}
return 0;
}
/* -----------------------------------------------
correction bits encoding routine
----------------------------------------------- */
INTERN int jpg_encode_crbits( abitwriter* huffw, abytewriter* storw )
{
unsigned char* data;
int len;
int i;
// peek into data from abytewriter
len = storw->getpos();
if ( len == 0 ) return 0;
data = storw->peekptr();
// write bits to huffwriter
for ( i = 0; i < len; i++ )
huffw->write( data[ i ], 1 );
// reset abytewriter, discard data
storw->reset();
return 0;
}
/* -----------------------------------------------
returns next code (from huffman-tree & -data)
----------------------------------------------- */
INTERN int jpg_next_huffcode( abitreader *huffw, huffTree *ctree )
{
int node = 0;
while ( node < 256 ) {
node = ( huffw->read( 1 ) == 1 ) ?
ctree->r[ node ] : ctree->l[ node ];
if ( node == 0 ) break;
}
return ( node - 256 );
}
/* -----------------------------------------------
calculates next position for MCU
----------------------------------------------- */
INTERN int jpg_next_mcupos( int* mcu, int* cmp, int* csc, int* sub, int* dpos, int* rstw )
{
int sta = 0; // status
// increment all counts where needed
if ( ( ++(*sub) ) >= cmpnfo[(*cmp)].mbs ) {
(*sub) = 0;
if ( ( ++(*csc) ) >= cs_cmpc ) {
(*csc) = 0;
(*cmp) = cs_cmp[ 0 ];
(*mcu)++;
if ( (*mcu) >= mcuc ) sta = 2;
else if ( rsti > 0 )
if ( --(*rstw) == 0 ) sta = 1;
}
else {
(*cmp) = cs_cmp[(*csc)];
}
}
// get correct position in image ( x & y )
if ( cmpnfo[(*cmp)].sfh > 1 ) { // to fix mcu order
(*dpos) = ( (*mcu) / mcuh ) * cmpnfo[(*cmp)].sfh + ( (*sub) / cmpnfo[(*cmp)].sfv );
(*dpos) *= cmpnfo[(*cmp)].bch;
(*dpos) += ( (*mcu) % mcuh ) * cmpnfo[(*cmp)].sfv + ( (*sub) % cmpnfo[(*cmp)].sfv );
}
else if ( cmpnfo[(*cmp)].sfv > 1 ) {
// simple calculation to speed up things if simple fixing is enough
(*dpos) = ( (*mcu) * cmpnfo[(*cmp)].mbs ) + (*sub);
}
else {
// no calculations needed without subsampling
(*dpos) = (*mcu);
}
return sta;
}
/* -----------------------------------------------
calculates next position (non interleaved)
----------------------------------------------- */
INTERN int jpg_next_mcuposn( int* cmp, int* dpos, int* rstw )
{
// increment position
(*dpos)++;
// fix for non interleaved mcu - horizontal
if ( cmpnfo[(*cmp)].bch != cmpnfo[(*cmp)].nch ) {
if ( (*dpos) % cmpnfo[(*cmp)].bch == cmpnfo[(*cmp)].nch )
(*dpos) += ( cmpnfo[(*cmp)].bch - cmpnfo[(*cmp)].nch );
}
// fix for non interleaved mcu - vertical
if ( cmpnfo[(*cmp)].bcv != cmpnfo[(*cmp)].ncv ) {
if ( (*dpos) / cmpnfo[(*cmp)].bch == cmpnfo[(*cmp)].ncv )
(*dpos) = cmpnfo[(*cmp)].bc;
}
// check position
if ( (*dpos) >= cmpnfo[(*cmp)].bc ) return 2;
else if ( rsti > 0 )
if ( --(*rstw) == 0 ) return 1;
return 0;
}
/* -----------------------------------------------
skips the eobrun, calculates next position
----------------------------------------------- */
INTERN int jpg_skip_eobrun( int* cmp, int* dpos, int* rstw, int* eobrun )
{
if ( (*eobrun) > 0 ) // error check for eobrun
{
// compare rst wait counter if needed
if ( rsti > 0 ) {
if ( (*eobrun) > (*rstw) )
return -1;
else
(*rstw) -= (*eobrun);
}
// fix for non interleaved mcu - horizontal
if ( cmpnfo[(*cmp)].bch != cmpnfo[(*cmp)].nch ) {
(*dpos) += ( ( ( (*dpos) % cmpnfo[(*cmp)].bch ) + (*eobrun) ) /
cmpnfo[(*cmp)].nch ) * ( cmpnfo[(*cmp)].bch - cmpnfo[(*cmp)].nch );
}
// fix for non interleaved mcu - vertical
if ( cmpnfo[(*cmp)].bcv != cmpnfo[(*cmp)].ncv ) {
if ( (*dpos) / cmpnfo[(*cmp)].bch >= cmpnfo[(*cmp)].ncv )
(*dpos) += ( cmpnfo[(*cmp)].bcv - cmpnfo[(*cmp)].ncv ) *
cmpnfo[(*cmp)].bch;
}
// skip blocks
(*dpos) += (*eobrun);
// reset eobrun
(*eobrun) = 0;
// check position
if ( (*dpos) == cmpnfo[(*cmp)].bc ) return 2;
else if ( (*dpos) > cmpnfo[(*cmp)].bc ) return -1;
else if ( rsti > 0 )
if ( (*rstw) == 0 ) return 1;
}
return 0;
}
/* -----------------------------------------------
creates huffman-codes & -trees from dht-data
----------------------------------------------- */
INTERN void jpg_build_huffcodes( unsigned char *clen, unsigned char *cval, huffCodes *hc, huffTree *ht )
{
int nextfree;
int code;
int node;
int i, j, k;
// fill with zeroes
memset( hc->clen, 0, 256 * sizeof( short ) );
memset( hc->cval, 0, 256 * sizeof( short ) );
memset( ht->l, 0, 256 * sizeof( short ) );
memset( ht->r, 0, 256 * sizeof( short ) );
// 1st part -> build huffman codes
// creating huffman-codes
k = 0;
code = 0;
// symbol-value of code is its position in the table
for( i = 0; i < 16; i++ ) {
for( j = 0; j < (int) clen[ i ]; j++ ) {
hc->clen[ (int) cval[k] ] = 1 + i;
hc->cval[ (int) cval[k] ] = code;
k++;
code++;
}
code = code << 1;
}
// find out eobrun max value
hc->max_eobrun = 0;
for ( i = 14; i >= 0; i-- ) {
if ( hc->clen[ i << 4 ] > 0 ) {
hc->max_eobrun = ( 2 << i ) - 1;
break;
}
}
// 2nd -> part use codes to build the coding tree
// initial value for next free place
nextfree = 1;
// work through every code creating links between the nodes (represented through ints)
for ( i = 0; i < 256; i++ ) {
// (re)set current node
node = 0;
// go through each code & store path
for ( j = hc->clen[ i ] - 1; j > 0; j-- ) {
if ( BITN( hc->cval[ i ], j ) == 1 ) {
if ( ht->r[ node ] == 0 )
ht->r[ node ] = nextfree++;
node = ht->r[ node ];
}
else{
if ( ht->l[ node ] == 0 )
ht->l[ node ] = nextfree++;
node = ht->l[ node ];
}
}
// last link is number of targetvalue + 256
if ( hc->clen[ i ] > 0 ) {
if ( BITN( hc->cval[ i ], 0 ) == 1 )
ht->r[ node ] = i + 256;
else
ht->l[ node ] = i + 256;
}
}
}
/* ----------------------- End of JPEG specific functions -------------------------- */
/* ----------------------- End of PJG specific functions -------------------------- */
/* -----------------------------------------------
encodes frequency scanorder to pjg
----------------------------------------------- */
INTERN bool pjg_encode_zstscan( aricoder* enc, int cmp )
{
model_s* model;
unsigned char freqlist[ 64 ];
int tpos; // true position
int cpos; // coded position
int c, i;
// calculate zero sort scan
pjg_get_zerosort_scan( zsrtscan[cmp], cmp );
// preset freqlist
for ( i = 0; i < 64; i++ )
freqlist[ i ] = stdscan[ i ];
// init model
model = INIT_MODEL_S( 64, 64, 1 );
// encode scanorder
for ( i = 1; i < 64; i++ )
{
// reduce range of model
model->exclude_symbols( 'a', 64 - i );
// compare remaining list to remainnig scan
tpos = 0;
for ( c = i; c < 64; c++ ) {
// search next val != 0 in list
for ( tpos++; freqlist[ tpos ] == 0; tpos++ );
// get out if not a match
if ( freqlist[ tpos ] != zsrtscan[ cmp ][ c ] ) break;
}
if ( c == 64 ) {
// remaining list is in sorted scanorder
// encode zero and make a quick exit
encode_ari( enc, model, 0 );
break;
}
// list is not in sorted order -> next pos hat to be encoded
cpos = 1;
// encode position
for ( tpos = 0; freqlist[ tpos ] != zsrtscan[ cmp ][ i ]; tpos++ )
if ( freqlist[ tpos ] != 0 ) cpos++;
// remove from list
freqlist[ tpos ] = 0;
// encode coded position in list
encode_ari( enc, model, cpos );
model->shift_context( cpos );
}
// delete model
delete( model );
// set zero sort scan as freqscan
freqscan[ cmp ] = zsrtscan[ cmp ];
return true;
}
/* -----------------------------------------------
encodes # of non zeroes to pjg (high)
----------------------------------------------- */
INTERN bool pjg_encode_zdst_high( aricoder* enc, int cmp )
{
model_s* model;
unsigned char* zdstls;
int dpos;
int a, b;
int bc;
int w;
// init model, constants
model = INIT_MODEL_S( 49 + 1, 25 + 1, 1 );
zdstls = zdstdata[ cmp ];
w = cmpnfo[cmp].bch;
bc = cmpnfo[cmp].bc;
// arithmetic encode zero-distribution-list
for ( dpos = 0; dpos < bc; dpos++ ) {
// context modelling - use average of above and left as context
get_context_nnb( dpos, w, &a, &b );
a = ( a >= 0 ) ? zdstls[ a ] : 0;
b = ( b >= 0 ) ? zdstls[ b ] : 0;
// shift context
model->shift_context( ( a + b + 2 ) / 4 );
// encode symbol
encode_ari( enc, model, zdstls[ dpos ] );
}
// clean up
delete( model );
return true;
}
/* -----------------------------------------------
encodes # of non zeroes to pjg (low)
----------------------------------------------- */
INTERN bool pjg_encode_zdst_low( aricoder* enc, int cmp )
{
model_s* model;
unsigned char* zdstls_x;
unsigned char* zdstls_y;
unsigned char* ctx_zdst;
unsigned char* ctx_eobx;
unsigned char* ctx_eoby;
int dpos;
int bc;
// init model, constants
model = INIT_MODEL_S( 8, 8, 2 );
zdstls_x = zdstxlow[ cmp ];
zdstls_y = zdstylow[ cmp ];
ctx_eobx = eobxhigh[ cmp ];
ctx_eoby = eobyhigh[ cmp ];
ctx_zdst = zdstdata[ cmp ];
bc = cmpnfo[cmp].bc;
// arithmetic encode zero-distribution-list (first row)
for ( dpos = 0; dpos < bc; dpos++ ) {
model->shift_context( ( ctx_zdst[dpos] + 3 ) / 7 ); // shift context
model->shift_context( ctx_eobx[dpos] ); // shift context
encode_ari( enc, model, zdstls_x[ dpos ] ); // encode symbol
}
// arithmetic encode zero-distribution-list (first collumn)
for ( dpos = 0; dpos < bc; dpos++ ) {
model->shift_context( ( ctx_zdst[dpos] + 3 ) / 7 ); // shift context
model->shift_context( ctx_eoby[dpos] ); // shift context
encode_ari( enc, model, zdstls_y[ dpos ] ); // encode symbol
}
// clean up
delete( model );
return true;
}
/* -----------------------------------------------
encodes DC coefficients to pjg
----------------------------------------------- */
INTERN bool pjg_encode_dc( aricoder* enc, int cmp )
{
unsigned char* segm_tab;
model_s* mod_len;
model_b* mod_sgn;
model_b* mod_res;
unsigned char* zdstls; // pointer to zero distribution list
signed short* coeffs; // pointer to current coefficent data
unsigned short* absv_store; // absolute coefficients values storage
unsigned short* c_absc[ 6 ]; // quick access array for contexts
int c_weight[ 6 ]; // weighting for contexts
int ctx_avr; // 'average' context
int ctx_len; // context for bit length
int max_val; // max value
int max_len; // max bitlength
int dpos;
int clen, absv, sgn;
int snum;
int bt, bp;
int p_x, p_y;
int r_x; //, r_y;
int w, bc;
// decide segmentation setting
segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ];
// get max absolute value/bit length
max_val = MAX_V( cmp, 0 );
max_len = BITLEN1024P( max_val );
// init models for bitlenghts and -patterns
mod_len = INIT_MODEL_S( max_len + 1, ( segm_cnt[cmp] > max_len ) ? segm_cnt[cmp] : max_len + 1, 2 );
mod_res = INIT_MODEL_B( ( segm_cnt[cmp] < 16 ) ? 1 << 4 : segm_cnt[cmp], 2 );
mod_sgn = INIT_MODEL_B( 1, 0 );
// set width/height of each band
bc = cmpnfo[cmp].bc;
w = cmpnfo[cmp].bch;
// allocate memory for absolute values storage
absv_store = (unsigned short*) calloc ( bc, sizeof( short ) );
if ( absv_store == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// set up context quick access array
pjg_aavrg_prepare( c_absc, c_weight, absv_store, cmp );
// locally store pointer to coefficients and zero distribution list
coeffs = colldata[ cmp ][ 0 ];
zdstls = zdstdata[ cmp ];
// arithmetic compression loop
for ( dpos = 0; dpos < bc; dpos++ )
{
//calculate x/y positions in band
p_y = dpos / w;
// r_y = h - ( p_y + 1 );
p_x = dpos % w;
r_x = w - ( p_x + 1 );
// get segment-number from zero distribution list and segmentation set
snum = segm_tab[ zdstls[dpos] ];
// calculate contexts (for bit length)
ctx_avr = pjg_aavrg_context( c_absc, c_weight, dpos, p_y, p_x, r_x ); // AVERAGE context
ctx_len = BITLEN1024P( ctx_avr ); // BITLENGTH context
// shift context / do context modelling (segmentation is done per context)
shift_model( mod_len, ctx_len, snum );
// simple treatment if coefficient is zero
if ( coeffs[ dpos ] == 0 ) {
// encode bit length (0) of current coefficient
encode_ari( enc, mod_len, 0 );
}
else {
// get absolute val, sign & bit length for current coefficient
absv = ABS( coeffs[dpos] );
clen = BITLEN1024P( absv );
sgn = ( coeffs[dpos] > 0 ) ? 0 : 1;
// encode bit length of current coefficient
encode_ari( enc, mod_len, clen );
// encoding of residual
// first set bit must be 1, so we start at clen - 2
for ( bp = clen - 2; bp >= 0; bp-- ) {
shift_model( mod_res, snum, bp ); // shift in 2 contexts
// encode/get bit
bt = BITN( absv, bp );
encode_ari( enc, mod_res, bt );
}
// encode sign
encode_ari( enc, mod_sgn, sgn );
// store absolute value
absv_store[ dpos ] = absv;
}
}
// free memory / clear models
free( absv_store );
delete ( mod_len );
delete ( mod_res );
delete ( mod_sgn );
return true;
}
/* -----------------------------------------------
encodes high (7x7) AC coefficients to pjg
----------------------------------------------- */
INTERN bool pjg_encode_ac_high( aricoder* enc, int cmp )
{
unsigned char* segm_tab;
model_s* mod_len;
model_b* mod_sgn;
model_b* mod_res;
unsigned char* zdstls; // pointer to zero distribution list
unsigned char* eob_x; // pointer to x eobs
unsigned char* eob_y; // pointer to y eobs
signed short* coeffs; // pointer to current coefficent data
unsigned short* absv_store; // absolute coefficients values storage
unsigned short* c_absc[ 6 ]; // quick access array for contexts
int c_weight[ 6 ]; // weighting for contexts
unsigned char* sgn_store; // sign storage for context
unsigned char* sgn_nbh; // left signs neighbor
unsigned char* sgn_nbv; // upper signs neighbor
int ctx_avr; // 'average' context
int ctx_len; // context for bit length
int ctx_sgn; // context for sign
int max_val; // max value
int max_len; // max bitlength
int bpos, dpos;
int clen, absv, sgn;
int snum;
int bt, bp;
int i;
int b_x, b_y;
int p_x, p_y;
int r_x; //, r_y;
int w, bc;
// decide segmentation setting
segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ];
// init models for bitlenghts and -patterns
mod_len = INIT_MODEL_S( 11, ( segm_cnt[cmp] > 11 ) ? segm_cnt[cmp] : 11, 2 );
mod_res = INIT_MODEL_B( ( segm_cnt[cmp] < 16 ) ? 1 << 4 : segm_cnt[cmp], 2 );
mod_sgn = INIT_MODEL_B( 9, 1 );
// set width/height of each band
bc = cmpnfo[cmp].bc;
w = cmpnfo[cmp].bch;
// allocate memory for absolute values & signs storage
absv_store = (unsigned short*) calloc ( bc, sizeof( short ) );
sgn_store = (unsigned char*) calloc ( bc, sizeof( char ) );
zdstls = (unsigned char*) calloc ( bc, sizeof( char ) );
if ( ( absv_store == NULL ) || ( sgn_store == NULL ) || ( zdstls == NULL ) ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// set up quick access arrays for signs context
sgn_nbh = sgn_store - 1;
sgn_nbv = sgn_store - w;
// locally store pointer to eob x / eob y
eob_x = eobxhigh[ cmp ];
eob_y = eobyhigh[ cmp ];
// preset x/y eobs
memset( eob_x, 0x00, bc * sizeof( char ) );
memset( eob_y, 0x00, bc * sizeof( char ) );
// make a local copy of the zero distribution list
for ( dpos = 0; dpos < bc; dpos++ )
zdstls[ dpos ] = zdstdata[ cmp ][ dpos ];
// work through lower 7x7 bands in order of freqscan
for ( i = 1; i < 64; i++ )
{
// work through blocks in order of frequency scan
bpos = (int) freqscan[cmp][i];
b_x = unzigzag[ bpos ] % 8;
b_y = unzigzag[ bpos ] / 8;
if ( ( b_x == 0 ) || ( b_y == 0 ) )
continue; // process remaining coefficients elsewhere
// preset absolute values/sign storage
memset( absv_store, 0x00, bc * sizeof( short ) );
memset( sgn_store, 0x00, bc * sizeof( char ) );
// set up average context quick access arrays
pjg_aavrg_prepare( c_absc, c_weight, absv_store, cmp );
// locally store pointer to coefficients
coeffs = colldata[ cmp ][ bpos ];
// get max bit length
max_val = MAX_V( cmp, bpos );
max_len = BITLEN1024P( max_val );
// arithmetic compression loo
for ( dpos = 0; dpos < bc; dpos++ )
{
// skip if beyound eob
if ( zdstls[dpos] == 0 )
continue;
//calculate x/y positions in band
p_y = dpos / w;
// r_y = h - ( p_y + 1 );
p_x = dpos % w;
r_x = w - ( p_x + 1 );
// get segment-number from zero distribution list and segmentation set
snum = segm_tab[ zdstls[dpos] ];
// calculate contexts (for bit length)
ctx_avr = pjg_aavrg_context( c_absc, c_weight, dpos, p_y, p_x, r_x ); // AVERAGE context
ctx_len = BITLEN1024P( ctx_avr ); // BITLENGTH context
// shift context / do context modelling (segmentation is done per context)
shift_model( mod_len, ctx_len, snum );
mod_len->exclude_symbols( 'a', max_len );
// simple treatment if coefficient is zero
if ( coeffs[ dpos ] == 0 ) {
// encode bit length (0) of current coefficien
encode_ari( enc, mod_len, 0 );
}
else {
// get absolute val, sign & bit length for current coefficient
absv = ABS( coeffs[dpos] );
clen = BITLEN1024P( absv );
sgn = ( coeffs[dpos] > 0 ) ? 0 : 1;
// encode bit length of current coefficient
encode_ari( enc, mod_len, clen );
// encoding of residual
// first set bit must be 1, so we start at clen - 2
for ( bp = clen - 2; bp >= 0; bp-- ) {
shift_model( mod_res, snum, bp ); // shift in 2 contexts
// encode/get bit
bt = BITN( absv, bp );
encode_ari( enc, mod_res, bt );
}
// encode sign
ctx_sgn = ( p_x > 0 ) ? sgn_nbh[ dpos ] : 0; // sign context
if ( p_y > 0 ) ctx_sgn += 3 * sgn_nbv[ dpos ]; // IMPROVE !!!!!!!!!!!
mod_sgn->shift_context( ctx_sgn );
encode_ari( enc, mod_sgn, sgn );
// store absolute value/sign, decrement zdst
absv_store[ dpos ] = absv;
sgn_store[ dpos ] = sgn + 1;
zdstls[dpos]--;
// recalculate x/y eob
if ( b_x > eob_x[dpos] ) eob_x[dpos] = b_x;
if ( b_y > eob_y[dpos] ) eob_y[dpos] = b_y;
}
}
// flush models
mod_len->flush_model( 1 );
mod_res->flush_model( 1 );
mod_sgn->flush_model( 1 );
}
// free memory / clear models
free( absv_store );
free( sgn_store );
free( zdstls );
delete ( mod_len );
delete ( mod_res );
delete ( mod_sgn );
return true;
}
/* -----------------------------------------------
encodes first row/col AC coefficients to pjg
----------------------------------------------- */
INTERN bool pjg_encode_ac_low( aricoder* enc, int cmp )
{
model_s* mod_len;
model_b* mod_sgn;
model_b* mod_res;
model_b* mod_top;
unsigned char* zdstls; // pointer to row/col # of non-zeroes
signed short* coeffs; // pointer to current coefficent data
signed short* coeffs_x[ 8 ]; // prediction coeffs - current block
signed short* coeffs_a[ 8 ]; // prediction coeffs - neighboring block
int pred_cf[ 8 ]; // prediction multipliers
int ctx_lak; // lakhani context
int ctx_abs; // absolute context
int ctx_len; // context for bit length
int ctx_res; // bit plane context for residual
int ctx_sgn; // context for sign
int max_valp; // max value (+)
int max_valn; // max value (-)
int max_len; // max bitlength
int thrs_bp; // residual threshold bitplane
int* edge_c; // edge criteria
int bpos, dpos;
int clen, absv, sgn;
int bt, bp;
int i;
int b_x, b_y;
int p_x, p_y;
int w, bc;
// init models for bitlenghts and -patterns
mod_len = INIT_MODEL_S( 11, ( segm_cnt[cmp] > 11 ) ? segm_cnt[cmp] : 11, 2 );
mod_res = INIT_MODEL_B( 1 << 4, 2 );
mod_top = INIT_MODEL_B( ( nois_trs[cmp] > 4 ) ? 1 << nois_trs[cmp] : 1 << 4, 3 );
mod_sgn = INIT_MODEL_B( 11, 1 );
// set width/height of each band
bc = cmpnfo[cmp].bc;
w = cmpnfo[cmp].bch;
// work through each first row / first collumn band
for ( i = 2; i < 16; i++ )
{
// alternate between first row and first collumn
b_x = ( i % 2 == 0 ) ? i / 2 : 0;
b_y = ( i % 2 == 1 ) ? i / 2 : 0;
bpos = (int) zigzag[ b_x + (8*b_y) ];
// locally store pointer to band coefficients
coeffs = colldata[ cmp ][ bpos ];
// store pointers to prediction coefficients
if ( b_x == 0 ) {
for ( ; b_x < 8; b_x++ ) {
coeffs_x[ b_x ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ];
coeffs_a[ b_x ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ] - 1;
pred_cf[ b_x ] = icos_base_8x8[ b_x * 8 ] * QUANT ( cmp, zigzag[b_x+(8*b_y)] );
} b_x = 0;
zdstls = zdstylow[ cmp ];
edge_c = &p_x;
}
else { // if ( b_y == 0 )
for ( ; b_y < 8; b_y++ ) {
coeffs_x[ b_y ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ];
coeffs_a[ b_y ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ] - w;
pred_cf[ b_y ] = icos_base_8x8[ b_y * 8 ] * QUANT ( cmp, zigzag[b_x+(8*b_y)] );
} b_y = 0;
zdstls = zdstxlow[ cmp ];
edge_c = &p_y;
}
// get max bit length / other info
max_valp = MAX_V( cmp, bpos );
max_valn = -max_valp;
max_len = BITLEN1024P( max_valp );
thrs_bp = ( max_len > nois_trs[cmp] ) ? max_len - nois_trs[cmp] : 0;
// arithmetic compression loop
for ( dpos = 0; dpos < bc; dpos++ )
{
// skip if beyound eob
if ( zdstls[ dpos ] == 0 )
continue;
// calculate x/y positions in band
p_y = dpos / w;
p_x = dpos % w;
// edge treatment / calculate LAKHANI context
if ( (*edge_c) > 0 )
ctx_lak = pjg_lakh_context( coeffs_x, coeffs_a, pred_cf, dpos );
else ctx_lak = 0;
ctx_lak = CLAMPED( max_valn, max_valp, ctx_lak );
ctx_len = BITLEN2048N( ctx_lak ); // BITLENGTH context
// shift context / do context modelling (segmentation is done per context)
shift_model( mod_len, ctx_len, zdstls[ dpos ] );
mod_len->exclude_symbols( 'a', max_len );
// simple treatment if coefficient is zero
if ( coeffs[ dpos ] == 0 ) {
// encode bit length (0) of current coefficient
encode_ari( enc, mod_len, 0 );
}
else {
// get absolute val, sign & bit length for current coefficient
absv = ABS( coeffs[dpos] );
clen = BITLEN2048N( absv );
sgn = ( coeffs[dpos] > 0 ) ? 0 : 1;
// encode bit length of current coefficient
encode_ari( enc, mod_len, clen );
// encoding of residual
bp = clen - 2; // first set bit must be 1, so we start at clen - 2
ctx_res = ( bp >= thrs_bp ) ? 1 : 0;
ctx_abs = ABS( ctx_lak );
ctx_sgn = ( ctx_lak == 0 ) ? 0 : ( ctx_lak > 0 ) ? 1 : 2;
for ( ; bp >= thrs_bp; bp-- ) {
shift_model( mod_top, ctx_abs >> thrs_bp, ctx_res, clen - thrs_bp ); // shift in 3 contexts
// encode/get bit
bt = BITN( absv, bp );
encode_ari( enc, mod_top, bt );
// update context
ctx_res = ctx_res << 1;
if ( bt ) ctx_res |= 1;
}
for ( ; bp >= 0; bp-- ) {
shift_model( mod_res, zdstls[ dpos ], bp ); // shift in 2 contexts
// encode/get bit
bt = BITN( absv, bp );
encode_ari( enc, mod_res, bt );
}
// encode sign
shift_model( mod_sgn, ctx_len, ctx_sgn );
encode_ari( enc, mod_sgn, sgn );
// decrement # of non zeroes
zdstls[ dpos ]--;
}
}
// flush models
mod_len->flush_model( 1 );
mod_res->flush_model( 1 );
mod_top->flush_model( 1 );
mod_sgn->flush_model( 1 );
}
// free memory / clear models
delete ( mod_len );
delete ( mod_res );
delete ( mod_top );
delete ( mod_sgn );
return true;
}
/* -----------------------------------------------
encodes a stream of generic (8bit) data to pjg
----------------------------------------------- */
INTERN bool pjg_encode_generic( aricoder* enc, unsigned char* data, int len )
{
model_s* model;
int i;
// arithmetic encode data
model = INIT_MODEL_S( 256 + 1, 256, 1 );
for ( i = 0; i < len; i++ )
{
encode_ari( enc, model, data[ i ] );
model->shift_context( data[ i ] );
}
// encode end-of-data symbol (256)
encode_ari( enc, model, 256 );
delete( model );
return true;
}
/* -----------------------------------------------
encodes one bit to pjg
----------------------------------------------- */
INTERN bool pjg_encode_bit( aricoder* enc, unsigned char bit )
{
model_b* model;
// encode one bit
model = INIT_MODEL_B( 1, -1 );
encode_ari( enc, model, bit );
delete( model );
return true;
}
/* -----------------------------------------------
encodes frequency scanorder to pjg
----------------------------------------------- */
INTERN bool pjg_decode_zstscan( aricoder* dec, int cmp )
{
model_s* model;;
unsigned char freqlist[ 64 ];
int tpos; // true position
int cpos; // coded position
int i;
// set first position in zero sort scan
zsrtscan[ cmp ][ 0 ] = 0;
// preset freqlist
for ( i = 0; i < 64; i++ )
freqlist[ i ] = stdscan[ i ];
// init model
model = INIT_MODEL_S( 64, 64, 1 );
// encode scanorder
for ( i = 1; i < 64; i++ )
{
// reduce range of model
model->exclude_symbols( 'a', 64 - i );
// decode symbol
cpos = decode_ari( dec, model );
model->shift_context( cpos );
if ( cpos == 0 ) {
// remaining list is identical to scan
// fill the scan & make a quick exit
for ( tpos = 0; i < 64; i++ ) {
while ( freqlist[ ++tpos ] == 0 );
zsrtscan[ cmp ][ i ] = freqlist[ tpos ];
}
break;
}
// decode position from list
for ( tpos = 0; tpos < 64; tpos++ ) {
if ( freqlist[ tpos ] != 0 ) cpos--;
if ( cpos == 0 ) break;
}
// write decoded position to zero sort scan
zsrtscan[ cmp ][ i ] = freqlist[ tpos ];
// remove from list
freqlist[ tpos ] = 0;
}
// delete model
delete( model );
// set zero sort scan as freqscan
freqscan[ cmp ] = zsrtscan[ cmp ];
return true;
}
/* -----------------------------------------------
decodes # of non zeroes from pjg (high)
----------------------------------------------- */
INTERN bool pjg_decode_zdst_high( aricoder* dec, int cmp )
{
model_s* model;
unsigned char* zdstls;
int dpos;
int a, b;
int bc;
int w;
// init model, constants
model = INIT_MODEL_S( 49 + 1, 25 + 1, 1 );
zdstls = zdstdata[ cmp ];
w = cmpnfo[cmp].bch;
bc = cmpnfo[cmp].bc;
// arithmetic decode zero-distribution-list
for ( dpos = 0; dpos < bc; dpos++ ) {
// context modelling - use average of above and left as context
get_context_nnb( dpos, w, &a, &b );
a = ( a >= 0 ) ? zdstls[ a ] : 0;
b = ( b >= 0 ) ? zdstls[ b ] : 0;
// shift context
model->shift_context( ( a + b + 2 ) / 4 );
// decode symbol
zdstls[ dpos ] = decode_ari( dec, model );
}
// clean up
delete( model );
return true;
}
/* -----------------------------------------------
decodes # of non zeroes from pjg (low)
----------------------------------------------- */
INTERN bool pjg_decode_zdst_low( aricoder* dec, int cmp )
{
model_s* model;
unsigned char* zdstls_x;
unsigned char* zdstls_y;
unsigned char* ctx_zdst;
unsigned char* ctx_eobx;
unsigned char* ctx_eoby;
int dpos;
int bc;
// init model, constants
model = INIT_MODEL_S( 8, 8, 2 );
zdstls_x = zdstxlow[ cmp ];
zdstls_y = zdstylow[ cmp ];
ctx_eobx = eobxhigh[ cmp ];
ctx_eoby = eobyhigh[ cmp ];
ctx_zdst = zdstdata[ cmp ];
bc = cmpnfo[cmp].bc;
// arithmetic encode zero-distribution-list (first row)
for ( dpos = 0; dpos < bc; dpos++ ) {
model->shift_context( ( ctx_zdst[dpos] + 3 ) / 7 ); // shift context
model->shift_context( ctx_eobx[dpos] ); // shift context
zdstls_x[ dpos ] = decode_ari( dec, model ); // decode symbol
}
// arithmetic encode zero-distribution-list (first collumn)
for ( dpos = 0; dpos < bc; dpos++ ) {
model->shift_context( ( ctx_zdst[dpos] + 3 ) / 7 ); // shift context
model->shift_context( ctx_eoby[dpos] ); // shift context
zdstls_y[ dpos ] = decode_ari( dec, model ); // decode symbol
}
// clean up
delete( model );
return true;
}
/* -----------------------------------------------
decodes DC coefficients from pjg
----------------------------------------------- */
INTERN bool pjg_decode_dc( aricoder* dec, int cmp )
{
unsigned char* segm_tab;
model_s* mod_len;
model_b* mod_sgn;
model_b* mod_res;
unsigned char* zdstls; // pointer to zero distribution list
signed short* coeffs; // pointer to current coefficent data
unsigned short* absv_store; // absolute coefficients values storage
unsigned short* c_absc[ 6 ]; // quick access array for contexts
int c_weight[ 6 ]; // weighting for contexts
int ctx_avr; // 'average' context
int ctx_len; // context for bit length
int max_val; // max value
int max_len; // max bitlength
int dpos;
int clen, absv, sgn;
int snum;
int bt, bp;
int p_x, p_y;
int r_x; //, r_y;
int w, bc;
// decide segmentation setting
segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ];
// get max absolute value/bit length
max_val = MAX_V( cmp, 0 );
max_len = BITLEN1024P( max_val );
// init models for bitlenghts and -patterns
mod_len = INIT_MODEL_S( max_len + 1, ( segm_cnt[cmp] > max_len ) ? segm_cnt[cmp] : max_len + 1, 2 );
mod_res = INIT_MODEL_B( ( segm_cnt[cmp] < 16 ) ? 1 << 4 : segm_cnt[cmp], 2 );
mod_sgn = INIT_MODEL_B( 1, 0 );
// set width/height of each band
bc = cmpnfo[cmp].bc;
w = cmpnfo[cmp].bch;
// allocate memory for absolute values storage
absv_store = (unsigned short*) calloc ( bc, sizeof( short ) );
if ( absv_store == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// set up context quick access array
pjg_aavrg_prepare( c_absc, c_weight, absv_store, cmp );
// locally store pointer to coefficients and zero distribution list
coeffs = colldata[ cmp ][ 0 ];
zdstls = zdstdata[ cmp ];
// arithmetic compression loop
for ( dpos = 0; dpos < bc; dpos++ )
{
//calculate x/y positions in band
p_y = dpos / w;
// r_y = h - ( p_y + 1 );
p_x = dpos % w;
r_x = w - ( p_x + 1 );
// get segment-number from zero distribution list and segmentation set
snum = segm_tab[ zdstls[dpos] ];
// calculate contexts (for bit length)
ctx_avr = pjg_aavrg_context( c_absc, c_weight, dpos, p_y, p_x, r_x ); // AVERAGE context
ctx_len = BITLEN1024P( ctx_avr ); // BITLENGTH context
// shift context / do context modelling (segmentation is done per context)
shift_model( mod_len, ctx_len, snum );
// decode bit length of current coefficient
clen = decode_ari( dec, mod_len );
// simple treatment if coefficient is zero
if ( clen == 0 ) {
// coeffs[ dpos ] = 0;
}
else {
// decoding of residual
absv = 1;
// first set bit must be 1, so we start at clen - 2
for ( bp = clen - 2; bp >= 0; bp-- ) {
shift_model( mod_res, snum, bp ); // shift in 2 contexts
// decode bit
bt = decode_ari( dec, mod_res );
// update absv
absv = absv << 1;
if ( bt ) absv |= 1;
}
// decode sign
sgn = decode_ari( dec, mod_sgn );
// copy to colldata
coeffs[ dpos ] = ( sgn == 0 ) ? absv : -absv;
// store absolute value/sign
absv_store[ dpos ] = absv;
}
}
// free memory / clear models
free( absv_store );
delete ( mod_len );
delete ( mod_res );
delete ( mod_sgn );
return true;
}
/* -----------------------------------------------
decodes high (7x7) AC coefficients to pjg
----------------------------------------------- */
INTERN bool pjg_decode_ac_high( aricoder* dec, int cmp )
{
unsigned char* segm_tab;
model_s* mod_len;
model_b* mod_sgn;
model_b* mod_res;
unsigned char* zdstls; // pointer to zero distribution list
unsigned char* eob_x; // pointer to x eobs
unsigned char* eob_y; // pointer to y eobs
signed short* coeffs; // pointer to current coefficent data
unsigned short* absv_store; // absolute coefficients values storage
unsigned short* c_absc[ 6 ]; // quick access array for contexts
int c_weight[ 6 ]; // weighting for contexts
unsigned char* sgn_store; // sign storage for context
unsigned char* sgn_nbh; // left signs neighbor
unsigned char* sgn_nbv; // upper signs neighbor
int ctx_avr; // 'average' context
int ctx_len; // context for bit length
int ctx_sgn; // context for sign
int max_val; // max value
int max_len; // max bitlength
int bpos, dpos;
int clen, absv, sgn;
int snum;
int bt, bp;
int i;
int b_x, b_y;
int p_x, p_y;
int r_x;
int w, bc;
// decide segmentation setting
segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ];
// init models for bitlenghts and -patterns
mod_len = INIT_MODEL_S( 11, ( segm_cnt[cmp] > 11 ) ? segm_cnt[cmp] : 11, 2 );
mod_res = INIT_MODEL_B( ( segm_cnt[cmp] < 16 ) ? 1 << 4 : segm_cnt[cmp], 2 );
mod_sgn = INIT_MODEL_B( 9, 1 );
// set width/height of each band
bc = cmpnfo[cmp].bc;
w = cmpnfo[cmp].bch;
// allocate memory for absolute values & signs storage
absv_store = (unsigned short*) calloc ( bc, sizeof( short ) );
sgn_store = (unsigned char*) calloc ( bc, sizeof( char ) );
zdstls = (unsigned char*) calloc ( bc, sizeof( char ) );
if ( ( absv_store == NULL ) || ( sgn_store == NULL ) ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// set up quick access arrays for signs context
sgn_nbh = sgn_store - 1;
sgn_nbv = sgn_store - w;
// locally store pointer to eob x / eob y
eob_x = eobxhigh[ cmp ];
eob_y = eobyhigh[ cmp ];
// preset x/y eobs
memset( eob_x, 0x00, bc * sizeof( char ) );
memset( eob_y, 0x00, bc * sizeof( char ) );
// make a local copy of the zero distribution list
for ( dpos = 0; dpos < bc; dpos++ )
zdstls[ dpos ] = zdstdata[ cmp ][ dpos ];
// work through lower 7x7 bands in order of freqscan
for ( i = 1; i < 64; i++ )
{
// work through blocks in order of frequency scan
bpos = (int) freqscan[cmp][i];
b_x = unzigzag[ bpos ] % 8;
b_y = unzigzag[ bpos ] / 8;
if ( ( b_x == 0 ) || ( b_y == 0 ) )
continue; // process remaining coefficients elsewhere
// preset absolute values/sign storage
memset( absv_store, 0x00, bc * sizeof( short ) );
memset( sgn_store, 0x00, bc * sizeof( char ) );
// set up average context quick access arrays
pjg_aavrg_prepare( c_absc, c_weight, absv_store, cmp );
// locally store pointer to coefficients
coeffs = colldata[ cmp ][ bpos ];
// get max bit length
max_val = MAX_V( cmp, bpos );
max_len = BITLEN1024P( max_val );
// arithmetic compression loop
for ( dpos = 0; dpos < bc; dpos++ )
{
// skip if beyound eob
if ( zdstls[dpos] == 0 )
continue;
//calculate x/y positions in band
p_y = dpos / w;
// r_y = h - ( p_y + 1 );
p_x = dpos % w;
r_x = w - ( p_x + 1 );
// get segment-number from zero distribution list and segmentation set
snum = segm_tab[ zdstls[dpos] ];
// calculate contexts (for bit length)
ctx_avr = pjg_aavrg_context( c_absc, c_weight, dpos, p_y, p_x, r_x ); // AVERAGE context
ctx_len = BITLEN1024P( ctx_avr ); // BITLENGTH context
// shift context / do context modelling (segmentation is done per context)
shift_model( mod_len, ctx_len, snum );
mod_len->exclude_symbols( 'a', max_len );
// decode bit length of current coefficient
clen = decode_ari( dec, mod_len );
// simple treatment if coefficient is zero
if ( clen == 0 ) {
// coeffs[ dpos ] = 0;
}
else {
// decoding of residual
absv = 1;
// first set bit must be 1, so we start at clen - 2
for ( bp = clen - 2; bp >= 0; bp-- ) {
shift_model( mod_res, snum, bp ); // shift in 2 contexts
// decode bit
bt = decode_ari( dec, mod_res );
// update absv
absv = absv << 1;
if ( bt ) absv |= 1;
}
// decode sign
ctx_sgn = ( p_x > 0 ) ? sgn_nbh[ dpos ] : 0; // sign context
if ( p_y > 0 ) ctx_sgn += 3 * sgn_nbv[ dpos ]; // IMPROVE! !!!!!!!!!!!
mod_sgn->shift_context( ctx_sgn );
sgn = decode_ari( dec, mod_sgn );
// copy to colldata
coeffs[ dpos ] = ( sgn == 0 ) ? absv : -absv;
// store absolute value/sign, decrement zdst
absv_store[ dpos ] = absv;
sgn_store[ dpos ] = sgn + 1;
zdstls[dpos]--;
// recalculate x/y eob
if ( b_x > eob_x[dpos] ) eob_x[dpos] = b_x;
if ( b_y > eob_y[dpos] ) eob_y[dpos] = b_y;
}
}
// flush models
mod_len->flush_model( 1 );
mod_res->flush_model( 1 );
mod_sgn->flush_model( 1 );
}
// free memory / clear models
free( absv_store );
free( sgn_store );
free( zdstls );
delete ( mod_len );
delete ( mod_res );
delete ( mod_sgn );
return true;
}
/* -----------------------------------------------
decodes high (7x7) AC coefficients to pjg
----------------------------------------------- */
INTERN bool pjg_decode_ac_low( aricoder* dec, int cmp )
{
model_s* mod_len;
model_b* mod_sgn;
model_b* mod_res;
model_b* mod_top;
unsigned char* zdstls; // pointer to row/col # of non-zeroes
signed short* coeffs; // pointer to current coefficent data
signed short* coeffs_x[ 8 ]; // prediction coeffs - current block
signed short* coeffs_a[ 8 ]; // prediction coeffs - neighboring block
int pred_cf[ 8 ]; // prediction multipliers
int ctx_lak; // lakhani context
int ctx_abs; // absolute context
int ctx_len; // context for bit length
int ctx_res; // bit plane context for residual
int ctx_sgn; // context for sign
int max_valp; // max value (+)
int max_valn; // max value (-)
int max_len; // max bitlength
int thrs_bp; // residual threshold bitplane
int* edge_c; // edge criteria
int bpos, dpos;
int clen, absv, sgn;
int bt, bp;
int i;
int b_x, b_y;
int p_x, p_y;
int w, bc;
// init models for bitlenghts and -patterns
mod_len = INIT_MODEL_S( 11, ( segm_cnt[cmp] > 11 ) ? segm_cnt[cmp] : 11, 2 );
mod_res = INIT_MODEL_B( 1 << 4, 2 );
mod_top = INIT_MODEL_B( ( nois_trs[cmp] > 4 ) ? 1 << nois_trs[cmp] : 1 << 4, 3 );
mod_sgn = INIT_MODEL_B( 11, 1 );
// set width/height of each band
bc = cmpnfo[cmp].bc;
w = cmpnfo[cmp].bch;
// work through each first row / first collumn band
for ( i = 2; i < 16; i++ )
{
// alternate between first row and first collumn
b_x = ( i % 2 == 0 ) ? i / 2 : 0;
b_y = ( i % 2 == 1 ) ? i / 2 : 0;
bpos = (int) zigzag[ b_x + (8*b_y) ];
// locally store pointer to band coefficients
coeffs = colldata[ cmp ][ bpos ];
// store pointers to prediction coefficients
if ( b_x == 0 ) {
for ( ; b_x < 8; b_x++ ) {
coeffs_x[ b_x ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ];
coeffs_a[ b_x ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ] - 1;
pred_cf[ b_x ] = icos_base_8x8[ b_x * 8 ] * QUANT ( cmp, zigzag[b_x+(8*b_y)] );
} b_x = 0;
zdstls = zdstylow[ cmp ];
edge_c = &p_x;
}
else { // if ( b_y == 0 )
for ( ; b_y < 8; b_y++ ) {
coeffs_x[ b_y ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ];
coeffs_a[ b_y ] = colldata[ cmp ][ zigzag[b_x+(8*b_y)] ] - w;
pred_cf[ b_y ] = icos_base_8x8[ b_y * 8 ] * QUANT ( cmp, zigzag[b_x+(8*b_y)] );
} b_y = 0;
zdstls = zdstxlow[ cmp ];
edge_c = &p_y;
}
// get max bit length / other info
max_valp = MAX_V( cmp, bpos );
max_valn = -max_valp;
max_len = BITLEN1024P( max_valp );
thrs_bp = ( max_len > nois_trs[cmp] ) ? max_len - nois_trs[cmp] : 0;
// arithmetic compression loop
for ( dpos = 0; dpos < bc; dpos++ )
{
// skip if beyound eob
if ( zdstls[ dpos ] == 0 )
continue;
//calculate x/y positions in band
p_y = dpos / w;
p_x = dpos % w;
// edge treatment / calculate LAKHANI context
if ( (*edge_c) > 0 )
ctx_lak = pjg_lakh_context( coeffs_x, coeffs_a, pred_cf, dpos );
else ctx_lak = 0;
ctx_lak = CLAMPED( max_valn, max_valp, ctx_lak );
ctx_len = BITLEN2048N( ctx_lak ); // BITLENGTH context
// shift context / do context modelling (segmentation is done per context)
shift_model( mod_len, ctx_len, zdstls[ dpos ] );
mod_len->exclude_symbols( 'a', max_len );
// decode bit length of current coefficient
clen = decode_ari( dec, mod_len );
// simple treatment if coefficients == 0
if ( clen == 0 ) {
// coeffs[ dpos ] = 0;
}
else {
// decoding of residual
bp = clen - 2; // first set bit must be 1, so we start at clen - 2
ctx_res = ( bp >= thrs_bp ) ? 1 : 0;
ctx_abs = ABS( ctx_lak );
ctx_sgn = ( ctx_lak == 0 ) ? 0 : ( ctx_lak > 0 ) ? 1 : 2;
for ( ; bp >= thrs_bp; bp-- ) {
shift_model( mod_top, ctx_abs >> thrs_bp, ctx_res, clen - thrs_bp ); // shift in 3 contexts
// decode bit
bt = decode_ari( dec, mod_top );
// update context
ctx_res = ctx_res << 1;
if ( bt ) ctx_res |= 1;
}
absv = ( ctx_res == 0 ) ? 1 : ctx_res; // !!!!
for ( ; bp >= 0; bp-- ) {
shift_model( mod_res, zdstls[ dpos ], bp ); // shift in 2 contexts
// decode bit
bt = decode_ari( dec, mod_res );
// update absv
absv = absv << 1;
if ( bt ) absv |= 1;
}
// decode sign
shift_model( mod_sgn, zdstls[ dpos ], ctx_sgn );
sgn = decode_ari( dec, mod_sgn );
// copy to colldata
coeffs[ dpos ] = ( sgn == 0 ) ? absv : -absv;
// decrement # of non zeroes
zdstls[ dpos ]--;
}
}
// flush models
mod_len->flush_model( 1 );
mod_res->flush_model( 1 );
mod_top->flush_model( 1 );
mod_sgn->flush_model( 1 );
}
// free memory / clear models
delete ( mod_len );
delete ( mod_res );
delete ( mod_top );
delete ( mod_sgn );
return true;
}
/* -----------------------------------------------
deodes a stream of generic (8bit) data from pjg
----------------------------------------------- */
INTERN bool pjg_decode_generic( aricoder* dec, unsigned char** data, int* len )
{
abytewriter* bwrt;
model_s* model;
int c;
// start byte writer
bwrt = new abytewriter( 1024 );
// decode header, ending with 256 symbol
model = INIT_MODEL_S( 256 + 1, 256, 1 );
while ( true ) {
c = decode_ari( dec, model );
if ( c == 256 ) break;
bwrt->write( (unsigned char) c );
model->shift_context( c );
}
delete( model );
// check for out of memory
if ( bwrt->error ) {
delete bwrt;
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
// get data/length and close byte writer
(*data) = bwrt->getptr();
if ( len != NULL ) (*len) = bwrt->getpos();
delete bwrt;
return true;
}
/* -----------------------------------------------
decodes one bit from pjg
----------------------------------------------- */
INTERN bool pjg_decode_bit( aricoder* dec, unsigned char* bit )
{
model_b* model;
model = INIT_MODEL_B( 1, -1 );
(*bit) = decode_ari( dec, model );
delete( model );
return true;
}
/* -----------------------------------------------
get zero sort frequency scan vector
----------------------------------------------- */
INTERN void pjg_get_zerosort_scan( unsigned char* sv, int cmp )
{
unsigned int zdist[ 64 ]; // distributions of zeroes per band
int bc = cmpnfo[cmp].bc;
int bpos, dpos;
bool done = false;
int swap;
int i;
// preset sv & zdist
for ( i = 0; i < 64; i++ ) {
sv[ i ] = i;
zdist[ i ] = 0;
}
// count zeroes for each frequency
for ( bpos = 0; bpos < 64; bpos++ )
for ( dpos = 0; dpos < bc; dpos++ )
if ( colldata[cmp][bpos][dpos] == 0 ) zdist[ bpos ]++;
// bubble sort according to count of zeroes (descending order)
while ( !done ) {
done = true;
for ( i = 2; i < 64; i++ )
if ( zdist[ i ] < zdist[ i - 1 ] ) {
swap = zdist[ i ];
zdist[ i ] = zdist[ i - 1 ];
zdist[ i - 1 ] = swap;
swap = sv[ i ];
sv[ i ] = sv[ i - 1 ];
sv[ i - 1 ] = swap;
done = false;
}
}
}
/* -----------------------------------------------
optimizes JFIF header for compression
----------------------------------------------- */
INTERN bool pjg_optimize_header( void )
{
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // position in header
unsigned int fpos; // end of marker position
unsigned int skip; // bytes to skip
unsigned int spos; // sub position
int i;
// search for DHT (0xFFC4) & DQT (0xFFDB) marker segments
// header parser loop
while ( ( int ) hpos < hdrs ) {
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
if ( type == 0xC4 ) { // for DHT
fpos = hpos + len; // reassign length to end position
hpos += 4; // skip marker & length
while ( hpos < fpos ) {
hpos++;
// table found - compare with each of the four standard tables
for ( i = 0; i < 4; i++ ) {
for ( spos = 0; spos < std_huff_lengths[ i ]; spos++ ) {
if ( hdrdata[ hpos + spos ] != std_huff_tables[ i ][ spos ] )
break;
}
// check if comparison ok
if ( spos != std_huff_lengths[ i ] )
continue;
// if we get here, the table matches the standard table
// number 'i', so it can be replaced
hdrdata[ hpos + 0 ] = std_huff_lengths[ i ] - 16 - i;
hdrdata[ hpos + 1 ] = i;
for ( spos = 2; spos < std_huff_lengths[ i ]; spos++ )
hdrdata[ hpos + spos ] = 0x00;
// everything done here, so leave
break;
}
skip = 16;
for ( i = 0; i < 16; i++ )
skip += ( int ) hdrdata[ hpos + i ];
hpos += skip;
}
}
else if ( type == 0xDB ) { // for DQT
fpos = hpos + len; // reassign length to end position
hpos += 4; // skip marker & length
while ( hpos < fpos ) {
i = LBITS( hdrdata[ hpos ], 4 );
hpos++;
// table found
if ( i == 1 ) { // get out for 16 bit precision
hpos += 128;
continue;
}
// do diff coding for 8 bit precision
for ( spos = 63; spos > 0; spos-- )
hdrdata[ hpos + spos ] -= hdrdata[ hpos + spos - 1 ];
hpos += 64;
}
}
else { // skip segment
hpos += len;
}
}
return true;
}
/* -----------------------------------------------
undoes the header optimizations
----------------------------------------------- */
INTERN bool pjg_unoptimize_header( void )
{
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // position in header
unsigned int fpos; // end of marker position
unsigned int skip; // bytes to skip
unsigned int spos; // sub position
int i;
// search for DHT (0xFFC4) & DQT (0xFFDB) marker segments
// header parser loop
while ( ( int ) hpos < hdrs ) {
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
if ( type == 0xC4 ) { // for DHT
fpos = hpos + len; // reassign length to end position
hpos += 4; // skip marker & length
while ( hpos < fpos ) {
hpos++;
// table found - check if modified
if ( hdrdata[ hpos ] > 2 ) {
// reinsert the standard table
i = hdrdata[ hpos + 1 ];
for ( spos = 0; spos < std_huff_lengths[ i ]; spos++ ) {
hdrdata[ hpos + spos ] = std_huff_tables[ i ][ spos ];
}
}
skip = 16;
for ( i = 0; i < 16; i++ )
skip += ( int ) hdrdata[ hpos + i ];
hpos += skip;
}
}
else if ( type == 0xDB ) { // for DQT
fpos = hpos + len; // reassign length to end position
hpos += 4; // skip marker & length
while ( hpos < fpos ) {
i = LBITS( hdrdata[ hpos ], 4 );
hpos++;
// table found
if ( i == 1 ) { // get out for 16 bit precision
hpos += 128;
continue;
}
// undo diff coding for 8 bit precision
for ( spos = 1; spos < 64; spos++ )
hdrdata[ hpos + spos ] += hdrdata[ hpos + spos - 1 ];
hpos += 64;
}
}
else { // skip segment
hpos += len;
}
}
return true;
}
/* -----------------------------------------------
preparations for special average context
----------------------------------------------- */
INTERN void pjg_aavrg_prepare( unsigned short** abs_coeffs, int* weights, unsigned short* abs_store, int cmp )
{
int w = cmpnfo[cmp].bch;
// set up quick access arrays for all prediction positions
abs_coeffs[ 0 ] = abs_store + ( 0 + ((-2)*w) ); // top-top
abs_coeffs[ 1 ] = abs_store + ( -1 + ((-1)*w) ); // top-left
abs_coeffs[ 2 ] = abs_store + ( 0 + ((-1)*w) ); // top
abs_coeffs[ 3 ] = abs_store + ( 1 + ((-1)*w) ); // top-right
abs_coeffs[ 4 ] = abs_store + ( -2 + (( 0)*w) ); // left-left
abs_coeffs[ 5 ] = abs_store + ( -1 + (( 0)*w) ); // left
// copy context weighting factors
weights[ 0 ] = abs_ctx_weights_lum[ 0 ][ 0 ][ 2 ]; // top-top
weights[ 1 ] = abs_ctx_weights_lum[ 0 ][ 1 ][ 1 ]; // top-left
weights[ 2 ] = abs_ctx_weights_lum[ 0 ][ 1 ][ 2 ]; // top
weights[ 3 ] = abs_ctx_weights_lum[ 0 ][ 1 ][ 3 ]; // top-right
weights[ 4 ] = abs_ctx_weights_lum[ 0 ][ 2 ][ 0 ]; // left-left
weights[ 5 ] = abs_ctx_weights_lum[ 0 ][ 2 ][ 1 ]; // left
}
/* -----------------------------------------------
special average context used in coeff encoding
----------------------------------------------- */
INTERN int pjg_aavrg_context( unsigned short** abs_coeffs, int* weights, int pos, int p_y, int p_x, int r_x )
{
int ctx_avr = 0; // AVERAGE context
int w_ctx = 0; // accumulated weight of context
int w_curr; // current weight of context
// different cases due to edge treatment
if ( p_y >= 2 ) {
w_curr = weights[ 0 ]; ctx_avr += abs_coeffs[ 0 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 2 ]; ctx_avr += abs_coeffs[ 2 ][ pos ] * w_curr; w_ctx += w_curr;
if ( p_x >= 2 ) {
w_curr = weights[ 1 ]; ctx_avr += abs_coeffs[ 1 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 4 ]; ctx_avr += abs_coeffs[ 4 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 5 ]; ctx_avr += abs_coeffs[ 5 ][ pos ] * w_curr; w_ctx += w_curr;
}
else if ( p_x == 1 ) {
w_curr = weights[ 1 ]; ctx_avr += abs_coeffs[ 1 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 5 ]; ctx_avr += abs_coeffs[ 5 ][ pos ] * w_curr; w_ctx += w_curr;
}
if ( r_x >= 1 ) {
w_curr = weights[ 3 ]; ctx_avr += abs_coeffs[ 3 ][ pos ] * w_curr; w_ctx += w_curr;
}
}
else if ( p_y == 1 ) {
w_curr = weights[ 2 ]; ctx_avr += abs_coeffs[ 2 ][ pos ] * w_curr; w_ctx += w_curr;
if ( p_x >= 2 ) {
w_curr = weights[ 1 ]; ctx_avr += abs_coeffs[ 1 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 4 ]; ctx_avr += abs_coeffs[ 4 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 5 ]; ctx_avr += abs_coeffs[ 5 ][ pos ] * w_curr; w_ctx += w_curr;
}
else if ( p_x == 1 ) {
w_curr = weights[ 1 ]; ctx_avr += abs_coeffs[ 1 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 5 ]; ctx_avr += abs_coeffs[ 5 ][ pos ] * w_curr; w_ctx += w_curr;
}
if ( r_x >= 1 ) {
w_curr = weights[ 3 ]; ctx_avr += abs_coeffs[ 3 ][ pos ] * w_curr; w_ctx += w_curr;
}
}
else {
if ( p_x >= 2 ) {
w_curr = weights[ 4 ]; ctx_avr += abs_coeffs[ 4 ][ pos ] * w_curr; w_ctx += w_curr;
w_curr = weights[ 5 ]; ctx_avr += abs_coeffs[ 5 ][ pos ] * w_curr; w_ctx += w_curr;
}
else if ( p_x == 1 ) {
w_curr = weights[ 5 ]; ctx_avr += abs_coeffs[ 5 ][ pos ] * w_curr; w_ctx += w_curr;
}
}
// return average context
return ( w_ctx != 0 ) ? ( ctx_avr + ( w_ctx / 2 ) ) / w_ctx : 0;
}
/* -----------------------------------------------
lakhani ac context used in coeff encoding
----------------------------------------------- */
INTERN int pjg_lakh_context( signed short** coeffs_x, signed short** coeffs_a, int* pred_cf, int pos )
{
int pred = 0;
// calculate partial prediction
pred -= ( coeffs_x[ 1 ][ pos ] + coeffs_a[ 1 ][ pos ] ) * pred_cf[ 1 ];
pred -= ( coeffs_x[ 2 ][ pos ] - coeffs_a[ 2 ][ pos ] ) * pred_cf[ 2 ];
pred -= ( coeffs_x[ 3 ][ pos ] + coeffs_a[ 3 ][ pos ] ) * pred_cf[ 3 ];
pred -= ( coeffs_x[ 4 ][ pos ] - coeffs_a[ 4 ][ pos ] ) * pred_cf[ 4 ];
pred -= ( coeffs_x[ 5 ][ pos ] + coeffs_a[ 5 ][ pos ] ) * pred_cf[ 5 ];
pred -= ( coeffs_x[ 6 ][ pos ] - coeffs_a[ 6 ][ pos ] ) * pred_cf[ 6 ];
pred -= ( coeffs_x[ 7 ][ pos ] + coeffs_a[ 7 ][ pos ] ) * pred_cf[ 7 ];
// normalize / quantize partial prediction
pred = ( ( pred > 0 ) ? ( pred + (pred_cf[0]/2) ) : ( pred - (pred_cf[0]/2) ) ) / pred_cf[ 0 ];
// complete prediction
pred += coeffs_a[ 0 ][ pos ];
return pred;
}
/* -----------------------------------------------
Calculates coordinates for nearest neighbor context
----------------------------------------------- */
INTERN void get_context_nnb( int pos, int w, int *a, int *b )
{
// this function calculates and returns coordinates for
// a simple 2D context
if ( pos == 0 ) {
*a = -1;
*b = -1;
}
else if ( ( pos % w ) == 0 ) {
*b = pos - w;
if ( pos >= ( w << 1 ) )
*a = pos - ( w << 1 );
else
*a = *b;
}
else if ( pos < w ) {
*a = pos - 1;
if ( pos >= 2 )
*b = pos - 2;
else
*b = *a;
}
else {
*a = pos - 1;
*b = pos - w;
}
}
/* ----------------------- End of PJG specific functions -------------------------- */
/* ----------------------- Begin ofDCT specific functions -------------------------- */
/* -----------------------------------------------
inverse DCT transform using precalc tables (fast)
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN int idct_2d_fst_8x8( int cmp, int dpos, int ix, int iy )
{
int idct = 0;
int ixy;
// calculate start index
ixy = ( ( iy << 3 ) + ix ) << 6;
// begin transform
idct += colldata[ cmp ][ 0 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 0 ];
idct += colldata[ cmp ][ 1 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 1 ];
idct += colldata[ cmp ][ 5 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 2 ];
idct += colldata[ cmp ][ 6 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 3 ];
idct += colldata[ cmp ][ 14 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 4 ];
idct += colldata[ cmp ][ 15 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 5 ];
idct += colldata[ cmp ][ 27 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 6 ];
idct += colldata[ cmp ][ 28 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 7 ];
idct += colldata[ cmp ][ 2 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 8 ];
idct += colldata[ cmp ][ 4 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 9 ];
idct += colldata[ cmp ][ 7 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 10 ];
idct += colldata[ cmp ][ 13 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 11 ];
idct += colldata[ cmp ][ 16 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 12 ];
idct += colldata[ cmp ][ 26 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 13 ];
idct += colldata[ cmp ][ 29 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 14 ];
idct += colldata[ cmp ][ 42 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 15 ];
idct += colldata[ cmp ][ 3 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 16 ];
idct += colldata[ cmp ][ 8 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 17 ];
idct += colldata[ cmp ][ 12 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 18 ];
idct += colldata[ cmp ][ 17 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 19 ];
idct += colldata[ cmp ][ 25 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 20 ];
idct += colldata[ cmp ][ 30 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 21 ];
idct += colldata[ cmp ][ 41 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 22 ];
idct += colldata[ cmp ][ 43 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 23 ];
idct += colldata[ cmp ][ 9 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 24 ];
idct += colldata[ cmp ][ 11 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 25 ];
idct += colldata[ cmp ][ 18 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 26 ];
idct += colldata[ cmp ][ 24 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 27 ];
idct += colldata[ cmp ][ 31 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 28 ];
idct += colldata[ cmp ][ 40 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 29 ];
idct += colldata[ cmp ][ 44 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 30 ];
idct += colldata[ cmp ][ 53 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 31 ];
idct += colldata[ cmp ][ 10 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 32 ];
idct += colldata[ cmp ][ 19 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 33 ];
idct += colldata[ cmp ][ 23 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 34 ];
idct += colldata[ cmp ][ 32 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 35 ];
idct += colldata[ cmp ][ 39 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 36 ];
idct += colldata[ cmp ][ 45 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 37 ];
idct += colldata[ cmp ][ 52 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 38 ];
idct += colldata[ cmp ][ 54 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 39 ];
idct += colldata[ cmp ][ 20 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 40 ];
idct += colldata[ cmp ][ 22 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 41 ];
idct += colldata[ cmp ][ 33 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 42 ];
idct += colldata[ cmp ][ 38 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 43 ];
idct += colldata[ cmp ][ 46 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 44 ];
idct += colldata[ cmp ][ 51 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 45 ];
idct += colldata[ cmp ][ 55 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 46 ];
idct += colldata[ cmp ][ 60 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 47 ];
idct += colldata[ cmp ][ 21 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 48 ];
idct += colldata[ cmp ][ 34 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 49 ];
idct += colldata[ cmp ][ 37 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 50 ];
idct += colldata[ cmp ][ 47 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 51 ];
idct += colldata[ cmp ][ 50 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 52 ];
idct += colldata[ cmp ][ 56 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 53 ];
idct += colldata[ cmp ][ 59 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 54 ];
idct += colldata[ cmp ][ 61 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 55 ];
idct += colldata[ cmp ][ 35 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 56 ];
idct += colldata[ cmp ][ 36 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 57 ];
idct += colldata[ cmp ][ 48 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 58 ];
idct += colldata[ cmp ][ 49 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 59 ];
idct += colldata[ cmp ][ 57 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 60 ];
idct += colldata[ cmp ][ 58 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 61 ];
idct += colldata[ cmp ][ 62 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 62 ];
idct += colldata[ cmp ][ 63 ][ dpos ] * adpt_idct_8x8[ cmp ][ ixy + 63 ];
return idct;
}
#endif
/* -----------------------------------------------
inverse DCT transform using precalc tables (fast)
----------------------------------------------- */
INTERN int idct_2d_fst_8x1( int cmp, int dpos, int ix, int iy )
{
int idct = 0;
int ixy;
// calculate start index
ixy = ix << 3;
// begin transform
idct += colldata[ cmp ][ 0 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 0 ];
idct += colldata[ cmp ][ 1 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 1 ];
idct += colldata[ cmp ][ 5 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 2 ];
idct += colldata[ cmp ][ 6 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 3 ];
idct += colldata[ cmp ][ 14 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 4 ];
idct += colldata[ cmp ][ 15 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 5 ];
idct += colldata[ cmp ][ 27 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 6 ];
idct += colldata[ cmp ][ 28 ][ dpos ] * adpt_idct_8x1[ cmp ][ ixy + 7 ];
return idct;
}
/* -----------------------------------------------
inverse DCT transform using precalc tables (fast)
----------------------------------------------- */
INTERN int idct_2d_fst_1x8( int cmp, int dpos, int ix, int iy )
{
int idct = 0;
int ixy;
// calculate start index
ixy = iy << 3;
// begin transform
idct += colldata[ cmp ][ 0 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 0 ];
idct += colldata[ cmp ][ 2 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 1 ];
idct += colldata[ cmp ][ 3 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 2 ];
idct += colldata[ cmp ][ 9 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 3 ];
idct += colldata[ cmp ][ 10 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 4 ];
idct += colldata[ cmp ][ 20 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 5 ];
idct += colldata[ cmp ][ 21 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 6 ];
idct += colldata[ cmp ][ 35 ][ dpos ] * adpt_idct_1x8[ cmp ][ ixy + 7 ];
return idct;
}
/* ----------------------- End of DCT specific functions -------------------------- */
/* ----------------------- Begin of prediction functions -------------------------- */
/* -----------------------------------------------
returns predictor for collection data
----------------------------------------------- */
#if defined(USE_PLOCOI)
INTERN int dc_coll_predictor( int cmp, int dpos )
{
signed short* coefs = colldata[ cmp ][ 0 ];
int w = cmpnfo[cmp].bch;
int a, b, c;
if ( dpos < w ) {
a = coefs[ dpos - 1 ];
b = 0;
c = 0;
}
else if ( (dpos%w) == 0 ) {
a = 0;
b = coefs[ dpos - w ];
c = 0;
}
else {
a = coefs[ dpos - 1 ];
b = coefs[ dpos - w ];
c = coefs[ dpos - 1 - w ];
}
return plocoi( a, b, c );
}
#endif
/* -----------------------------------------------
1D DCT predictor for DC coefficients
----------------------------------------------- */
#if !defined(USE_PLOCOI)
INTERN int dc_1ddct_predictor( int cmp, int dpos )
{
int w = cmpnfo[cmp].bch;
int px = ( dpos % w );
int py = ( dpos / w );
int pred;
int pa = 0;
int pb = 0;
int xa = 0;
int xb = 0;
int swap;
// store current block DC coefficient
swap = colldata[ cmp ][ 0 ][ dpos ];
colldata[ cmp ][ 0 ][ dpos ] = 0;
// calculate prediction
if ( ( px > 0 ) && ( py > 0 ) ) {
pa = idct_2d_fst_8x1( cmp, dpos - 1, 7, 0 );
pb = idct_2d_fst_1x8( cmp, dpos - w, 0, 7 );
xa = idct_2d_fst_8x1( cmp, dpos, 0, 0 );
xb = idct_2d_fst_1x8( cmp, dpos, 0, 0 );
pred = ( ( pa - xa ) + ( pb - xb ) ) * ( 8 / 2 );
}
else if ( px > 0 ) {
pa = idct_2d_fst_8x1( cmp, dpos - 1, 7, 0 );
xa = idct_2d_fst_8x1( cmp, dpos, 0, 0 );
pred = ( pa - xa ) * 8;
}
else if ( py > 0 ) {
pb = idct_2d_fst_1x8( cmp, dpos - w, 0, 7 );
xb = idct_2d_fst_1x8( cmp, dpos, 0, 0 );
pred = ( pb - xb ) * 8;
}
else {
pred = 0;
}
// write back current DCT coefficient
colldata[ cmp ][ 0 ][ dpos ] = swap;
// clamp and quantize predictor
pred = CLAMPED( -( 1024 * DCT_RSC_FACTOR ), ( 1016 * DCT_RSC_FACTOR ), pred );
pred = pred / QUANT( cmp, 0 );
pred = DCT_RESCALE( pred );
return pred;
}
#endif
/* -----------------------------------------------
loco-i predictor
----------------------------------------------- */
INTERN inline int plocoi( int a, int b, int c )
{
// a -> left; b -> above; c -> above-left
int min, max;
min = ( a < b ) ? a : b;
max = ( a > b ) ? a : b;
if ( c >= max ) return min;
if ( c <= min ) return max;
return a + b - c;
}
/* -----------------------------------------------
calculates median out of an integer array
----------------------------------------------- */
INTERN inline int median_int( int* values, int size )
{
int middle = ( size >> 1 );
bool done;
int swap;
int i;
// sort data first
done = false;
while ( !done ) {
done = true;
for ( i = 1; i < size; i++ )
if ( values[ i ] < values[ i - 1 ] ) {
swap = values[ i ];
values[ i ] = values[ i - 1 ];
values[ i - 1 ] = swap;
done = false;
}
}
// return median
return ( ( size % 2 ) == 0 ) ?
( values[ middle ] + values[ middle - 1 ] ) / 2 : values[ middle ];
}
/* -----------------------------------------------
calculates median out of an float array
----------------------------------------------- */
INTERN inline float median_float( float* values, int size )
{
int middle = ( size >> 1 );
bool done;
float swap;
int i;
// sort data first
done = false;
while ( !done ) {
done = true;
for ( i = 1; i < size; i++ )
if ( values[ i ] < values[ i - 1 ] ) {
swap = values[ i ];
values[ i ] = values[ i - 1 ];
values[ i - 1 ] = swap;
done = false;
}
}
// return median
if ( ( size % 2 ) == 0 ) {
return ( values[ middle ] + values[ middle - 1 ] ) / 2.0;
}
else
return ( values[ middle ] );
}
/* ----------------------- End of prediction functions -------------------------- */
/* ----------------------- Begin of miscellaneous helper functions -------------------------- */
/* -----------------------------------------------
displays progress bar on screen
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN inline void progress_bar( int current, int last )
{
int barpos = ( ( current * BARLEN ) + ( last / 2 ) ) / last;
int i;
// generate progress bar
fprintf( msgout, "[" );
#if defined(_WIN32)
for ( i = 0; i < barpos; i++ )
fprintf( msgout, "\xFE" );
#else
for ( i = 0; i < barpos; i++ )
fprintf( msgout, "X" );
#endif
for ( ; i < BARLEN; i++ )
fprintf( msgout, " " );
fprintf( msgout, "]" );
}
#endif
/* -----------------------------------------------
creates filename, callocs memory for it
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN inline char* create_filename( const char* base, const char* extension )
{
int len = strlen( base ) + ( ( extension == NULL ) ? 0 : strlen( extension ) + 1 ) + 1;
char* filename = (char*) calloc( len, sizeof( char ) );
// create a filename from base & extension
strcpy( filename, base );
set_extension( filename, extension );
return filename;
}
#endif
/* -----------------------------------------------
creates filename, callocs memory for it
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN inline char* unique_filename( const char* base, const char* extension )
{
int len = strlen( base ) + ( ( extension == NULL ) ? 0 : strlen( extension ) + 1 ) + 1;
char* filename = (char*) calloc( len, sizeof( char ) );
// create a unique filename using underscores
strcpy( filename, base );
set_extension( filename, extension );
while ( file_exists( filename ) ) {
len += sizeof( char );
filename = (char*) realloc( filename, len );
add_underscore( filename );
}
return filename;
}
#endif
/* -----------------------------------------------
changes extension of filename
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN inline void set_extension( char* filename, const char* extension )
{
char* extstr;
// find position of extension in filename
extstr = ( strrchr( filename, '.' ) == NULL ) ?
strrchr( filename, '\0' ) : strrchr( filename, '.' );
// set new extension
if ( extension != NULL ) {
(*extstr++) = '.';
strcpy( extstr, extension );
}
else
(*extstr) = '\0';
}
#endif
/* -----------------------------------------------
adds underscore after filename
----------------------------------------------- */
#if !defined(BUILD_LIB)
INTERN inline void add_underscore( char* filename )
{
char* tmpname = (char*) calloc( strlen( filename ) + 1, sizeof( char ) );
char* extstr;
// copy filename to tmpname
strcpy( tmpname, filename );
// search extension in filename
extstr = strrchr( filename, '.' );
// add underscore before extension
if ( extstr != NULL ) {
(*extstr++) = '_';
strcpy( extstr, strrchr( tmpname, '.' ) );
}
else
sprintf( filename, "%s_", tmpname );
// free memory
free( tmpname );
}
#endif
/* -----------------------------------------------
checks if a file exists
----------------------------------------------- */
INTERN inline bool file_exists( const char* filename )
{
// needed for both, executable and library
FILE* fp = fopen( filename, "rb" );
if ( fp == NULL ) return false;
else {
fclose( fp );
return true;
}
}
/* ----------------------- End of miscellaneous helper functions -------------------------- */
/* ----------------------- Begin of developers functions -------------------------- */
/* -----------------------------------------------
Writes header file
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_hdr( void )
{
const char* ext = "hdr";
const char* basename = filelist[ file_no ];
if ( !dump_file( basename, ext, hdrdata, 1, hdrs ) )
return false;
return true;
}
#endif
/* -----------------------------------------------
Writes huffman coded file
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_huf( void )
{
const char* ext = "huf";
const char* basename = filelist[ file_no ];
if ( !dump_file( basename, ext, huffdata, 1, hufs ) )
return false;
return true;
}
#endif
/* -----------------------------------------------
Writes collections of DCT coefficients
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_coll( void )
{
FILE* fp;
char* fn;
const char* ext[ 4 ];
const char* base;
int cmp, bpos, dpos;
int i, j;
ext[0] = "coll0";
ext[1] = "coll1";
ext[2] = "coll2";
ext[3] = "coll3";
base = filelist[ file_no ];
for ( cmp = 0; cmp < cmpc; cmp++ ) {
// create filename
fn = create_filename( base, ext[ cmp ] );
// open file for output
fp = fopen( fn, "wb" );
if ( fp == NULL ){
sprintf( errormessage, FWR_ERRMSG, fn);
errorlevel = 2;
return false;
}
free( fn );
switch ( collmode ) {
case 0: // standard collections
for ( bpos = 0; bpos < 64; bpos++ )
fwrite( colldata[cmp][bpos], sizeof( short ), cmpnfo[cmp].bc, fp );
break;
case 1: // sequential order collections, 'dhufs'
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ )
for ( bpos = 0; bpos < 64; bpos++ )
fwrite( &(colldata[cmp][bpos][dpos]), sizeof( short ), 1, fp );
break;
case 2: // square collections
dpos = 0;
for ( i = 0; i < 64; ) {
bpos = zigzag[ i++ ];
fwrite( &(colldata[cmp][bpos][dpos]), sizeof( short ),
cmpnfo[cmp].bch, fp );
if ( ( i % 8 ) == 0 ) {
dpos += cmpnfo[cmp].bch;
if ( dpos >= cmpnfo[cmp].bc ) {
dpos = 0;
}
else {
i -= 8;
}
}
}
break;
case 3: // uncollections
for ( i = 0; i < ( cmpnfo[cmp].bcv * 8 ); i++ )
for ( j = 0; j < ( cmpnfo[cmp].bch * 8 ); j++ ) {
bpos = zigzag[ ( ( i % 8 ) * 8 ) + ( j % 8 ) ];
dpos = ( ( i / 8 ) * cmpnfo[cmp].bch ) + ( j / 8 );
fwrite( &(colldata[cmp][bpos][dpos]), sizeof( short ), 1, fp );
}
break;
case 4: // square collections / alt order (even/uneven)
dpos = 0;
for ( i = 0; i < 64; ) {
bpos = even_zigzag[ i++ ];
fwrite( &(colldata[cmp][bpos][dpos]), sizeof( short ),
cmpnfo[cmp].bch, fp );
if ( ( i % 8 ) == 0 ) {
dpos += cmpnfo[cmp].bch;
if ( dpos >= cmpnfo[cmp].bc ) {
dpos = 0;
}
else {
i -= 8;
}
}
}
break;
case 5: // uncollections / alt order (even/uneven)
for ( i = 0; i < ( cmpnfo[cmp].bcv * 8 ); i++ )
for ( j = 0; j < ( cmpnfo[cmp].bch * 8 ); j++ ) {
bpos = even_zigzag[ ( ( i % 8 ) * 8 ) + ( j % 8 ) ];
dpos = ( ( i / 8 ) * cmpnfo[cmp].bch ) + ( j / 8 );
fwrite( &(colldata[cmp][bpos][dpos]), sizeof( short ), 1, fp );
}
break;
}
fclose( fp );
}
return true;
}
#endif
/* -----------------------------------------------
Writes zero distribution data to file;
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_zdst( void )
{
const char* ext[4];
const char* basename;
int cmp;
ext[0] = "zdst0";
ext[1] = "zdst1";
ext[2] = "zdst2";
ext[3] = "zdst3";
basename = filelist[ file_no ];
for ( cmp = 0; cmp < cmpc; cmp++ )
if ( !dump_file( basename, ext[cmp], zdstdata[cmp], 1, cmpnfo[cmp].bc ) )
return false;
return true;
}
#endif
/* -----------------------------------------------
Writes to file
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_file( const char* base, const char* ext, void* data, int bpv, int size )
{
FILE* fp;
char* fn;
// create filename
fn = create_filename( base, ext );
// open file for output
fp = fopen( fn, "wb" );
if ( fp == NULL ) {
sprintf( errormessage, FWR_ERRMSG, fn);
errorlevel = 2;
return false;
}
free( fn );
// write & close
fwrite( data, bpv, size, fp );
fclose( fp );
return true;
}
#endif
/* -----------------------------------------------
Writes error info file
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_errfile( void )
{
FILE* fp;
char* fn;
// return immediately if theres no error
if ( errorlevel == 0 ) return true;
// create filename based on errorlevel
if ( errorlevel == 1 ) {
fn = create_filename( filelist[ file_no ], "wrn.nfo" );
}
else {
fn = create_filename( filelist[ file_no ], "err.nfo" );
}
// open file for output
fp = fopen( fn, "w" );
if ( fp == NULL ){
sprintf( errormessage, FWR_ERRMSG, fn);
errorlevel = 2;
return false;
}
free( fn );
// write status and errormessage to file
fprintf( fp, "--> error (level %i) in file \"%s\" <--\n", errorlevel, filelist[ file_no ] );
fprintf( fp, "\n" );
// write error specification to file
fprintf( fp, " %s -> %s:\n", get_status( errorfunction ),
( errorlevel == 1 ) ? "warning" : "error" );
fprintf( fp, " %s\n", errormessage );
// done, close file
fclose( fp );
return true;
}
#endif
/* -----------------------------------------------
Writes info to textfile
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_info( void )
{
FILE* fp;
char* fn;
unsigned char type = 0x00; // type of current marker segment
unsigned int len = 0; // length of current marker segment
unsigned int hpos = 0; // position in header
int cmp, bpos;
int i;
// create filename
fn = create_filename( filelist[ file_no ], "nfo" );
// open file for output
fp = fopen( fn, "w" );
if ( fp == NULL ){
sprintf( errormessage, FWR_ERRMSG, fn);
errorlevel = 2;
return false;
}
free( fn );
// info about image
fprintf( fp, "<Infofile for JPEG image %s>\n\n\n", jpgfilename );
fprintf( fp, "coding process: %s\n", ( jpegtype == 1 ) ? "sequential" : "progressive" );
// fprintf( fp, "no of scans: %i\n", scnc );
fprintf( fp, "imageheight: %i / imagewidth: %i\n", imgheight, imgwidth );
fprintf( fp, "component count: %i\n", cmpc );
fprintf( fp, "mcu count: %i/%i/%i (all/v/h)\n\n", mcuc, mcuv, mcuh );
// info about header
fprintf( fp, "\nfile header structure:\n" );
fprintf( fp, " type length hpos\n" );
// header parser loop
for ( hpos = 0; (int) hpos < hdrs; hpos += len ) {
type = hdrdata[ hpos + 1 ];
len = 2 + B_SHORT( hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ] );
fprintf( fp, " FF%2X %6i %6i\n", type, len, hpos );
}
fprintf( fp, " _END 0 %6i\n", hpos );
fprintf( fp, "\n" );
// info about compression settings
fprintf( fp, "\ncompression settings:\n" );
fprintf( fp, " no of segments -> %3i[0] %3i[1] %3i[2] %3i[3]\n",
segm_cnt[0], segm_cnt[1], segm_cnt[2], segm_cnt[3] );
fprintf( fp, " noise threshold -> %3i[0] %3i[1] %3i[2] %3i[3]\n",
nois_trs[0], nois_trs[1], nois_trs[2], nois_trs[3] );
fprintf( fp, "\n" );
// info about components
for ( cmp = 0; cmp < cmpc; cmp++ ) {
fprintf( fp, "\n" );
fprintf( fp, "component number %i ->\n", cmp );
fprintf( fp, "sample factors: %i/%i (v/h)\n", cmpnfo[cmp].sfv, cmpnfo[cmp].sfh );
fprintf( fp, "blocks per mcu: %i\n", cmpnfo[cmp].mbs );
fprintf( fp, "block count (mcu): %i/%i/%i (all/v/h)\n",
cmpnfo[cmp].bc, cmpnfo[cmp].bcv, cmpnfo[cmp].bch );
fprintf( fp, "block count (sng): %i/%i/%i (all/v/h)\n",
cmpnfo[cmp].nc, cmpnfo[cmp].ncv, cmpnfo[cmp].nch );
fprintf( fp, "quantiser table ->" );
for ( i = 0; i < 64; i++ ) {
bpos = zigzag[ i ];
if ( ( i % 8 ) == 0 ) fprintf( fp, "\n" );
fprintf( fp, "%4i, ", QUANT( cmp, bpos ) );
}
fprintf( fp, "\n" );
fprintf( fp, "maximum values ->" );
for ( i = 0; i < 64; i++ ) {
bpos = zigzag[ i ];
if ( ( i % 8 ) == 0 ) fprintf( fp, "\n" );
fprintf( fp, "%4i, ", MAX_V( cmp, bpos ) );
}
fprintf( fp, "\n\n" );
}
fclose( fp );
return true;
}
#endif
/* -----------------------------------------------
Writes distribution for use in valdist.h
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_dist( void )
{
FILE* fp;
char* fn;
unsigned int dist[ 1024 + 1 ];
int cmp, bpos, dpos;
int i;
// create filename
fn = create_filename( filelist[ file_no ], "dist" );
// open file for output
fp = fopen( fn, "wb" );
free( fn );
if ( fp == NULL ){
sprintf( errormessage, FWR_ERRMSG, fn);
errorlevel = 2;
return false;
}
// calculate & write distributions for each frequency
for ( cmp = 0; cmp < cmpc; cmp++ )
for ( bpos = 0; bpos < 64; bpos++ ) {
// preset dist with zeroes
for ( i = 0; i <= 1024; i++ ) dist[ i ] = 0;
// get distribution
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ )
dist[ ABS( colldata[cmp][bpos][dpos] ) ]++;
// write to file
fwrite( dist, sizeof( int ), 1024 + 1, fp );
}
// close file
fclose( fp );
return true;
}
#endif
/* -----------------------------------------------
Do inverse DCT and write pgms
----------------------------------------------- */
#if !defined(BUILD_LIB) && defined(DEV_BUILD)
INTERN bool dump_pgm( void )
{
unsigned char* imgdata;
FILE* fp;
char* fn;
const char* ext[4];
int cmp, dpos;
int pix_v;
int xpos, ypos, dcpos;
int x, y;
ext[0] = "cmp0.pgm";
ext[1] = "cmp1.pgm";
ext[2] = "cmp2.pgm";
ext[3] = "cmp3.pgm";
for ( cmp = 0; cmp < cmpc; cmp++ )
{
// create filename
fn = create_filename( filelist[ file_no ], ext[ cmp ] );
// open file for output
fp = fopen( fn, "wb" );
if ( fp == NULL ){
sprintf( errormessage, FWR_ERRMSG, fn );
errorlevel = 2;
return false;
}
free( fn );
// alloc memory for image data
imgdata = (unsigned char*) calloc ( cmpnfo[cmp].bc * 64, sizeof( char ) );
if ( imgdata == NULL ) {
sprintf( errormessage, MEM_ERRMSG );
errorlevel = 2;
return false;
}
for ( dpos = 0; dpos < cmpnfo[cmp].bc; dpos++ ) {
// do inverse DCT, store in imgdata
dcpos = ( ( ( dpos / cmpnfo[cmp].bch ) * cmpnfo[cmp].bch ) << 6 ) +
( ( dpos % cmpnfo[cmp].bch ) << 3 );
for ( y = 0; y < 8; y++ ) {
ypos = dcpos + ( y * ( cmpnfo[cmp].bch << 3 ) );
for ( x = 0; x < 8; x++ ) {
xpos = ypos + x;
pix_v = idct_2d_fst_8x8( cmp, dpos, x, y );
pix_v = DCT_RESCALE( pix_v );
pix_v = pix_v + 128;
imgdata[ xpos ] = ( unsigned char ) CLAMPED( 0, 255, pix_v );
}
}
}
// write PGM header
fprintf( fp, "P5\n" );
fprintf( fp, "# created by %s v%i.%i%s (%s) by %s\n",
apptitle, appversion / 10, appversion % 10, subversion, versiondate, author );
fprintf( fp, "%i %i\n", cmpnfo[cmp].bch * 8, cmpnfo[cmp].bcv * 8 );
fprintf( fp, "255\n" );
// write image data
fwrite( imgdata, sizeof( char ), cmpnfo[cmp].bc * 64, fp );
// free memory
free( imgdata );
// close file
fclose( fp );
}
return true;
}
#endif
/* ----------------------- End of developers functions -------------------------- */
/* ----------------------- End of file -------------------------- */