1// jpgd.h - C++ class for JPEG decompression. 2// Public domain, Rich Geldreich <richgel99@gmail.com> 3#ifndef JPEG_DECODER_H 4#define JPEG_DECODER_H 5 6#include <stdlib.h> 7#include <stdio.h> 8#include <setjmp.h> 9 10#ifdef _MSC_VER 11 #define JPGD_NORETURN __declspec(noreturn) 12#elif defined(__GNUC__) 13 #define JPGD_NORETURN __attribute__ ((noreturn)) 14#else 15 #define JPGD_NORETURN 16#endif 17 18namespace jpgd 19{ 20 typedef unsigned char uint8; 21 typedef signed short int16; 22 typedef unsigned short uint16; 23 typedef unsigned int uint; 24 typedef signed int int32; 25 26 const char *failure_reason(void); 27 28 // Loads a JPEG image from a memory buffer or a file. 29 // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA). 30 // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB). 31 // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly. 32 // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp. 33 unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps); 34 unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps); 35 36 // Success/failure error codes. 37 enum jpgd_status 38 { 39 JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1, 40 JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE, 41 JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS, 42 JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH, 43 JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER, 44 JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS, 45 JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE, 46 JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR, 47 JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM 48 }; 49 50 // Input stream interface. 51 // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available. 52 // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set. 53 // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer. 54 // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding. 55 class jpeg_decoder_stream 56 { 57 public: 58 jpeg_decoder_stream() { } 59 virtual ~jpeg_decoder_stream() { } 60 61 // The read() method is called when the internal input buffer is empty. 62 // Parameters: 63 // pBuf - input buffer 64 // max_bytes_to_read - maximum bytes that can be written to pBuf 65 // pEOF_flag - set this to true if at end of stream (no more bytes remaining) 66 // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0). 67 // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full. 68 virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0; 69 }; 70 71 // stdio FILE stream class. 72 class jpeg_decoder_file_stream : public jpeg_decoder_stream 73 { 74 jpeg_decoder_file_stream(const jpeg_decoder_file_stream &); 75 jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &); 76 77 FILE *m_pFile; 78 bool m_eof_flag, m_error_flag; 79 80 public: 81 jpeg_decoder_file_stream(); 82 virtual ~jpeg_decoder_file_stream(); 83 84 bool open(const char *Pfilename); 85 void close(); 86 87 virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag); 88 }; 89 90 // Memory stream class. 91 class jpeg_decoder_mem_stream : public jpeg_decoder_stream 92 { 93 const uint8 *m_pSrc_data; 94 uint m_ofs, m_size; 95 96 public: 97 jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { } 98 jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { } 99 100 virtual ~jpeg_decoder_mem_stream() { } 101 102 bool open(const uint8 *pSrc_data, uint size); 103 void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; } 104 105 virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag); 106 }; 107 108 // Loads JPEG file from a jpeg_decoder_stream. 109 unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps); 110 111 enum 112 { 113 JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4, 114 JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384 115 }; 116 117 typedef int16 jpgd_quant_t; 118 typedef int16 jpgd_block_t; 119 120 class jpeg_decoder 121 { 122 public: 123 // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc. 124 // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline. 125 jpeg_decoder(jpeg_decoder_stream *pStream); 126 127 ~jpeg_decoder(); 128 129 // Call this method after constructing the object to begin decompression. 130 // If JPGD_SUCCESS is returned you may then call decode() on each scanline. 131 int begin_decoding(); 132 133 // Returns the next scan line. 134 // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1). 135 // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4). 136 // Returns JPGD_SUCCESS if a scan line has been returned. 137 // Returns JPGD_DONE if all scan lines have been returned. 138 // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info. 139 int decode(const void** pScan_line, uint* pScan_line_len); 140 141 inline jpgd_status get_error_code() const { return m_error_code; } 142 143 inline int get_width() const { return m_image_x_size; } 144 inline int get_height() const { return m_image_y_size; } 145 146 inline int get_num_components() const { return m_comps_in_frame; } 147 148 inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; } 149 inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); } 150 151 // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file). 152 inline int get_total_bytes_read() const { return m_total_bytes_read; } 153 154 private: 155 jpeg_decoder(const jpeg_decoder &); 156 jpeg_decoder &operator =(const jpeg_decoder &); 157 158 typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int); 159 160 struct huff_tables 161 { 162 bool ac_table; 163 uint look_up[256]; 164 uint look_up2[256]; 165 uint8 code_size[256]; 166 uint tree[512]; 167 }; 168 169 struct coeff_buf 170 { 171 uint8 *pData; 172 int block_num_x, block_num_y; 173 int block_len_x, block_len_y; 174 int block_size; 175 }; 176 177 struct mem_block 178 { 179 mem_block *m_pNext; 180 size_t m_used_count; 181 size_t m_size; 182 char m_data[1]; 183 }; 184 185 jmp_buf m_jmp_state; 186 mem_block *m_pMem_blocks; 187 int m_image_x_size; 188 int m_image_y_size; 189 jpeg_decoder_stream *m_pStream; 190 int m_progressive_flag; 191 uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES]; 192 uint8* m_huff_num[JPGD_MAX_HUFF_TABLES]; // pointer to number of Huffman codes per bit size 193 uint8* m_huff_val[JPGD_MAX_HUFF_TABLES]; // pointer to Huffman codes per bit size 194 jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables 195 int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported) 196 int m_comps_in_frame; // # of components in frame 197 int m_comp_h_samp[JPGD_MAX_COMPONENTS]; // component's horizontal sampling factor 198 int m_comp_v_samp[JPGD_MAX_COMPONENTS]; // component's vertical sampling factor 199 int m_comp_quant[JPGD_MAX_COMPONENTS]; // component's quantization table selector 200 int m_comp_ident[JPGD_MAX_COMPONENTS]; // component's ID 201 int m_comp_h_blocks[JPGD_MAX_COMPONENTS]; 202 int m_comp_v_blocks[JPGD_MAX_COMPONENTS]; 203 int m_comps_in_scan; // # of components in scan 204 int m_comp_list[JPGD_MAX_COMPS_IN_SCAN]; // components in this scan 205 int m_comp_dc_tab[JPGD_MAX_COMPONENTS]; // component's DC Huffman coding table selector 206 int m_comp_ac_tab[JPGD_MAX_COMPONENTS]; // component's AC Huffman coding table selector 207 int m_spectral_start; // spectral selection start 208 int m_spectral_end; // spectral selection end 209 int m_successive_low; // successive approximation low 210 int m_successive_high; // successive approximation high 211 int m_max_mcu_x_size; // MCU's max. X size in pixels 212 int m_max_mcu_y_size; // MCU's max. Y size in pixels 213 int m_blocks_per_mcu; 214 int m_max_blocks_per_row; 215 int m_mcus_per_row, m_mcus_per_col; 216 int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU]; 217 int m_total_lines_left; // total # lines left in image 218 int m_mcu_lines_left; // total # lines left in this MCU 219 int m_real_dest_bytes_per_scan_line; 220 int m_dest_bytes_per_scan_line; // rounded up 221 int m_dest_bytes_per_pixel; // 4 (RGB) or 1 (Y) 222 huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES]; 223 coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS]; 224 coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS]; 225 int m_eob_run; 226 int m_block_y_mcu[JPGD_MAX_COMPONENTS]; 227 uint8* m_pIn_buf_ofs; 228 int m_in_buf_left; 229 int m_tem_flag; 230 bool m_eof_flag; 231 uint8 m_in_buf_pad_start[128]; 232 uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128]; 233 uint8 m_in_buf_pad_end[128]; 234 int m_bits_left; 235 uint m_bit_buf; 236 int m_restart_interval; 237 int m_restarts_left; 238 int m_next_restart_num; 239 int m_max_mcus_per_row; 240 int m_max_blocks_per_mcu; 241 int m_expanded_blocks_per_mcu; 242 int m_expanded_blocks_per_row; 243 int m_expanded_blocks_per_component; 244 bool m_freq_domain_chroma_upsample; 245 int m_max_mcus_per_col; 246 uint m_last_dc_val[JPGD_MAX_COMPONENTS]; 247 jpgd_block_t* m_pMCU_coefficients; 248 int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU]; 249 uint8* m_pSample_buf; 250 int m_crr[256]; 251 int m_cbb[256]; 252 int m_crg[256]; 253 int m_cbg[256]; 254 uint8* m_pScan_line_0; 255 uint8* m_pScan_line_1; 256 jpgd_status m_error_code; 257 bool m_ready_flag; 258 int m_total_bytes_read; 259 260 void free_all_blocks(); 261 JPGD_NORETURN void stop_decoding(jpgd_status status); 262 void *alloc(size_t n, bool zero = false); 263 void word_clear(void *p, uint16 c, uint n); 264 void prep_in_buffer(); 265 void read_dht_marker(); 266 void read_dqt_marker(); 267 void read_sof_marker(); 268 void skip_variable_marker(); 269 void read_dri_marker(); 270 void read_sos_marker(); 271 int next_marker(); 272 int process_markers(); 273 void locate_soi_marker(); 274 void locate_sof_marker(); 275 int locate_sos_marker(); 276 void init(jpeg_decoder_stream * pStream); 277 void create_look_ups(); 278 void fix_in_buffer(); 279 void transform_mcu(int mcu_row); 280 void transform_mcu_expand(int mcu_row); 281 coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y); 282 inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y); 283 void load_next_row(); 284 void decode_next_row(); 285 void make_huff_table(int index, huff_tables *pH); 286 void check_quant_tables(); 287 void check_huff_tables(); 288 void calc_mcu_block_order(); 289 int init_scan(); 290 void init_frame(); 291 void process_restart(); 292 void decode_scan(pDecode_block_func decode_block_func); 293 void init_progressive(); 294 void init_sequential(); 295 void decode_start(); 296 void decode_init(jpeg_decoder_stream * pStream); 297 void H2V2Convert(); 298 void H2V1Convert(); 299 void H1V2Convert(); 300 void H1V1Convert(); 301 void gray_convert(); 302 void expanded_convert(); 303 void find_eoi(); 304 inline uint get_char(); 305 inline uint get_char(bool *pPadding_flag); 306 inline void stuff_char(uint8 q); 307 inline uint8 get_octet(); 308 inline uint get_bits(int num_bits); 309 inline uint get_bits_no_markers(int numbits); 310 inline int huff_decode(huff_tables *pH); 311 inline int huff_decode(huff_tables *pH, int& extrabits); 312 static inline uint8 clamp(int i); 313 static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y); 314 static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y); 315 static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y); 316 static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y); 317 }; 318 319} // namespace jpgd 320 321#endif // JPEG_DECODER_H