commit 073c5385a78c940edf83a12087a39d51456112d0 Author: David Sorber Date: Tue Jul 10 20:20:32 2018 -0400 WIP for libpackjpg reorganization: moved all main interface and main functions inside the wrapper class diff --git a/software/packJPG_library/lib_src/packjpg.cpp b/software/packJPG_library/lib_src/packjpg.cpp index 6c87999..9946ea0 100644 --- a/software/packJPG_library/lib_src/packjpg.cpp +++ b/software/packJPG_library/lib_src/packjpg.cpp @@ -296,7 +296,7 @@ packJPG by Matthias Stirner, 01/2016 // #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 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 ) @@ -322,7 +322,7 @@ packJPG by Matthias Stirner, 01/2016 static inline void* frealloc(void* ptr, size_t size) { void* n_ptr = realloc(ptr, (size) ? size : 1); - if (n_ptr == NULL) + if (n_ptr == nullptr) { free(ptr); } @@ -462,13 +462,13 @@ inline float median_float(float* values, int size); #if defined(DEV_INFOS) int dev_size_hdr = 0; -int dev_size_cmp[ 4 ] = { 0 }; -int dev_size_zsr[ 4 ] = { 0 }; -int dev_size_dc[ 4 ] = { 0 }; -int dev_size_ach[ 4 ] = { 0 }; -int dev_size_acl[ 4 ] = { 0 }; -int dev_size_zdh[ 4 ] = { 0 }; -int dev_size_zdl[ 4 ] = { 0 }; +int dev_size_cmp[4] = { 0 }; +int dev_size_zsr[4] = { 0 }; +int dev_size_dc[4] = { 0 }; +int dev_size_ach[4] = { 0 }; +int dev_size_acl[4] = { 0 }; +int dev_size_zdh[4] = { 0 }; +int dev_size_zdl[4] = { 0 }; #endif @@ -571,47 +571,43 @@ const char* packJPG::pjglib_short_name(void) return (const char*) v_name; } -#if 0 - - /* ----------------------- Begin of library only functions -------------------------- */ /* ----------------------------------------------- DLL export converter function ----------------------------------------------- */ - -bool pjglib_convert_stream2stream(char* msg) +bool packJPG::pjglib_convert_stream2stream(char* msg) { // process in main function - return pjglib_convert_stream2mem(NULL, NULL, msg); + return pjglib_convert_stream2mem(nullptr, nullptr, msg); } /* ----------------------------------------------- DLL export converter function ----------------------------------------------- */ - -bool pjglib_convert_file2file(char* in, char* out, char* msg) +bool packJPG::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); + return pjglib_convert_stream2mem(nullptr, nullptr, msg); } /* ----------------------------------------------- DLL export converter function ----------------------------------------------- */ - -bool pjglib_convert_stream2mem(unsigned char** out_file, unsigned int* out_size, char* msg) +bool packJPG::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; @@ -627,7 +623,7 @@ bool pjglib_convert_stream2mem(unsigned char** out_file, unsigned int* out_size, // 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_file != nullptr) && (out_size != nullptr)) { *out_size = str_out->num_bytes_written(); *out_file = str_out->get_c_data(); @@ -659,7 +655,7 @@ bool pjglib_convert_stream2mem(unsigned char** out_file, unsigned int* out_size, } } } - if (msg != NULL) + if (msg != nullptr) { strcpy(msg, errormessage); } @@ -671,7 +667,7 @@ bool pjglib_convert_stream2mem(unsigned char** out_file, unsigned int* out_size, cr = (jpgfilesize > 0) ? (100.0 * pjgfilesize / jpgfilesize) : 0; // write success message else - if (msg != NULL) + if (msg != nullptr) { switch (filetype) { @@ -697,8 +693,12 @@ bool pjglib_convert_stream2mem(unsigned char** out_file, unsigned int* out_size, /* ----------------------------------------------- DLL export init input (file/mem) ----------------------------------------------- */ - -void pjglib_init_streams(void* in_src, int in_type, int in_size, void* out_dest, int out_type) +void packJPG::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: @@ -722,10 +722,10 @@ void pjglib_init_streams(void* in_src, int in_type, int in_size, void* out_dest, vice versa for output streams! */ - unsigned char buffer[ 2 ]; + unsigned char buffer[2]; // (re)set errorlevel - errorfunction = NULL; + errorfunction = nullptr; errorlevel = 0; jpgfilesize = 0; pjgfilesize = 0; @@ -849,54 +849,27 @@ void pjglib_init_streams(void* in_src, int in_type, int in_size, void* out_dest, lib_out_type = out_type; } - /* ----------------------- End of libary only functions -------------------------- */ /* ----------------------- Begin of main interface functions -------------------------- */ - -/* ----------------------------------------------- - reads in commandline arguments - ----------------------------------------------- */ - - - -/* ----------------------------------------------- - UI for processing one file - ----------------------------------------------- */ - - - -/* ----------------------------------------------- - gets statusmessage for function - ----------------------------------------------- */ - - - -/* ----------------------------------------------- - shows help in case of wrong input - ----------------------------------------------- */ - - - /* ----------------------------------------------- processes one file ----------------------------------------------- */ - -void process_file(void) +void packJPG::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); + read_jpeg(); + decode_jpeg(); + check_value_range(); + adapt_icos(); + predict_dc(); + calc_zdst_lists(); + pack_pjg(); break; default: @@ -908,27 +881,26 @@ void process_file(void) switch (action) { case A_COMPRESS: - execute(unpack_pjg); - execute(adapt_icos); - execute(unpredict_dc); - execute(recode_jpeg); - execute(merge_jpeg); + unpack_pjg(); + adapt_icos(); + unpredict_dc(); + recode_jpeg(); + merge_jpeg(); break; default: break; } } + // reset buffers reset_buffers(); } - /* ----------------------------------------------- main-function execution routine ----------------------------------------------- */ - -void execute(bool (*function)()) +void packJPG::execute(bool (*function)()) { if (errorlevel < err_tol) { @@ -936,7 +908,7 @@ void execute(bool (*function)()) (*function)(); // store errorfunction if needed - if ((errorlevel > 0) && (errorfunction == NULL)) + if ((errorlevel > 0) && (errorfunction == nullptr)) { errorfunction = function; } @@ -948,128 +920,107 @@ void execute(bool (*function)()) /* ----------------------- Begin of main functions -------------------------- */ -/* ----------------------------------------------- - check file and determine filetype - ----------------------------------------------- */ - - - -/* ----------------------------------------------- - swap streams / init verification - ----------------------------------------------- */ - - - -/* ----------------------------------------------- - comparison between input & output - ----------------------------------------------- */ - - - /* ----------------------------------------------- set each variable to its initial value ----------------------------------------------- */ - -bool reset_buffers(void) +bool packJPG::reset_buffers(void) { int cmp, bpos; int i; - // -- free buffers -- - // free buffers & set pointers NULL - if (hdrdata != NULL) + // free buffers & set pointers nullptr + if (hdrdata != nullptr) { free(hdrdata); } - if (huffdata != NULL) + if (huffdata != nullptr) { free(huffdata); } - if (grbgdata != NULL) + if (grbgdata != nullptr) { free(grbgdata); } - if (rst_err != NULL) + if (rst_err != nullptr) { free(rst_err); } - if (rstp != NULL) + if (rstp != nullptr) { free(rstp); } - if (scnp != NULL) + if (scnp != nullptr) { free(scnp); } - hdrdata = NULL; - huffdata = NULL; - grbgdata = NULL; - rst_err = NULL; - rstp = NULL; - scnp = NULL; + hdrdata = nullptr; + huffdata = nullptr; + grbgdata = nullptr; + rst_err = nullptr; + rstp = nullptr; + scnp = nullptr; // free image arrays for (cmp = 0; cmp < 4; cmp++) { - if (zdstdata[ cmp ] != NULL) + if (zdstdata[cmp] != nullptr) { free(zdstdata[cmp]); } - if (eobxhigh[ cmp ] != NULL) + if (eobxhigh[cmp] != nullptr) { free(eobxhigh[cmp]); } - if (eobyhigh[ cmp ] != NULL) + if (eobyhigh[cmp] != nullptr) { free(eobyhigh[cmp]); } - if (zdstxlow[ cmp ] != NULL) + if (zdstxlow[cmp] != nullptr) { free(zdstxlow[cmp]); } - if (zdstylow[ cmp ] != NULL) + if (zdstylow[cmp] != nullptr) { free(zdstylow[cmp]); } - zdstdata[ cmp ] = NULL; - eobxhigh[ cmp ] = NULL; - eobyhigh[ cmp ] = NULL; - zdstxlow[ cmp ] = NULL; - zdstylow[ cmp ] = NULL; - freqscan[ cmp ] = (unsigned char*) stdscan; + zdstdata[cmp] = nullptr; + eobxhigh[cmp] = nullptr; + eobyhigh[cmp] = nullptr; + zdstxlow[cmp] = nullptr; + zdstylow[cmp] = nullptr; + freqscan[cmp] = (unsigned char*) stdscan; for (bpos = 0; bpos < 64; bpos++) { - if (colldata[ cmp ][ bpos ] != NULL) + if (colldata[cmp][bpos] != nullptr) { free(colldata[cmp][bpos]); } - colldata[ cmp ][ bpos ] = NULL; + colldata[cmp][bpos] = nullptr; } } - // -- 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; + 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 = nullptr; + cmpnfo[cmp].huffdc = -1; + cmpnfo[cmp].huffac = -1; } // preset imgwidth / imgheight / component count @@ -1088,11 +1039,11 @@ bool reset_buffers(void) // reset quantization / huffman tables for (i = 0; i < 4; i++) { - htset[ 0 ][ i ] = 0; - htset[ 1 ][ i ] = 0; + htset[0][i] = 0; + htset[1][i] = 0; for (bpos = 0; bpos < 64; bpos++) { - qtables[ i ][ bpos ] = 0; + qtables[i][bpos] = 0; } } @@ -1102,18 +1053,15 @@ bool reset_buffers(void) // reset padbit padbit = -1; - return true; } - /* ----------------------------------------------- Read in header & image data ----------------------------------------------- */ - -bool read_jpeg(void) +bool packJPG::read_jpeg(void) { - unsigned char* segment = NULL; // storage for current segment + unsigned char* segment = nullptr; // 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 @@ -1125,7 +1073,6 @@ bool read_jpeg(void) MemoryWriter* hdrw; MemoryWriter* grbgw; - // preset count of scans scnc = 0; @@ -1139,7 +1086,7 @@ bool read_jpeg(void) // alloc memory for segment data first segment = (unsigned char*) calloc(ssize, sizeof(char)); - if (segment == NULL) + if (segment == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -1200,10 +1147,10 @@ bool read_jpeg(void) // store number of wrongly set rst markers if (crst > 0) { - if (rst_err == NULL) + if (rst_err == nullptr) { rst_err = (unsigned char*) calloc(scnc + 1, sizeof(char)); - if (rst_err == NULL) + if (rst_err == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -1211,11 +1158,11 @@ bool read_jpeg(void) } } } - if (rst_err != NULL) + if (rst_err != nullptr) { // realloc and set only if needed rst_err = (unsigned char*) frealloc(rst_err, (scnc + 1) * sizeof(char)); - if (rst_err == NULL) + if (rst_err == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -1227,13 +1174,13 @@ bool read_jpeg(void) errorlevel = 1; crst = 255; } - rst_err[ scnc ] = crst; + rst_err[scnc] = crst; } // end of current scan scnc++; // on with the header parser routines - segment[ 0 ] = 0xFF; - segment[ 1 ] = tmp; + segment[0] = 0xFF; + segment[1] = tmp; break; } } @@ -1251,7 +1198,7 @@ bool read_jpeg(void) { break; } - if (segment[ 0 ] != 0xFF) + if (segment[0] != 0xFF) { // ugly fix for incorrect marker segment sizes sprintf(errormessage, "size mismatch in marker segment FF %2X", type); @@ -1262,7 +1209,7 @@ bool read_jpeg(void) { break; } - if (segment[ 0 ] == 0xFF) + if (segment[0] == 0xFF) { errorlevel = 1; } @@ -1278,7 +1225,7 @@ bool read_jpeg(void) } // read segment type - type = segment[ 1 ]; + type = segment[1]; // if EOI is encountered make a quick exit if (type == 0xD9) @@ -1298,7 +1245,7 @@ bool read_jpeg(void) { break; } - len = 2 + B_SHORT(segment[ 2 ], segment[ 3 ]); + len = 2 + B_SHORT(segment[2], segment[3]); if (len < 4) { break; @@ -1308,7 +1255,7 @@ bool read_jpeg(void) if (ssize < len) { segment = (unsigned char*) frealloc(segment, len); - if (segment == NULL) + if (segment == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -1330,8 +1277,8 @@ bool read_jpeg(void) // JPEG reader loop end // free writers - delete (hdrw); - delete (huffw); + delete hdrw; + delete huffw; // check if everything went OK if ((hdrs == 0) || (hufs == 0)) @@ -1377,15 +1324,13 @@ bool read_jpeg(void) return true; } - /* ----------------------------------------------- Merges header & image data to jpeg ----------------------------------------------- */ - -bool merge_jpeg(void) +bool packJPG::merge_jpeg(void) { - unsigned char SOI[ 2 ] = { 0xFF, 0xD8 }; // SOI segment - unsigned char EOI[ 2 ] = { 0xFF, 0xD9 }; // EOI segment + 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 @@ -1399,7 +1344,6 @@ bool merge_jpeg(void) unsigned int scan = 1; // number of current scan unsigned int tmp; // temporary storage variable - // write SOI str_out->write(SOI, 2); @@ -1416,8 +1360,8 @@ bool merge_jpeg(void) { break; } - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + type = hdrdata[hpos + 1]; + len = 2 + B_SHORT(hdrdata[hpos + 2], hdrdata[hpos + 3]); hpos += len; } @@ -1430,24 +1374,23 @@ bool merge_jpeg(void) break; } - // (re)set corrected rst pos cpos = 0; // write & expand huffman coded image data - for (ipos = scnp[ scan - 1 ]; ipos < scnp[ scan ]; ipos++) + for (ipos = scnp[scan - 1]; ipos < scnp[scan]; ipos++) { // write current byte str_out->write_byte(huffdata[ipos]); // check current byte, stuff if needed - if (huffdata[ ipos ] == 0xFF) + if (huffdata[ipos] == 0xFF) { str_out->write_byte(stv); } // insert restart markers if needed - if (rstp != NULL) + if (rstp != nullptr) { - if (ipos == rstp[ rpos ]) + if (ipos == rstp[rpos]) { rst = 0xD0 + (cpos % 8); str_out->write_byte(mrk); @@ -1458,15 +1401,15 @@ bool merge_jpeg(void) } } // insert false rst markers at end if needed - if (rst_err != NULL) + if (rst_err != nullptr) { - while (rst_err[ scan - 1 ] > 0) + while (rst_err[scan - 1] > 0) { rst = 0xD0 + (cpos % 8); str_out->write_byte(mrk); str_out->write_byte(rst); cpos++; - rst_err[ scan - 1 ]--; + rst_err[scan - 1]--; } } @@ -1494,16 +1437,13 @@ bool merge_jpeg(void) // get filesize jpgfilesize = str_out->num_bytes_written(); - return true; } - /* ----------------------------------------------- JPEG decoding routine ----------------------------------------------- */ - -bool decode_jpeg(void) +bool packJPG::decode_jpeg(void) { BitReader* huffr; // bitwise reader for image data @@ -1511,8 +1451,8 @@ bool decode_jpeg(void) 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 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 @@ -1521,7 +1461,6 @@ bool decode_jpeg(void) int mcu, sub, csc; int eob, sta; - // open huffman coded image data for input in BitReader huffr = new BitReader(huffdata, hufs); @@ -1538,11 +1477,11 @@ bool decode_jpeg(void) { break; } - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + 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 ]))) + if (!jpg_parse_jfif(type, len, &(hdrdata[hpos]))) { return false; } @@ -1559,9 +1498,9 @@ bool decode_jpeg(void) // 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))) + 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; @@ -1570,9 +1509,8 @@ bool decode_jpeg(void) } } - // intial variables set for decoding - cmp = cs_cmp[ 0 ]; + cmp = cs_cmp[0]; csc = 0; mcu = 0; sub = 0; @@ -1582,10 +1520,10 @@ bool decode_jpeg(void) while (true) { // (re)set last DCs for diff coding - lastdc[ 0 ] = 0; - lastdc[ 1 ] = 0; - lastdc[ 2 ] = 0; - lastdc[ 3 ] = 0; + lastdc[0] = 0; + lastdc[1] = 0; + lastdc[2] = 0; + lastdc[3] = 0; // (re)set status eob = 0; @@ -1608,25 +1546,25 @@ bool decode_jpeg(void) { // decode block eob = jpg_decode_block_seq(huffr, - &(htrees[ 0 ][ cmpnfo[cmp].huffdc ]), - &(htrees[ 1 ][ cmpnfo[cmp].huffdc ]), + &(htrees[0][cmpnfo[cmp].huffdc]), + &(htrees[1][cmpnfo[cmp].huffdc]), block); // check for non optimal coding - if ((eob > 1) && (block[ eob - 1 ] == 0)) + if ((eob > 1) && (block[eob - 1] == 0)) { sprintf(errormessage, "reconstruction of inefficient coding not supported"); errorlevel = 1; } // fix dc - block[ 0 ] += lastdc[ cmp ]; - lastdc[ cmp ] = block[ 0 ]; + block[0] += lastdc[cmp]; + lastdc[cmp] = block[0]; // copy to colldata for (bpos = 0; bpos < eob; bpos++) { - colldata[ cmp ][ bpos ][ dpos ] = block[ bpos ]; + colldata[cmp][bpos][dpos] = block[bpos]; } // check for errors, proceed if no error encountered @@ -1647,12 +1585,12 @@ bool decode_jpeg(void) while (sta == 0) { sta = jpg_decode_dc_prg_fs(huffr, - &(htrees[ 0 ][ cmpnfo[cmp].huffdc ]), + &(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]; + colldata[cmp][0][dpos] = block[0] + lastdc[cmp]; + lastdc[cmp] = colldata[cmp][0][dpos]; // bitshift for succesive approximation colldata[cmp][0][dpos] <<= cs_sal; @@ -1671,8 +1609,7 @@ bool decode_jpeg(void) while (sta == 0) { // decode next bit - sta = jpg_decode_dc_prg_sa(huffr, - block); + sta = jpg_decode_dc_prg_sa(huffr, block); // shift in next bit colldata[cmp][0][dpos] += block[0] << cs_sal; @@ -1694,25 +1631,25 @@ bool decode_jpeg(void) { // decode block eob = jpg_decode_block_seq(huffr, - &(htrees[ 0 ][ cmpnfo[cmp].huffdc ]), - &(htrees[ 1 ][ cmpnfo[cmp].huffdc ]), + &(htrees[0][cmpnfo[cmp].huffdc]), + &(htrees[1][cmpnfo[cmp].huffdc]), block); // check for non optimal coding - if ((eob > 1) && (block[ eob - 1 ] == 0)) + if ((eob > 1) && (block[eob - 1] == 0)) { sprintf(errormessage, "reconstruction of inefficient coding not supported"); errorlevel = 1; } // fix dc - block[ 0 ] += lastdc[ cmp ]; - lastdc[ cmp ] = block[ 0 ]; + block[0] += lastdc[cmp]; + lastdc[cmp] = block[0]; // copy to colldata for (bpos = 0; bpos < eob; bpos++) { - colldata[ cmp ][ bpos ][ dpos ] = block[ bpos ]; + colldata[cmp][bpos][dpos] = block[bpos]; } // check for errors, proceed if no error encountered @@ -1735,12 +1672,12 @@ bool decode_jpeg(void) while (sta == 0) { sta = jpg_decode_dc_prg_fs(huffr, - &(htrees[ 0 ][ cmpnfo[cmp].huffdc ]), + &(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]; + colldata[cmp][0][dpos] = block[0] + lastdc[cmp]; + lastdc[cmp] = colldata[cmp][0][dpos]; // bitshift for succesive approximation colldata[cmp][0][dpos] <<= cs_sal; @@ -1759,8 +1696,7 @@ bool decode_jpeg(void) while (sta == 0) { // decode next bit - sta = jpg_decode_dc_prg_sa(huffr, - block); + sta = jpg_decode_dc_prg_sa(huffr, block); // shift in next bit colldata[cmp][0][dpos] += block[0] << cs_sal; @@ -1785,14 +1721,14 @@ bool decode_jpeg(void) { // decode block eob = jpg_decode_ac_prg_fs(huffr, - &(htrees[ 1 ][ cmpnfo[cmp].huffac ]), + &(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)) + (peobrun < hcodes[1][cmpnfo[cmp].huffac].max_eobrun - 1)) { sprintf(errormessage, "reconstruction of inefficient coding not supported"); @@ -1809,7 +1745,7 @@ bool decode_jpeg(void) // copy to colldata for (bpos = cs_from; bpos < eob; bpos++) { - colldata[ cmp ][ bpos ][ dpos ] = block[ bpos ] << cs_sal; + colldata[cmp][bpos][dpos] = block[bpos] << cs_sal; } } else @@ -1843,21 +1779,21 @@ bool decode_jpeg(void) // copy from colldata for (bpos = cs_from; bpos <= cs_to; bpos++) { - block[ bpos ] = colldata[ cmp ][ bpos ][ dpos ]; + 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 ]), + &(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)) + (peobrun < hcodes[1][cmpnfo[cmp].huffac].max_eobrun - 1)) { sprintf(errormessage, "reconstruction of inefficient coding not supported"); @@ -1884,7 +1820,7 @@ bool decode_jpeg(void) // copy back to colldata for (bpos = cs_from; bpos <= cs_to; bpos++) { - colldata[ cmp ][ bpos ][ dpos ] += block[ bpos ] << cs_sal; + colldata[cmp][bpos][dpos] += block[bpos] << cs_sal; } // proceed only if no error encountered @@ -1949,18 +1885,15 @@ bool decode_jpeg(void) } // clean up - delete (huffr); - + delete huffr; return true; } - /* ----------------------------------------------- JPEG encoding routine ----------------------------------------------- */ - -bool recode_jpeg(void) +bool packJPG::recode_jpeg(void) { BitWriter* huffw; // bitwise writer for image data @@ -1968,8 +1901,8 @@ bool recode_jpeg(void) 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 lastdc[4]; // last dc for each component0 + short block[64]; // store block for coeffs int eobrun; // run of eobs int rstw; // restart wait counter @@ -1978,7 +1911,6 @@ bool recode_jpeg(void) int eob, sta; int tmp; - // open huffman coded image data in BitWriter huffw = new BitWriter(padbit); @@ -1999,11 +1931,11 @@ bool recode_jpeg(void) { break; } - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + 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 ]))) + if (!jpg_parse_jfif(type, len, &(hdrdata[hpos]))) { return false; } @@ -2022,9 +1954,8 @@ bool recode_jpeg(void) break; } - // (re)alloc scan positons array - if (scnp == NULL) + if (scnp == nullptr) { scnp = (unsigned int*) calloc(scnc + 2, sizeof(int)); } @@ -2032,7 +1963,7 @@ bool recode_jpeg(void) { scnp = (unsigned int*) frealloc(scnp, (scnc + 2) * sizeof(int)); } - if (scnp == NULL) + if (scnp == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -2043,8 +1974,8 @@ bool recode_jpeg(void) if (rsti > 0) { tmp = rstc + ((cs_cmpc > 1) ? - (mcuc / rsti) : (cmpnfo[ cs_cmp[ 0 ] ].bc / rsti)); - if (rstp == NULL) + (mcuc / rsti) : (cmpnfo[cs_cmp[0]].bc / rsti)); + if (rstp == nullptr) { rstp = (unsigned int*) calloc(tmp + 1, sizeof(int)); } @@ -2052,7 +1983,7 @@ bool recode_jpeg(void) { rstp = (unsigned int*) frealloc(rstp, (tmp + 1) * sizeof(int)); } - if (rstp == NULL) + if (rstp == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -2061,23 +1992,23 @@ bool recode_jpeg(void) } // intial variables set for encoding - cmp = cs_cmp[ 0 ]; + cmp = cs_cmp[0]; csc = 0; mcu = 0; sub = 0; dpos = 0; // store scan position - scnp[ scnc ] = huffw->num_bytes_written(); + scnp[scnc] = huffw->num_bytes_written(); // 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; + lastdc[0] = 0; + lastdc[1] = 0; + lastdc[2] = 0; + lastdc[3] = 0; // (re)set status sta = 0; @@ -2099,17 +2030,17 @@ bool recode_jpeg(void) // copy from colldata for (bpos = 0; bpos < 64; bpos++) { - block[ bpos ] = colldata[ cmp ][ bpos ][ dpos ]; + block[bpos] = colldata[cmp][bpos][dpos]; } // diff coding for dc - block[ 0 ] -= lastdc[ cmp ]; - lastdc[ cmp ] = colldata[ cmp ][ 0 ][ dpos ]; + block[0] -= lastdc[cmp]; + lastdc[cmp] = colldata[cmp][0][dpos]; // encode block eob = jpg_encode_block_seq(huffw, - &(hcodes[ 0 ][ cmpnfo[cmp].huffdc ]), - &(hcodes[ 1 ][ cmpnfo[cmp].huffac ]), + &(hcodes[0][cmpnfo[cmp].huffdc]), + &(hcodes[1][cmpnfo[cmp].huffac]), block); // check for errors, proceed if no error encountered @@ -2130,13 +2061,13 @@ bool recode_jpeg(void) while (sta == 0) { // diff coding & bitshifting for dc - tmp = colldata[ cmp ][ 0 ][ dpos ] >> cs_sal; - block[ 0 ] = tmp - lastdc[ cmp ]; - lastdc[ cmp ] = tmp; + 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 ]), + &(hcodes[0][cmpnfo[cmp].huffdc]), block); // next mcupos if no error happened @@ -2153,7 +2084,7 @@ bool recode_jpeg(void) while (sta == 0) { // fetch bit from current bitplane - block[ 0 ] = BITN(colldata[ cmp ][ 0 ][ dpos ], cs_sal); + block[0] = BITN(colldata[cmp][0][dpos], cs_sal); // encode dc correction bit sta = jpg_encode_dc_prg_sa(huffw, block); @@ -2176,17 +2107,17 @@ bool recode_jpeg(void) // copy from colldata for (bpos = 0; bpos < 64; bpos++) { - block[ bpos ] = colldata[ cmp ][ bpos ][ dpos ]; + block[bpos] = colldata[cmp][bpos][dpos]; } // diff coding for dc - block[ 0 ] -= lastdc[ cmp ]; - lastdc[ cmp ] = colldata[ cmp ][ 0 ][ dpos ]; + block[0] -= lastdc[cmp]; + lastdc[cmp] = colldata[cmp][0][dpos]; // encode block eob = jpg_encode_block_seq(huffw, - &(hcodes[ 0 ][ cmpnfo[cmp].huffdc ]), - &(hcodes[ 1 ][ cmpnfo[cmp].huffac ]), + &(hcodes[0][cmpnfo[cmp].huffdc]), + &(hcodes[1][cmpnfo[cmp].huffac]), block); // check for errors, proceed if no error encountered @@ -2209,13 +2140,13 @@ bool recode_jpeg(void) while (sta == 0) { // diff coding & bitshifting for dc - tmp = colldata[ cmp ][ 0 ][ dpos ] >> cs_sal; - block[ 0 ] = tmp - lastdc[ cmp ]; - lastdc[ cmp ] = tmp; + 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 ]), + &(hcodes[0][cmpnfo[cmp].huffdc]), block); // check for errors, increment dpos otherwise @@ -2232,7 +2163,7 @@ bool recode_jpeg(void) while (sta == 0) { // fetch bit from current bitplane - block[ 0 ] = BITN(colldata[ cmp ][ 0 ][ dpos ], cs_sal); + block[0] = BITN(colldata[cmp][0][dpos], cs_sal); // encode dc correction bit sta = jpg_encode_dc_prg_sa(huffw, block); @@ -2255,12 +2186,12 @@ bool recode_jpeg(void) { // copy from colldata for (bpos = cs_from; bpos <= cs_to; bpos++) - block[ bpos ] = - FDIV2(colldata[ cmp ][ bpos ][ dpos ], cs_sal); + block[bpos] = + FDIV2(colldata[cmp][bpos][dpos], cs_sal); // encode block eob = jpg_encode_ac_prg_fs(huffw, - &(hcodes[ 1 ][ cmpnfo[cmp].huffac ]), + &(hcodes[1][cmpnfo[cmp].huffac]), block, &eobrun, cs_from, cs_to); // check for errors, proceed if no error encountered @@ -2276,7 +2207,7 @@ bool recode_jpeg(void) // encode remaining eobrun jpg_encode_eobrun(huffw, - &(hcodes[ 1 ][ cmpnfo[cmp].huffac ]), + &(hcodes[1][cmpnfo[cmp].huffac]), &eobrun); } else @@ -2287,12 +2218,12 @@ bool recode_jpeg(void) { // copy from colldata for (bpos = cs_from; bpos <= cs_to; bpos++) - block[ bpos ] = - FDIV2(colldata[ cmp ][ bpos ][ dpos ], cs_sal); + block[bpos] = + FDIV2(colldata[cmp][bpos][dpos], cs_sal); // encode block eob = jpg_encode_ac_prg_sa(huffw, storw, - &(hcodes[ 1 ][ cmpnfo[cmp].huffac ]), + &(hcodes[1][cmpnfo[cmp].huffac]), block, &eobrun, cs_from, cs_to); // check for errors, proceed if no error encountered @@ -2308,7 +2239,7 @@ bool recode_jpeg(void) // encode remaining eobrun jpg_encode_eobrun(huffw, - &(hcodes[ 1 ][ cmpnfo[cmp].huffac ]), + &(hcodes[1][cmpnfo[cmp].huffac]), &eobrun); // encode remaining correction bits @@ -2338,7 +2269,7 @@ bool recode_jpeg(void) { if (rsti > 0) // store rstp & stay in the loop { - rstp[ rstc++ ] = huffw->num_bytes_written() - 1; + rstp[rstc++] = huffw->num_bytes_written() - 1; } } } @@ -2350,66 +2281,59 @@ bool recode_jpeg(void) delete huffw; // store last scan & restart positions - scnp[ scnc ] = hufs; - if (rstp != NULL) + scnp[scnc] = hufs; + if (rstp != nullptr) { - rstp[ rstc ] = hufs; + rstp[rstc] = hufs; } - return true; } - /* ----------------------------------------------- adapt ICOS tables for quantizer tables ----------------------------------------------- */ - -bool adapt_icos(void) +bool packJPG::adapt_icos(void) { - unsigned short quant[ 64 ]; // local copy of quantization + 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] = 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; + 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 ]; + 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 ]; + 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 ]; + adpt_idct_8x1[cmp][ipos] = icos_idct_1x8[ipos] * quant[ipos % 8]; } } - return true; } - /* ----------------------------------------------- filter DC coefficients ----------------------------------------------- */ - -bool predict_dc(void) +bool packJPG::predict_dc(void) { signed short* coef; int absmaxp; @@ -2417,7 +2341,6 @@ bool predict_dc(void) int corr_f; int cmp, dpos; - // apply prediction, store prediction error instead of DC for (cmp = 0; cmp < cmpc; cmp++) { @@ -2428,7 +2351,7 @@ bool predict_dc(void) for (dpos = cmpnfo[cmp].bc - 1; dpos > 0; dpos--) { coef = &(colldata[cmp][0][dpos]); -#if defined( USE_PLOCOI ) +#if defined(USE_PLOCOI) (*coef) -= dc_coll_predictor(cmp, dpos); // loco-i predictor #else (*coef) -= dc_1ddct_predictor(cmp, dpos); // 1d dct @@ -2449,12 +2372,10 @@ bool predict_dc(void) return true; } - /* ----------------------------------------------- unpredict DC coefficients ----------------------------------------------- */ - -bool unpredict_dc(void) +bool packJPG::unpredict_dc(void) { signed short* coef; int absmaxp; @@ -2462,7 +2383,6 @@ bool unpredict_dc(void) int corr_f; int cmp, dpos; - // remove prediction, store DC instead of prediction error for (cmp = 0; cmp < cmpc; cmp++) { @@ -2491,16 +2411,13 @@ bool unpredict_dc(void) } } - return true; } - /* ----------------------------------------------- checks range of values, error if out of bounds ----------------------------------------------- */ - -bool check_value_range(void) +bool packJPG::check_value_range(void) { int absmax; int cmp, bpos, dpos; @@ -2521,21 +2438,17 @@ bool check_value_range(void) } } - return true; } - /* ----------------------------------------------- calculate zero distribution lists ----------------------------------------------- */ - -bool calc_zdst_lists(void) +bool packJPG::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++) { @@ -2545,8 +2458,8 @@ bool calc_zdst_lists(void) // 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; + b_x = unzigzag[bpos] % 8; + b_y = unzigzag[bpos] / 8; if (b_x == 0) { for (dpos = 0; dpos < cmpnfo[cmp].bc; dpos++) @@ -2574,16 +2487,13 @@ bool calc_zdst_lists(void) } } - return true; } - /* ----------------------------------------------- packs all parts to compressed pjg ----------------------------------------------- */ - -bool pack_pjg(void) +bool packJPG::pack_pjg(void) { unsigned char hcode; int cmp; @@ -2591,7 +2501,6 @@ bool pack_pjg(void) int dev_size = 0; #endif - // PJG-Header str_out->write(reinterpret_cast(pjg_magic), 2); @@ -2649,12 +2558,12 @@ bool pack_pjg(void) return false; } // also encode one bit to signal false/correct use of RST markers - if (!pjg_encode_bit(encoder, (rst_err == NULL) ? 0 : 1)) + if (!pjg_encode_bit(encoder, (rst_err == nullptr) ? 0 : 1)) { return false; } // encode # of false set RST markers per scan - if (rst_err != NULL) + if (rst_err != nullptr) if (!pjg_encode_generic(encoder, rst_err, scnc)) { return false; @@ -2701,45 +2610,45 @@ bool pack_pjg(void) { return false; } - dev_size_zsr[ cmp ] += str_out->getpos() - dev_size; + 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_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_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_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_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 ]; + 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 } @@ -2756,8 +2665,7 @@ bool pack_pjg(void) } // finalize arithmetic compression - delete (encoder); - + delete encoder; // errormessage if write error if (str_out->error()) @@ -2770,22 +2678,18 @@ bool pack_pjg(void) // get filesize pjgfilesize = str_out->num_bytes_written(); - return true; } - /* ----------------------------------------------- unpacks compressed pjg to colldata ----------------------------------------------- */ - -bool unpack_pjg(void) +bool packJPG::unpack_pjg(void) { unsigned char hcode; unsigned char cb; int cmp; - // check header codes ( maybe position in other function ? ) while (true) { @@ -2820,7 +2724,6 @@ bool unpack_pjg(void) } } - // init arithmetic compression auto decoder = new ArithmeticDecoder(*str_in); @@ -2842,7 +2745,7 @@ bool unpack_pjg(void) } // decode # of false set RST markers per scan only if available if (cb == 1) - if (!pjg_decode_generic(decoder, &rst_err, NULL)) + if (!pjg_decode_generic(decoder, &rst_err, nullptr)) { return false; } @@ -2916,18 +2819,20 @@ bool unpack_pjg(void) } // finalize arithmetic compression - delete (decoder); - + delete decoder; // get filesize pjgfilesize = str_in->get_size(); - return true; } + + /* ----------------------- End of main functions -------------------------- */ +#if 0 + /* ----------------------- Begin of JPEG specific functions -------------------------- */ @@ -2946,12 +2851,12 @@ bool jpg_setup_imginfo(void) // header parser loop while ((int) hpos < hdrs) { - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + 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 ]))) + if (!jpg_parse_jfif(type, len, &(hdrdata[hpos]))) { return false; } @@ -2970,7 +2875,7 @@ bool jpg_setup_imginfo(void) { if ((cmpnfo[cmp].sfv == 0) || (cmpnfo[cmp].sfh == 0) || - (cmpnfo[cmp].qtable == NULL) || + (cmpnfo[cmp].qtable == nullptr) || (cmpnfo[cmp].qtable[0] == 0) || (jpegtype == 0)) { @@ -2983,13 +2888,13 @@ bool jpg_setup_imginfo(void) // do all remaining component info calculations for (cmp = 0; cmp < cmpc; cmp++) { - if (cmpnfo[ cmp ].sfh > sfhm) + if (cmpnfo[cmp].sfh > sfhm) { - sfhm = cmpnfo[ cmp ].sfh; + sfhm = cmpnfo[cmp].sfh; } - if (cmpnfo[ cmp ].sfv > sfvm) + if (cmpnfo[cmp].sfv > sfvm) { - sfvm = cmpnfo[ cmp ].sfv; + sfvm = cmpnfo[cmp].sfv; } } mcuv = (int) ceil((float) imgheight / (float)(8 * sfhm)); @@ -2997,15 +2902,15 @@ bool jpg_setup_imginfo(void) 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; + 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 @@ -3013,14 +2918,14 @@ bool jpg_setup_imginfo(void) { for (cmp = 0; cmp < cmpc; cmp++) { - cmpnfo[ cmp ].sid = cmp; + cmpnfo[cmp].sid = cmp; } } else { for (cmp = 0; cmp < cmpc; cmp++) { - cmpnfo[ cmp ].sid = 0; + cmpnfo[cmp].sid = 0; } } @@ -3031,7 +2936,7 @@ bool jpg_setup_imginfo(void) for (bpos = 0; bpos < 64; bpos++) { colldata[cmp][bpos] = (short int*) calloc(cmpnfo[cmp].bc, sizeof(short)); - if (colldata[cmp][bpos] == NULL) + if (colldata[cmp][bpos] == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -3045,9 +2950,9 @@ bool jpg_setup_imginfo(void) 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)) + if ((zdstdata[cmp] == nullptr) || + (eobxhigh[cmp] == nullptr) || (eobyhigh[cmp] == nullptr) || + (zdstxlow[cmp] == nullptr) || (zdstylow[cmp] == nullptr)) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -3061,10 +2966,10 @@ bool jpg_setup_imginfo(void) for (cmp = 0; cmp < cmpc; cmp++) { for (i = 0; - conf_sets[ i ][ cmpnfo[cmp].sid ] > (unsigned int) cmpnfo[ cmp ].bc; + 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 ]; + segm_cnt[cmp] = conf_segm[i][cmpnfo[cmp].sid]; + nois_trs[cmp] = conf_ntrs[i][cmpnfo[cmp].sid]; } } @@ -3091,8 +2996,8 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment // build huffman trees & codes while (hpos < len) { - lval = LBITS(segment[ hpos ], 4); - rval = RBITS(segment[ hpos ], 4); + lval = LBITS(segment[hpos], 4); + rval = RBITS(segment[hpos], 4); if (((lval < 0) || (lval >= 2)) || ((rval < 0) || (rval >= 4))) { break; @@ -3100,14 +3005,14 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment hpos++; // build huffman codes & trees - jpg_build_huffcodes(&(segment[ hpos + 0 ]), &(segment[ hpos + 16 ]), - &(hcodes[ lval ][ rval ]), &(htrees[ lval ][ rval ])); - htset[ lval ][ rval ] = 1; + 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 ]; + skip += (int) segment[hpos + i]; } hpos += skip; } @@ -3125,8 +3030,8 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment // copy quantization tables to internal memory while (hpos < len) { - lval = LBITS(segment[ hpos ], 4); - rval = RBITS(segment[ hpos ], 4); + lval = LBITS(segment[hpos], 4); + rval = RBITS(segment[hpos], 4); if ((lval < 0) || (lval >= 2)) { break; @@ -3140,8 +3045,8 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment { for (i = 0; i < 64; i++) { - qtables[ rval ][ i ] = (unsigned short) segment[ hpos + i ]; - if (qtables[ rval ][ i ] == 0) + qtables[rval][i] = (unsigned short) segment[hpos + i]; + if (qtables[rval][i] == 0) { break; } @@ -3152,9 +3057,9 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment { 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) + qtables[rval][i] = + B_SHORT(segment[hpos + (2*i)], segment[hpos + (2*i) + 1]); + if (qtables[rval][i] == 0) { break; } @@ -3174,12 +3079,12 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment case 0xDD: // DRI segment // define restart interval - rsti = B_SHORT(segment[ hpos ], segment[ hpos + 1 ]); + rsti = B_SHORT(segment[hpos], segment[hpos + 1]); return true; case 0xDA: // SOS segment // prepare next scan - cs_cmpc = segment[ hpos ]; + cs_cmpc = segment[hpos]; if (cs_cmpc > cmpc) { sprintf(errormessage, "%i components in scan, only %i are allowed", @@ -3190,18 +3095,18 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment hpos++; for (i = 0; i < cs_cmpc; i++) { - for (cmp = 0; (segment[ hpos ] != cmpnfo[ cmp ].jid) && (cmp < cmpc); cmp++); + 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)) + 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; @@ -3209,10 +3114,10 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment } 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); + 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)) { @@ -3248,7 +3153,7 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment } // check data precision, only 8 bit is allowed - lval = segment[ hpos ]; + lval = segment[hpos]; if (lval != 8) { sprintf(errormessage, "%i bit data precision is not supported", lval); @@ -3257,9 +3162,9 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment } // 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 ]; + imgheight = B_SHORT(segment[hpos + 1], segment[hpos + 2]); + imgwidth = B_SHORT(segment[hpos + 3], segment[hpos + 4]); + cmpc = segment[hpos + 5]; if ((imgwidth == 0) || (imgheight == 0)) { sprintf(errormessage, "resolution is %ix%i, possible malformed JPEG", imgwidth, imgheight); @@ -3277,10 +3182,10 @@ bool jpg_parse_jfif(unsigned char type, unsigned int len, unsigned char* segment // 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 ] ]; + 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; } @@ -3418,14 +3323,14 @@ bool jpg_rebuild_header(void) // header parser loop while ((int) hpos < hdrs) { - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + 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(&(hdrdata[ hpos ]), len); + hdrw->write(&(hdrdata[hpos]), len); } hpos += len; } @@ -3465,7 +3370,7 @@ int jpg_decode_block_seq(BitReader* huffr, huffTree* dctree, huffTree* actree, s s = (unsigned char) hc; } n = huffr->read(s); - block[ 0 ] = DEVLI(s, n); + block[0] = DEVLI(s, n); // decode ac for (bpos = 1; bpos < 64;) @@ -3484,16 +3389,16 @@ int jpg_decode_block_seq(BitReader* huffr, huffTree* dctree, huffTree* actree, s } while (z > 0) // write zeroes { - block[ bpos++ ] = 0; + block[bpos++] = 0; z--; } - block[ bpos++ ] = (short) DEVLI(s, n); // decode cvli + 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; + // block[bpos++] = 0; break; } else @@ -3521,9 +3426,9 @@ int jpg_encode_block_seq(BitWriter* huffw, huffCodes* dctbl, huffCodes* actbl, s // encode DC - s = BITLEN2048N(block[ 0 ]); - n = ENVLI(s, block[ 0 ]); - huffw->write_u16(dctbl->cval[ s ], dctbl->clen[ s ]); + s = BITLEN2048N(block[0]); + n = ENVLI(s, block[0]); + huffw->write_u16(dctbl->cval[s], dctbl->clen[s]); huffw->write_u16(n, s); // encode AC @@ -3531,20 +3436,20 @@ int jpg_encode_block_seq(BitWriter* huffw, huffCodes* dctbl, huffCodes* actbl, s for (bpos = 1; bpos < 64; bpos++) { // if nonzero is encountered - if (block[ bpos ] != 0) + if (block[bpos] != 0) { // write remaining zeroes while (z >= 16) { - huffw->write_u16(actbl->cval[ 0xF0 ], actbl->clen[ 0xF0 ]); + huffw->write_u16(actbl->cval[0xF0], actbl->clen[0xF0]); z -= 16; } // vli encode - s = BITLEN2048N(block[ bpos ]); - n = ENVLI(s, block[ bpos ]); + s = BITLEN2048N(block[bpos]); + n = ENVLI(s, block[bpos]); hc = ((z << 4) + s); // write to huffman writer - huffw->write_u16(actbl->cval[ hc ], actbl->clen[ hc ]); + huffw->write_u16(actbl->cval[hc], actbl->clen[hc]); huffw->write_u16(n, s); // reset zeroes z = 0; @@ -3557,7 +3462,7 @@ int jpg_encode_block_seq(BitWriter* huffw, huffCodes* dctbl, huffCodes* actbl, s // write eob if needed if (z > 0) { - huffw->write_u16(actbl->cval[ 0x00 ], actbl->clen[ 0x00 ]); + huffw->write_u16(actbl->cval[0x00], actbl->clen[0x00]); } @@ -3586,7 +3491,7 @@ int jpg_decode_dc_prg_fs(BitReader* huffr, huffTree* dctree, short* block) s = (unsigned char) hc; } n = huffr->read(s); - block[ 0 ] = DEVLI(s, n); + block[0] = DEVLI(s, n); // return 0 if everything is ok @@ -3604,9 +3509,9 @@ int jpg_encode_dc_prg_fs(BitWriter* huffw, huffCodes* dctbl, short* block) // encode DC - s = BITLEN2048N(block[ 0 ]); - n = ENVLI(s, block[ 0 ]); - huffw->write_u16(dctbl->cval[ s ], dctbl->clen[ s ]); + s = BITLEN2048N(block[0]); + n = ENVLI(s, block[0]); + huffw->write_u16(dctbl->cval[s], dctbl->clen[s]); huffw->write_u16(n, s); @@ -3653,10 +3558,10 @@ int jpg_decode_ac_prg_fs(BitReader* huffr, huffTree* actree, short* block, int* } while (z > 0) // write zeroes { - block[ bpos++ ] = 0; + block[bpos++] = 0; z--; } - block[ bpos++ ] = (short) DEVLI(s, n); // decode cvli + block[bpos++] = (short) DEVLI(s, n); // decode cvli } else // decode eobrun { @@ -3665,7 +3570,7 @@ int jpg_decode_ac_prg_fs(BitReader* huffr, huffTree* actree, short* block, int* n = huffr->read(s); (*eobrun) = E_DEVLI(s, n); // while( bpos <= to ) // fill remaining block with zeroes - // block[ bpos++ ] = 0; + // block[bpos++] = 0; break; } } @@ -3692,22 +3597,22 @@ int jpg_encode_ac_prg_fs(BitWriter* huffw, huffCodes* actbl, short* block, int* for (bpos = from; bpos <= to; bpos++) { // if nonzero is encountered - if (block[ bpos ] != 0) + if (block[bpos] != 0) { // encode eobrun jpg_encode_eobrun(huffw, actbl, eobrun); // write remaining zeroes while (z >= 16) { - huffw->write_u16(actbl->cval[ 0xF0 ], actbl->clen[ 0xF0 ]); + huffw->write_u16(actbl->cval[0xF0], actbl->clen[0xF0]); z -= 16; } // vli encode - s = BITLEN2048N(block[ bpos ]); - n = ENVLI(s, block[ bpos ]); + s = BITLEN2048N(block[bpos]); + n = ENVLI(s, block[bpos]); hc = ((z << 4) + s); // write to huffman writer - huffw->write_u16(actbl->cval[ hc ], actbl->clen[ hc ]); + huffw->write_u16(actbl->cval[hc], actbl->clen[hc]); huffw->write_u16(n, s); // reset zeroes z = 0; @@ -3742,7 +3647,7 @@ int jpg_encode_ac_prg_fs(BitWriter* huffw, huffCodes* actbl, short* block, int* int jpg_decode_dc_prg_sa(BitReader* huffr, short* block) { // decode next bit of dc coefficient - block[ 0 ] = huffr->read(1); + block[0] = huffr->read(1); // return 0 if everything is ok return 0; @@ -3755,7 +3660,7 @@ int jpg_decode_dc_prg_sa(BitReader* huffr, short* block) int jpg_encode_dc_prg_sa(BitWriter* huffw, short* block) { // enocode next bit of dc coefficient - huffw->write_u16(block[ 0 ], 1); + huffw->write_u16(block[0], 1); // return 0 if everything is ok return 0; @@ -3810,7 +3715,7 @@ int jpg_decode_ac_prg_sa(BitReader* huffr, huffTree* actree, short* block, int* // write zeroes / write correction bits while (true) { - if (block[ bpos ] == 0) // skip zeroes / write value + if (block[bpos] == 0) // skip zeroes / write value { if (z > 0) { @@ -3818,14 +3723,14 @@ int jpg_decode_ac_prg_sa(BitReader* huffr, huffTree* actree, short* block, int* } else { - block[ bpos++ ] = v; + block[bpos++] = v; break; } } else // read correction bit { n = huffr->read(1); - block[ bpos ] = (block[ bpos ] > 0) ? n : -n; + block[bpos] = (block[bpos] > 0) ? n : -n; } if (bpos++ >= to) { @@ -3848,10 +3753,10 @@ int jpg_decode_ac_prg_sa(BitReader* huffr, huffTree* actree, short* block, int* { for (; bpos <= to; bpos++) { - if (block[ bpos ] != 0) + if (block[bpos] != 0) { n = huffr->read(1); - block[ bpos ] = (block[ bpos ] > 0) ? n : -n; + block[bpos] = (block[bpos] > 0) ? n : -n; } } } @@ -3876,7 +3781,7 @@ int jpg_encode_ac_prg_sa(BitWriter* huffw, std::vector& storw, huf // 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)) + if ((block[bpos] == 1) || (block[bpos] == -1)) { eob = bpos + 1; break; @@ -3895,25 +3800,25 @@ int jpg_encode_ac_prg_sa(BitWriter* huffw, std::vector& storw, huf for (bpos = from; bpos < eob; bpos++) { // if zero is encountered - if (block[ bpos ] == 0) + if (block[bpos] == 0) { z++; // increment zero counter if (z == 16) // write zeroes if needed { - huffw->write_u16(actbl->cval[ 0xF0 ], actbl->clen[ 0xF0 ]); + huffw->write_u16(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)) + else if ((block[bpos] == 1) || (block[bpos] == -1)) { // vli encode - s = BITLEN2048N(block[ bpos ]); - n = ENVLI(s, block[ bpos ]); + s = BITLEN2048N(block[bpos]); + n = ENVLI(s, block[bpos]); hc = ((z << 4) + s); // write to huffman writer - huffw->write_u16(actbl->cval[ hc ], actbl->clen[ hc ]); + huffw->write_u16(actbl->cval[hc], actbl->clen[hc]); huffw->write_u16(n, s); // write correction bits jpg_encode_crbits(huffw, storw); @@ -3922,7 +3827,7 @@ int jpg_encode_ac_prg_sa(BitWriter* huffw, std::vector& storw, huf } else // store correction bits { - n = block[ bpos ] & 0x1; + n = block[bpos] & 0x1; storw.emplace_back(n); } } @@ -3930,9 +3835,9 @@ int jpg_encode_ac_prg_sa(BitWriter* huffw, std::vector& storw, huf // fast processing after eob for (; bpos <= to; bpos++) { - if (block[ bpos ] != 0) // store correction bits + if (block[bpos] != 0) // store correction bits { - n = block[ bpos ] & 0x1; + n = block[bpos] & 0x1; storw.emplace_back(n); } } @@ -3966,10 +3871,10 @@ int jpg_decode_eobrun_sa(BitReader* huffr, short* block, int* eobrun, int from, // fast eobrun decoding routine for succesive approximation for (bpos = from; bpos <= to; bpos++) { - if (block[ bpos ] != 0) + if (block[bpos] != 0) { n = huffr->read(1); - block[ bpos ] = (block[ bpos ] > 0) ? n : -n; + block[bpos] = (block[bpos] > 0) ? n : -n; } } @@ -3992,7 +3897,7 @@ int jpg_encode_eobrun(BitWriter* huffw, huffCodes* actbl, int* eobrun) { while ((*eobrun) > actbl->max_eobrun) { - huffw->write_u16(actbl->cval[ 0xE0 ], actbl->clen[ 0xE0 ]); + huffw->write_u16(actbl->cval[0xE0], actbl->clen[0xE0]); huffw->write_u16(E_ENVLI(14, 32767), 14); (*eobrun) -= actbl->max_eobrun; } @@ -4000,7 +3905,7 @@ int jpg_encode_eobrun(BitWriter* huffw, huffCodes* actbl, int* eobrun) s--; n = E_ENVLI(s, (*eobrun)); hc = (s << 4); - huffw->write_u16(actbl->cval[ hc ], actbl->clen[ hc ]); + huffw->write_u16(actbl->cval[hc], actbl->clen[hc]); huffw->write_u16(n, s); (*eobrun) = 0; } @@ -4035,7 +3940,7 @@ int jpg_next_huffcode(BitReader* huffw, huffTree* ctree) while (node < 256) { node = (huffw->read(1) == 1) ? - ctree->r[ node ] : ctree->l[ node ]; + ctree->r[node] : ctree->l[node]; if (node == 0) { break; @@ -4062,7 +3967,7 @@ int jpg_next_mcupos(int* mcu, int* cmp, int* csc, int* sub, int* dpos, int* rstw if ((++(*csc)) >= cs_cmpc) { (*csc) = 0; - (*cmp) = cs_cmp[ 0 ]; + (*cmp) = cs_cmp[0]; (*mcu)++; if ((*mcu) >= mcuc) { @@ -4232,10 +4137,10 @@ void jpg_build_huffcodes(unsigned char* clen, unsigned char* cval, huffCodes* h // symbol-value of code is its position in the table for (i = 0; i < 16; i++) { - for (j = 0; j < (int) clen[ i ]; j++) + for (j = 0; j < (int) clen[i]; j++) { - hc->clen[(int) cval[k] ] = 1 + i; - hc->cval[(int) cval[k] ] = code; + hc->clen[(int) cval[k]] = 1 + i; + hc->cval[(int) cval[k]] = code; k++; code++; @@ -4247,7 +4152,7 @@ void jpg_build_huffcodes(unsigned char* clen, unsigned char* cval, huffCodes* h hc->max_eobrun = 0; for (i = 14; i >= 0; i--) { - if (hc->clen[ i << 4 ] > 0) + if (hc->clen[i << 4] > 0) { hc->max_eobrun = (2 << i) - 1; break; @@ -4265,35 +4170,35 @@ void jpg_build_huffcodes(unsigned char* clen, unsigned char* cval, huffCodes* h // (re)set current node node = 0; // go through each code & store path - for (j = hc->clen[ i ] - 1; j > 0; j--) + for (j = hc->clen[i] - 1; j > 0; j--) { - if (BITN(hc->cval[ i ], j) == 1) + if (BITN(hc->cval[i], j) == 1) { - if (ht->r[ node ] == 0) + if (ht->r[node] == 0) { - ht->r[ node ] = nextfree++; + ht->r[node] = nextfree++; } - node = ht->r[ node ]; + node = ht->r[node]; } else { - if (ht->l[ node ] == 0) + if (ht->l[node] == 0) { - ht->l[ node ] = nextfree++; + ht->l[node] = nextfree++; } - node = ht->l[ node ]; + node = ht->l[node]; } } // last link is number of targetvalue + 256 - if (hc->clen[ i ] > 0) + if (hc->clen[i] > 0) { - if (BITN(hc->cval[ i ], 0) == 1) + if (BITN(hc->cval[i], 0) == 1) { - ht->r[ node ] = i + 256; + ht->r[node] = i + 256; } else { - ht->l[ node ] = i + 256; + ht->l[node] = i + 256; } } } @@ -4311,7 +4216,7 @@ bool pjg_encode_zstscan(ArithmeticEncoder* enc, int cmp) { model_s* model; - unsigned char freqlist[ 64 ]; + unsigned char freqlist[64]; int tpos; // true position int cpos; // coded position int c, i; @@ -4323,7 +4228,7 @@ bool pjg_encode_zstscan(ArithmeticEncoder* enc, int cmp) // preset freqlist for (i = 0; i < 64; i++) { - freqlist[ i ] = stdscan[ i ]; + freqlist[i] = stdscan[i]; } // init model @@ -4340,9 +4245,9 @@ bool pjg_encode_zstscan(ArithmeticEncoder* enc, int cmp) for (c = i; c < 64; c++) { // search next val != 0 in list - for (tpos++; freqlist[ tpos ] == 0; tpos++); + for (tpos++; freqlist[tpos] == 0; tpos++); // get out if not a match - if (freqlist[ tpos ] != zsrtscan[ cmp ][ c ]) + if (freqlist[tpos] != zsrtscan[cmp][c]) { break; } @@ -4358,13 +4263,13 @@ bool pjg_encode_zstscan(ArithmeticEncoder* enc, int cmp) // 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) + for (tpos = 0; freqlist[tpos] != zsrtscan[cmp][i]; tpos++) + if (freqlist[tpos] != 0) { cpos++; } // remove from list - freqlist[ tpos ] = 0; + freqlist[tpos] = 0; // encode coded position in list encode_ari(enc, model, cpos); @@ -4375,7 +4280,7 @@ bool pjg_encode_zstscan(ArithmeticEncoder* enc, int cmp) delete (model); // set zero sort scan as freqscan - freqscan[ cmp ] = zsrtscan[ cmp ]; + freqscan[cmp] = zsrtscan[cmp]; return true; @@ -4398,7 +4303,7 @@ bool pjg_encode_zdst_high(ArithmeticEncoder* enc, int cmp) // init model, constants model = INIT_MODEL_S(49 + 1, 25 + 1, 1); - zdstls = zdstdata[ cmp ]; + zdstls = zdstdata[cmp]; w = cmpnfo[cmp].bch; bc = cmpnfo[cmp].bc; @@ -4407,12 +4312,12 @@ bool pjg_encode_zdst_high(ArithmeticEncoder* enc, int cmp) { // 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; + 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 ]); + encode_ari(enc, model, zdstls[dpos]); } // clean up @@ -4442,11 +4347,11 @@ bool pjg_encode_zdst_low(ArithmeticEncoder* enc, int cmp) // 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 ]; + 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) @@ -4454,14 +4359,14 @@ bool pjg_encode_zdst_low(ArithmeticEncoder* enc, int cmp) { 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 + 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 + encode_ari(enc, model, zdstls_y[dpos]); // encode symbol } // clean up @@ -4487,8 +4392,8 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) 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 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 @@ -4507,7 +4412,7 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) // decide segmentation setting - segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ]; + segm_tab = segm_tables[segm_cnt[cmp] - 1]; // get max absolute value/bit length max_val = MAX_V(cmp, 0); @@ -4524,7 +4429,7 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) // allocate memory for absolute values storage absv_store = (unsigned short*) calloc(bc, sizeof(short)); - if (absv_store == NULL) + if (absv_store == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -4535,8 +4440,8 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) 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 ]; + coeffs = colldata[cmp][0]; + zdstls = zdstdata[cmp]; // arithmetic compression loop for (dpos = 0; dpos < bc; dpos++) @@ -4548,7 +4453,7 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) r_x = w - (p_x + 1); // get segment-number from zero distribution list and segmentation set - snum = segm_tab[ zdstls[dpos] ]; + 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 @@ -4556,7 +4461,7 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) shift_model(mod_len, ctx_len, snum); // simple treatment if coefficient is zero - if (coeffs[ dpos ] == 0) + if (coeffs[dpos] == 0) { // encode bit length (0) of current coefficient encode_ari(enc, mod_len, 0); @@ -4581,7 +4486,7 @@ bool pjg_encode_dc(ArithmeticEncoder* enc, int cmp) // encode sign encode_ari(enc, mod_sgn, sgn); // store absolute value - absv_store[ dpos ] = absv; + absv_store[dpos] = absv; } } @@ -4613,8 +4518,8 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) 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 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 @@ -4640,7 +4545,7 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) // decide segmentation setting - segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ]; + 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); @@ -4655,17 +4560,17 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) 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)) + if ((absv_store == nullptr) || (sgn_store == nullptr) || (zdstls == nullptr)) { - if (absv_store != NULL) + if (absv_store != nullptr) { free(absv_store); } - if (sgn_store != NULL) + if (sgn_store != nullptr) { free(sgn_store); } - if (zdstls != NULL) + if (zdstls != nullptr) { free(zdstls); } @@ -4679,8 +4584,8 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) sgn_nbv = sgn_store - w; // locally store pointer to eob x / eob y - eob_x = eobxhigh[ cmp ]; - eob_y = eobyhigh[ cmp ]; + eob_x = eobxhigh[cmp]; + eob_y = eobyhigh[cmp]; // preset x/y eobs memset(eob_x, 0x00, bc * sizeof(char)); @@ -4689,7 +4594,7 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) // make a local copy of the zero distribution list for (dpos = 0; dpos < bc; dpos++) { - zdstls[ dpos ] = zdstdata[ cmp ][ dpos ]; + zdstls[dpos] = zdstdata[cmp][dpos]; } // work through lower 7x7 bands in order of freqscan @@ -4697,8 +4602,8 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) { // work through blocks in order of frequency scan bpos = (int) freqscan[cmp][i]; - b_x = unzigzag[ bpos ] % 8; - b_y = unzigzag[ bpos ] / 8; + b_x = unzigzag[bpos] % 8; + b_y = unzigzag[bpos] / 8; if ((b_x == 0) || (b_y == 0)) { @@ -4713,7 +4618,7 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) pjg_aavrg_prepare(c_absc, c_weight, absv_store, cmp); // locally store pointer to coefficients - coeffs = colldata[ cmp ][ bpos ]; + coeffs = colldata[cmp][bpos]; // get max bit length max_val = MAX_V(cmp, bpos); @@ -4735,7 +4640,7 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) r_x = w - (p_x + 1); // get segment-number from zero distribution list and segmentation set - snum = segm_tab[ zdstls[dpos] ]; + 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 @@ -4744,7 +4649,7 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) mod_len->exclude_symbols(max_len); // simple treatment if coefficient is zero - if (coeffs[ dpos ] == 0) + if (coeffs[dpos] == 0) { // encode bit length (0) of current coefficien encode_ari(enc, mod_len, 0); @@ -4767,16 +4672,16 @@ bool pjg_encode_ac_high(ArithmeticEncoder* enc, int cmp) encode_ari(enc, mod_res, bt); } // encode sign - ctx_sgn = (p_x > 0) ? sgn_nbh[ dpos ] : 0; // sign context + ctx_sgn = (p_x > 0) ? sgn_nbh[dpos] : 0; // sign context if (p_y > 0) { - ctx_sgn += 3 * sgn_nbv[ dpos ]; // IMPROVE !!!!!!!!!!! + 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; + absv_store[dpos] = absv; + sgn_store[dpos] = sgn + 1; zdstls[dpos]--; // recalculate x/y eob if (b_x > eob_x[dpos]) @@ -4821,9 +4726,9 @@ bool pjg_encode_ac_low(ArithmeticEncoder* enc, int cmp) 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 + 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 @@ -4863,33 +4768,33 @@ bool pjg_encode_ac_low(ArithmeticEncoder* enc, int cmp) // 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) ]; + bpos = (int) zigzag[b_x + (8*b_y)]; // locally store pointer to band coefficients - coeffs = colldata[ cmp ][ bpos ]; + 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)]); + 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 ]; + 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)]); + 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 ]; + zdstls = zdstxlow[cmp]; edge_c = &p_y; } @@ -4903,7 +4808,7 @@ bool pjg_encode_ac_low(ArithmeticEncoder* enc, int cmp) for (dpos = 0; dpos < bc; dpos++) { // skip if beyound eob - if (zdstls[ dpos ] == 0) + if (zdstls[dpos] == 0) { continue; } @@ -4925,11 +4830,11 @@ bool pjg_encode_ac_low(ArithmeticEncoder* enc, int cmp) 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 ]); + shift_model(mod_len, ctx_len, zdstls[dpos]); mod_len->exclude_symbols(max_len); // simple treatment if coefficient is zero - if (coeffs[ dpos ] == 0) + if (coeffs[dpos] == 0) { // encode bit length (0) of current coefficient encode_ari(enc, mod_len, 0); @@ -4962,7 +4867,7 @@ bool pjg_encode_ac_low(ArithmeticEncoder* enc, int cmp) } for (; bp >= 0; bp--) { - shift_model(mod_res, zdstls[ dpos ], bp); // shift in 2 contexts + shift_model(mod_res, zdstls[dpos], bp); // shift in 2 contexts // encode/get bit bt = BITN(absv, bp); encode_ari(enc, mod_res, bt); @@ -4971,7 +4876,7 @@ bool pjg_encode_ac_low(ArithmeticEncoder* enc, int cmp) shift_model(mod_sgn, ctx_len, ctx_sgn); encode_ari(enc, mod_sgn, sgn); // decrement # of non zeroes - zdstls[ dpos ]--; + zdstls[dpos]--; } } // flush models @@ -5005,8 +4910,8 @@ bool pjg_encode_generic(ArithmeticEncoder* enc, unsigned char* data, int len) 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_ari(enc, model, data[i]); + model->shift_context(data[i]); } // encode end-of-data symbol (256) encode_ari(enc, model, 256); @@ -5042,19 +4947,19 @@ bool pjg_decode_zstscan(ArithmeticDecoder* dec, int cmp) { model_s* model;; - unsigned char freqlist[ 64 ]; + 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; + zsrtscan[cmp][0] = 0; // preset freqlist for (i = 0; i < 64; i++) { - freqlist[ i ] = stdscan[ i ]; + freqlist[i] = stdscan[i]; } // init model @@ -5076,8 +4981,8 @@ bool pjg_decode_zstscan(ArithmeticDecoder* dec, int cmp) // fill the scan & make a quick exit for (tpos = 0; i < 64; i++) { - while (freqlist[ ++tpos ] == 0); - zsrtscan[ cmp ][ i ] = freqlist[ tpos ]; + while (freqlist[++tpos] == 0); + zsrtscan[cmp][i] = freqlist[tpos]; } break; } @@ -5085,7 +4990,7 @@ bool pjg_decode_zstscan(ArithmeticDecoder* dec, int cmp) // decode position from list for (tpos = 0; tpos < 64; tpos++) { - if (freqlist[ tpos ] != 0) + if (freqlist[tpos] != 0) { cpos--; } @@ -5096,16 +5001,16 @@ bool pjg_decode_zstscan(ArithmeticDecoder* dec, int cmp) } // write decoded position to zero sort scan - zsrtscan[ cmp ][ i ] = freqlist[ tpos ]; + zsrtscan[cmp][i] = freqlist[tpos]; // remove from list - freqlist[ tpos ] = 0; + freqlist[tpos] = 0; } // delete model delete (model); // set zero sort scan as freqscan - freqscan[ cmp ] = zsrtscan[ cmp ]; + freqscan[cmp] = zsrtscan[cmp]; return true; @@ -5128,7 +5033,7 @@ bool pjg_decode_zdst_high(ArithmeticDecoder* dec, int cmp) // init model, constants model = INIT_MODEL_S(49 + 1, 25 + 1, 1); - zdstls = zdstdata[ cmp ]; + zdstls = zdstdata[cmp]; w = cmpnfo[cmp].bch; bc = cmpnfo[cmp].bc; @@ -5137,12 +5042,12 @@ bool pjg_decode_zdst_high(ArithmeticDecoder* dec, int cmp) { // 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; + 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); + zdstls[dpos] = decode_ari(dec, model); } // clean up @@ -5172,11 +5077,11 @@ bool pjg_decode_zdst_low(ArithmeticDecoder* dec, int cmp) // 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 ]; + 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) @@ -5184,14 +5089,14 @@ bool pjg_decode_zdst_low(ArithmeticDecoder* dec, int cmp) { 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 + 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 + zdstls_y[dpos] = decode_ari(dec, model); // decode symbol } // clean up @@ -5217,8 +5122,8 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) 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 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 @@ -5237,7 +5142,7 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) // decide segmentation setting - segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ]; + segm_tab = segm_tables[segm_cnt[cmp] - 1]; // get max absolute value/bit length max_val = MAX_V(cmp, 0); @@ -5254,7 +5159,7 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) // allocate memory for absolute values storage absv_store = (unsigned short*) calloc(bc, sizeof(short)); - if (absv_store == NULL) + if (absv_store == nullptr) { sprintf(errormessage, MEM_ERRMSG); errorlevel = 2; @@ -5265,8 +5170,8 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) 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 ]; + coeffs = colldata[cmp][0]; + zdstls = zdstdata[cmp]; // arithmetic compression loop for (dpos = 0; dpos < bc; dpos++) @@ -5278,7 +5183,7 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) r_x = w - (p_x + 1); // get segment-number from zero distribution list and segmentation set - snum = segm_tab[ zdstls[dpos] ]; + 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 @@ -5290,7 +5195,7 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) // simple treatment if coefficient is zero if (clen == 0) { - // coeffs[ dpos ] = 0; + // coeffs[dpos] = 0; } else { @@ -5312,9 +5217,9 @@ bool pjg_decode_dc(ArithmeticDecoder* dec, int cmp) // decode sign sgn = decode_ari(dec, mod_sgn); // copy to colldata - coeffs[ dpos ] = (sgn == 0) ? absv : -absv; + coeffs[dpos] = (sgn == 0) ? absv : -absv; // store absolute value/sign - absv_store[ dpos ] = absv; + absv_store[dpos] = absv; } } @@ -5346,8 +5251,8 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) 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 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 @@ -5373,7 +5278,7 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) // decide segmentation setting - segm_tab = segm_tables[ segm_cnt[ cmp ] - 1 ]; + 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); @@ -5388,17 +5293,17 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) 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)) + if ((absv_store == nullptr) || (sgn_store == nullptr) || (zdstls == nullptr)) { - if (absv_store != NULL) + if (absv_store != nullptr) { free(absv_store); } - if (sgn_store != NULL) + if (sgn_store != nullptr) { free(sgn_store); } - if (zdstls != NULL) + if (zdstls != nullptr) { free(zdstls); } @@ -5412,8 +5317,8 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) sgn_nbv = sgn_store - w; // locally store pointer to eob x / eob y - eob_x = eobxhigh[ cmp ]; - eob_y = eobyhigh[ cmp ]; + eob_x = eobxhigh[cmp]; + eob_y = eobyhigh[cmp]; // preset x/y eobs memset(eob_x, 0x00, bc * sizeof(char)); @@ -5422,7 +5327,7 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) // make a local copy of the zero distribution list for (dpos = 0; dpos < bc; dpos++) { - zdstls[ dpos ] = zdstdata[ cmp ][ dpos ]; + zdstls[dpos] = zdstdata[cmp][dpos]; } // work through lower 7x7 bands in order of freqscan @@ -5430,8 +5335,8 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) { // work through blocks in order of frequency scan bpos = (int) freqscan[cmp][i]; - b_x = unzigzag[ bpos ] % 8; - b_y = unzigzag[ bpos ] / 8; + b_x = unzigzag[bpos] % 8; + b_y = unzigzag[bpos] / 8; if ((b_x == 0) || (b_y == 0)) { @@ -5446,7 +5351,7 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) pjg_aavrg_prepare(c_absc, c_weight, absv_store, cmp); // locally store pointer to coefficients - coeffs = colldata[ cmp ][ bpos ]; + coeffs = colldata[cmp][bpos]; // get max bit length max_val = MAX_V(cmp, bpos); @@ -5468,7 +5373,7 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) r_x = w - (p_x + 1); // get segment-number from zero distribution list and segmentation set - snum = segm_tab[ zdstls[dpos] ]; + 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 @@ -5481,7 +5386,7 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) // simple treatment if coefficient is zero if (clen == 0) { - // coeffs[ dpos ] = 0; + // coeffs[dpos] = 0; } else { @@ -5501,18 +5406,18 @@ bool pjg_decode_ac_high(ArithmeticDecoder* dec, int cmp) } } // decode sign - ctx_sgn = (p_x > 0) ? sgn_nbh[ dpos ] : 0; // sign context + ctx_sgn = (p_x > 0) ? sgn_nbh[dpos] : 0; // sign context if (p_y > 0) { - ctx_sgn += 3 * sgn_nbv[ dpos ]; // IMPROVE! !!!!!!!!!!! + 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; + coeffs[dpos] = (sgn == 0) ? absv : -absv; // store absolute value/sign, decrement zdst - absv_store[ dpos ] = absv; - sgn_store[ dpos ] = sgn + 1; + absv_store[dpos] = absv; + sgn_store[dpos] = sgn + 1; zdstls[dpos]--; // recalculate x/y eob if (b_x > eob_x[dpos]) @@ -5557,9 +5462,9 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) 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 + 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 @@ -5599,33 +5504,33 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) // 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) ]; + bpos = (int) zigzag[b_x + (8*b_y)]; // locally store pointer to band coefficients - coeffs = colldata[ cmp ][ bpos ]; + 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)]); + 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 ]; + 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)]); + 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 ]; + zdstls = zdstxlow[cmp]; edge_c = &p_y; } @@ -5639,7 +5544,7 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) for (dpos = 0; dpos < bc; dpos++) { // skip if beyound eob - if (zdstls[ dpos ] == 0) + if (zdstls[dpos] == 0) { continue; } @@ -5660,7 +5565,7 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) 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 ]); + shift_model(mod_len, ctx_len, zdstls[dpos]); mod_len->exclude_symbols(max_len); // decode bit length of current coefficient @@ -5668,7 +5573,7 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) // simple treatment if coefficients == 0 if (clen == 0) { - // coeffs[ dpos ] = 0; + // coeffs[dpos] = 0; } else { @@ -5692,7 +5597,7 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) absv = (ctx_res == 0) ? 1 : ctx_res; // !!!! for (; bp >= 0; bp--) { - shift_model(mod_res, zdstls[ dpos ], bp); // shift in 2 contexts + shift_model(mod_res, zdstls[dpos], bp); // shift in 2 contexts // decode bit bt = decode_ari(dec, mod_res); // update absv @@ -5703,12 +5608,12 @@ bool pjg_decode_ac_low(ArithmeticDecoder* dec, int cmp) } } // decode sign - shift_model(mod_sgn, zdstls[ dpos ], ctx_sgn); + shift_model(mod_sgn, zdstls[dpos], ctx_sgn); sgn = decode_ari(dec, mod_sgn); // copy to colldata - coeffs[ dpos ] = (sgn == 0) ? absv : -absv; + coeffs[dpos] = (sgn == 0) ? absv : -absv; // decrement # of non zeroes - zdstls[ dpos ]--; + zdstls[dpos]--; } } // flush models @@ -5767,7 +5672,7 @@ bool pjg_decode_generic(ArithmeticDecoder* dec, unsigned char** data, int* len) // get data/length and close byte writer (*data) = bwrt->get_c_data(); - if (len != NULL) + if (len != nullptr) { (*len) = bwrt->num_bytes_written(); } @@ -5800,7 +5705,7 @@ bool pjg_decode_bit(ArithmeticDecoder* dec, unsigned char* bit) ----------------------------------------------- */ void pjg_get_zerosort_scan(unsigned char* sv, int cmp) { - unsigned int zdist[ 64 ]; // distributions of zeroes per band + unsigned int zdist[64]; // distributions of zeroes per band int bc = cmpnfo[cmp].bc; int bpos, dpos; bool done = false; @@ -5811,8 +5716,8 @@ void pjg_get_zerosort_scan(unsigned char* sv, int cmp) // preset sv & zdist for (i = 0; i < 64; i++) { - sv[ i ] = i; - zdist[ i ] = 0; + sv[i] = i; + zdist[i] = 0; } // count zeroes for each frequency @@ -5820,7 +5725,7 @@ void pjg_get_zerosort_scan(unsigned char* sv, int cmp) for (dpos = 0; dpos < bc; dpos++) if (colldata[cmp][bpos][dpos] == 0) { - zdist[ bpos ]++; + zdist[bpos]++; } // bubble sort according to count of zeroes (descending order) @@ -5828,16 +5733,16 @@ void pjg_get_zerosort_scan(unsigned char* sv, int cmp) { done = true; for (i = 2; i < 64; i++) - if (zdist[ i ] < zdist[ i - 1 ]) + if (zdist[i] < zdist[i - 1]) { - swap = zdist[ i ]; - zdist[ i ] = zdist[ i - 1 ]; - zdist[ i - 1 ] = swap; + swap = zdist[i]; + zdist[i] = zdist[i - 1]; + zdist[i - 1] = swap; - swap = sv[ i ]; - sv[ i ] = sv[ i - 1 ]; - sv[ i - 1 ] = swap; + swap = sv[i]; + sv[i] = sv[i - 1]; + sv[i - 1] = swap; done = false; } @@ -5864,8 +5769,8 @@ bool pjg_optimize_header(void) // header parser loop while ((int) hpos < hdrs) { - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + 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 @@ -5876,26 +5781,26 @@ bool pjg_optimize_header(void) // 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++) + for (spos = 0; spos < std_huff_lengths[i]; spos++) { - if (hdrdata[ hpos + spos ] != std_huff_tables[ i ][ spos ]) + if (hdrdata[hpos + spos] != std_huff_tables[i][spos]) { break; } } // check if comparison ok - if (spos != std_huff_lengths[ i ]) + 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 + 0] = std_huff_lengths[i] - 16 - i; + hdrdata[hpos + 1] = i; + for (spos = 2; spos < std_huff_lengths[i]; spos++) { - hdrdata[ hpos + spos ] = 0x00; + hdrdata[hpos + spos] = 0x00; } // everything done here, so leave break; @@ -5904,7 +5809,7 @@ bool pjg_optimize_header(void) skip = 16; for (i = 0; i < 16; i++) { - skip += (int) hdrdata[ hpos + i ]; + skip += (int) hdrdata[hpos + i]; } hpos += skip; } @@ -5915,7 +5820,7 @@ bool pjg_optimize_header(void) hpos += 4; // skip marker & length while (hpos < fpos) { - i = LBITS(hdrdata[ hpos ], 4); + i = LBITS(hdrdata[hpos], 4); hpos++; // table found if (i == 1) // get out for 16 bit precision @@ -5926,7 +5831,7 @@ bool pjg_optimize_header(void) // do diff coding for 8 bit precision for (spos = 63; spos > 0; spos--) { - hdrdata[ hpos + spos ] -= hdrdata[ hpos + spos - 1 ]; + hdrdata[hpos + spos] -= hdrdata[hpos + spos - 1]; } hpos += 64; @@ -5962,8 +5867,8 @@ bool pjg_unoptimize_header(void) // header parser loop while ((int) hpos < hdrs) { - type = hdrdata[ hpos + 1 ]; - len = 2 + B_SHORT(hdrdata[ hpos + 2 ], hdrdata[ hpos + 3 ]); + type = hdrdata[hpos + 1]; + len = 2 + B_SHORT(hdrdata[hpos + 2], hdrdata[hpos + 3]); if (type == 0xC4) // for DHT { @@ -5973,20 +5878,20 @@ bool pjg_unoptimize_header(void) { hpos++; // table found - check if modified - if (hdrdata[ hpos ] > 2) + if (hdrdata[hpos] > 2) { // reinsert the standard table - i = hdrdata[ hpos + 1 ]; - for (spos = 0; spos < std_huff_lengths[ i ]; spos++) + i = hdrdata[hpos + 1]; + for (spos = 0; spos < std_huff_lengths[i]; spos++) { - hdrdata[ hpos + spos ] = std_huff_tables[ i ][ spos ]; + hdrdata[hpos + spos] = std_huff_tables[i][spos]; } } skip = 16; for (i = 0; i < 16; i++) { - skip += (int) hdrdata[ hpos + i ]; + skip += (int) hdrdata[hpos + i]; } hpos += skip; } @@ -5997,7 +5902,7 @@ bool pjg_unoptimize_header(void) hpos += 4; // skip marker & length while (hpos < fpos) { - i = LBITS(hdrdata[ hpos ], 4); + i = LBITS(hdrdata[hpos], 4); hpos++; // table found if (i == 1) // get out for 16 bit precision @@ -6008,7 +5913,7 @@ bool pjg_unoptimize_header(void) // undo diff coding for 8 bit precision for (spos = 1; spos < 64; spos++) { - hdrdata[ hpos + spos ] += hdrdata[ hpos + spos - 1 ]; + hdrdata[hpos + spos] += hdrdata[hpos + spos - 1]; } hpos += 64; @@ -6033,19 +5938,19 @@ void pjg_aavrg_prepare(unsigned short** abs_coeffs, int* weights, unsigned short 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 + 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 + 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 } @@ -6062,70 +5967,70 @@ int pjg_aavrg_context(unsigned short** abs_coeffs, int* weights, int pos, int p_ // different cases due to edge treatment if (p_y >= 2) { - w_curr = weights[ 0 ]; - ctx_avr += abs_coeffs[ 0 ][ pos ] * w_curr; + 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_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_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_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_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_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_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_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_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_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_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_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_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_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_curr = weights[3]; + ctx_avr += abs_coeffs[3][pos] * w_curr; w_ctx += w_curr; } } @@ -6133,17 +6038,17 @@ int pjg_aavrg_context(unsigned short** abs_coeffs, int* weights, int pos, int p_ { if (p_x >= 2) { - w_curr = weights[ 4 ]; - ctx_avr += abs_coeffs[ 4 ][ pos ] * 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_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_curr = weights[5]; + ctx_avr += abs_coeffs[5][pos] * w_curr; w_ctx += w_curr; } } @@ -6161,17 +6066,17 @@ int pjg_lakh_context(signed short** coeffs_x, signed short** coeffs_a, int* pred 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 ]; + 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 ]; + pred = ((pred > 0) ? (pred + (pred_cf[0]/2)) : (pred - (pred_cf[0]/2))) / pred_cf[0]; // complete prediction - pred += coeffs_a[ 0 ][ pos ]; + pred += coeffs_a[0][pos]; return pred; } @@ -6243,14 +6148,14 @@ int idct_2d_fst_8x1(int cmp, int dpos, int ix, int iy) 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 ]; + 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; @@ -6270,14 +6175,14 @@ int idct_2d_fst_1x8(int cmp, int dpos, int ix, int iy) 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 ]; + 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; @@ -6294,27 +6199,27 @@ int idct_2d_fst_1x8(int cmp, int dpos, int ix, int iy) #if defined(USE_PLOCOI) int dc_coll_predictor(int cmp, int dpos) { - signed short* coefs = colldata[ cmp ][ 0 ]; + signed short* coefs = colldata[cmp][0]; int w = cmpnfo[cmp].bch; int a, b, c; if (dpos < w) { - a = coefs[ dpos - 1 ]; + a = coefs[dpos - 1]; b = 0; c = 0; } else if ((dpos%w) == 0) { a = 0; - b = coefs[ dpos - w ]; + b = coefs[dpos - w]; c = 0; } else { - a = coefs[ dpos - 1 ]; - b = coefs[ dpos - w ]; - c = coefs[ dpos - 1 - w ]; + a = coefs[dpos - 1]; + b = coefs[dpos - w]; + c = coefs[dpos - 1 - w]; } return plocoi(a, b, c); @@ -6341,8 +6246,8 @@ int dc_1ddct_predictor(int cmp, int dpos) // store current block DC coefficient - swap = colldata[ cmp ][ 0 ][ dpos ]; - colldata[ cmp ][ 0 ][ dpos ] = 0; + swap = colldata[cmp][0][dpos]; + colldata[cmp][0][dpos] = 0; // calculate prediction if ((px > 0) && (py > 0)) @@ -6371,7 +6276,7 @@ int dc_1ddct_predictor(int cmp, int dpos) } // write back current DCT coefficient - colldata[ cmp ][ 0 ][ dpos ] = swap; + colldata[cmp][0][dpos] = swap; // clamp and quantize predictor pred = CLAMPED(-(1024 * DCT_RSC_FACTOR), (1016 * DCT_RSC_FACTOR), pred); @@ -6425,18 +6330,18 @@ inline int median_int(int* values, int size) { done = true; for (i = 1; i < size; i++) - if (values[ i ] < values[ i - 1 ]) + if (values[i] < values[i - 1]) { - swap = values[ i ]; - values[ i ] = values[ i - 1 ]; - values[ i - 1 ] = swap; + 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 ]; + (values[middle] + values[middle - 1]) / 2 : values[middle]; } @@ -6457,11 +6362,11 @@ inline float median_float(float* values, int size) { done = true; for (i = 1; i < size; i++) - if (values[ i ] < values[ i - 1 ]) + if (values[i] < values[i - 1]) { - swap = values[ i ]; - values[ i ] = values[ i - 1 ]; - values[ i - 1 ] = swap; + swap = values[i]; + values[i] = values[i - 1]; + values[i - 1] = swap; done = false; } } @@ -6469,11 +6374,11 @@ inline float median_float(float* values, int size) // return median if ((size % 2) == 0) { - return (values[ middle ] + values[ middle - 1 ]) / 2.0; + return (values[middle] + values[middle - 1]) / 2.0; } else { - return (values[ middle ]); + return (values[middle]); } } diff --git a/software/packJPG_library/lib_src/packjpg.h b/software/packJPG_library/lib_src/packjpg.h index 0a05791..088249e 100644 --- a/software/packJPG_library/lib_src/packjpg.h +++ b/software/packJPG_library/lib_src/packjpg.h @@ -73,6 +73,61 @@ public: } } + /************************************************************************** + * Library functions + *************************************************************************/ + + bool pjglib_convert_stream2stream(char* msg); + + bool pjglib_convert_file2file(char* in, char* out, char* msg); + + bool pjglib_convert_stream2mem( + unsigned char** out_file, + unsigned int* out_size, + char* msg); + + void pjglib_init_streams( + void* in_src, + int in_type, + int in_size, + void* out_dest, + int out_type); + + /************************************************************************** + * Main interface functions + *************************************************************************/ + + void process_file(void); + + void execute(bool (*function)()); + + /************************************************************************** + * Main functions + *************************************************************************/ + + bool reset_buffers(void); + + bool read_jpeg(void); + + bool merge_jpeg(void); + + bool decode_jpeg(void); + + bool recode_jpeg(void); + + bool adapt_icos(void); + + bool predict_dc(void); + + bool unpredict_dc(void); + + bool check_value_range(void); + + bool calc_zdst_lists(void); + + bool pack_pjg(void); + + bool unpack_pjg(void); private: