jpge.h

// jpge.h - C++ class for JPEG compression.
// Public domain, Rich Geldreich <richgel99@gmail.com>
// Alex Evans: Added RGBA support, linear memory allocator.
#ifndef JPEG_ENCODER_H
#define JPEG_ENCODER_H

namespace jpge {
typedef unsigned char uint8;
typedef signed short int16;
typedef signed int int32;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef unsigned int uint;

// JPEG chroma subsampling factors. Y_ONLY (grayscale images) and H2V2 (color
// images) are the most common.
enum subsampling_t { Y_ONLY = 0, H1V1 = 1, H2V1 = 2, H2V2 = 3 };

// JPEG compression parameters structure.
struct params {
  inline params()
      : m_quality(85), m_subsampling(H2V2), m_no_chroma_discrim_flag(false),
        m_two_pass_flag(false) {}

  inline bool check() const {
    if ((m_quality < 1) || (m_quality > 100))
      return false;
    if ((uint)m_subsampling > (uint)H2V2)
      return false;
    return true;
  }

  // Quality: 1-100, higher is better. Typical values are around 50-95.
  int m_quality;

  // m_subsampling:
  // 0 = Y (grayscale) only
  // 1 = YCbCr, no subsampling (H1V1, YCbCr 1x1x1, 3 blocks per MCU)
  // 2 = YCbCr, H2V1 subsampling (YCbCr 2x1x1, 4 blocks per MCU)
  // 3 = YCbCr, H2V2 subsampling (YCbCr 4x1x1, 6 blocks per MCU-- very common)
  subsampling_t m_subsampling;

  // Disables CbCr discrimination - only intended for testing.
  // If true, the Y quantization table is also used for the CbCr channels.
  bool m_no_chroma_discrim_flag;

  bool m_two_pass_flag;
};

// Writes JPEG image to a file.
// num_channels must be 1 (Y) or 3 (RGB), image pitch must be
// width*num_channels.
bool compress_image_to_jpeg_file(const char *pFilename, int width, int height,
                                 int num_channels, const uint8 *pImage_data,
                                 const params &comp_params = params());

// Writes JPEG image to memory buffer.
// On entry, buf_size is the size of the output buffer pointed at by pBuf, which
// should be at least ~1024 bytes.
// If return value is true, buf_size will be set to the size of the compressed
// data.
bool compress_image_to_jpeg_file_in_memory(
    void *pBuf, int &buf_size, int width, int height, int num_channels,
    const uint8 *pImage_data, const params &comp_params = params());

// Output stream abstract class - used by the jpeg_encoder class to write to the
// output stream.
// put_buf() is generally called with len==JPGE_OUT_BUF_SIZE bytes, but for
// headers it'll be called with smaller amounts.
class output_stream {
public:
  virtual ~output_stream() {};
  virtual bool put_buf(const void *Pbuf, int len) = 0;
  template <class T> inline bool put_obj(const T &obj) {
    return put_buf(&obj, sizeof(T));
  }
};

// Lower level jpeg_encoder class - useful if more control is needed than the
// above helper functions.
class jpeg_encoder {
public:
  jpeg_encoder();
  ~jpeg_encoder();

  // Initializes the compressor.
  // pStream: The stream object to use for writing compressed data.
  // params - Compression parameters structure, defined above.
  // width, height  - Image dimensions.
  // channels - May be 1, or 3. 1 indicates grayscale, 3 indicates RGB source
  // data.
  // Returns false on out of memory or if a stream write fails.
  bool init(output_stream *pStream, int width, int height, int src_channels,
            const params &comp_params = params());

  const params &get_params() const { return m_params; }

  // Deinitializes the compressor, freeing any allocated memory. May be called
  // at any time.
  void deinit();

  uint get_total_passes() const { return m_params.m_two_pass_flag ? 2 : 1; }
  inline uint get_cur_pass() { return m_pass_num; }

  // Call this method with each source scanline.
  // width * src_channels bytes per scanline is expected (RGB or Y format).
  // You must call with NULL after all scanlines are processed to finish
  // compression.
  // Returns false on out of memory or if a stream write fails.
  bool process_scanline(const void *pScanline);

private:
  jpeg_encoder(const jpeg_encoder &);
  jpeg_encoder &operator=(const jpeg_encoder &);

  typedef int32 sample_array_t;

  output_stream *m_pStream;
  params m_params;
  uint8 m_num_components;
  uint8 m_comp_h_samp[3], m_comp_v_samp[3];
  int m_image_x, m_image_y, m_image_bpp, m_image_bpl;
  int m_image_x_mcu, m_image_y_mcu;
  int m_image_bpl_xlt, m_image_bpl_mcu;
  int m_mcus_per_row;
  int m_mcu_x, m_mcu_y;
  uint8 *m_mcu_lines[16];
  uint8 m_mcu_y_ofs;
  sample_array_t m_sample_array[64];
  int16 m_coefficient_array[64];
  int32 m_quantization_tables[2][64];
  uint m_huff_codes[4][256];
  uint8 m_huff_code_sizes[4][256];
  uint8 m_huff_bits[4][17];
  uint8 m_huff_val[4][256];
  uint32 m_huff_count[4][256];
  int m_last_dc_val[3];
  enum { JPGE_OUT_BUF_SIZE = 2048 };
  uint8 m_out_buf[JPGE_OUT_BUF_SIZE];
  uint8 *m_pOut_buf;
  uint m_out_buf_left;
  uint32 m_bit_buffer;
  uint m_bits_in;
  uint8 m_pass_num;
  bool m_all_stream_writes_succeeded;

  void optimize_huffman_table(int table_num, int table_len);
  void emit_byte(uint8 i);
  void emit_word(uint i);
  void emit_marker(int marker);
  void emit_jfif_app0();
  void emit_dqt();
  void emit_sof();
  void emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag);
  void emit_dhts();
  void emit_sos();
  void emit_markers();
  void compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits,
                             uint8 *val);
  void compute_quant_table(int32 *dst, int16 *src);
  void adjust_quant_table(int32 *dst, int32 *src);
  void first_pass_init();
  bool second_pass_init();
  bool jpg_open(int p_x_res, int p_y_res, int src_channels);
  void load_block_8_8_grey(int x);
  void load_block_8_8(int x, int y, int c);
  void load_block_16_8(int x, int c);
  void load_block_16_8_8(int x, int c);
  void load_quantized_coefficients(int component_num);
  void flush_output_buffer();
  void put_bits(uint bits, uint len);
  void code_coefficients_pass_one(int component_num);
  void code_coefficients_pass_two(int component_num);
  void code_block(int component_num);
  void process_mcu_row();
  bool terminate_pass_one();
  bool terminate_pass_two();
  bool process_end_of_image();
  void load_mcu(const void *src);
  void clear();
  void init();
};

} // namespace jpge

#endif // JPEG_ENCODER