CodeStream.h

Go to the documentation of this file.

/*
 *    Copyright (C) 2016-2020 Grok Image Compression Inc.
 *
 *    This source code is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This source code is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 *    This source code incorporates work covered by the BSD 2-clause license.
 *    Please see the LICENSE file in the root directory for details.
 *
 */
 
#pragma once
 
#include <vector>
#include <map>
#include "CodingParams.h"
 
namespace grk {
 
// includes marker and marker length (4 bytes)
const uint32_t sot_marker_segment_len = 12U;
 
const uint32_t SPCod_SPCoc_len = 5U;
const uint32_t cod_coc_len = 5U;
const uint32_t tlm_len_per_tile_part = 5;
 
 
const uint32_t  GRK_COMP_PARAM_DEFAULT_CBLOCKW  =      64;
const uint32_t  GRK_COMP_PARAM_DEFAULT_CBLOCKH  =      64;
const GRK_PROG_ORDER  GRK_COMP_PARAM_DEFAULT_PROG_ORDER   =  GRK_LRCP;
const uint32_t  GRK_COMP_PARAM_DEFAULT_NUMRESOLUTION =  6;
 
// limits defined in JPEG 2000 standard
const uint32_t max_precision_jpeg_2000 = 38; // maximum number of magnitude bits, according to ISO standard
const uint32_t max_num_components = 16384;      // maximum allowed number components
const uint32_t max_passes_per_segment = (max_precision_jpeg_2000-1) * 3 +1;
const uint32_t max_num_tiles = 65535;
const uint32_t max_num_tile_parts_per_tile = 255;
const uint32_t max_num_tile_parts = 65535;
// includes tile part header
const uint32_t max_tile_part_size = UINT_MAX;
 
// limits in Grok library
const uint64_t max_tile_area = 67108864000;
const uint32_t max_supported_precision = 16; // maximum supported precision for Grok library
const uint32_t default_numbers_segments = 10;
const uint32_t default_header_size = 1000;
const uint32_t default_number_mcc_records = 10;
const uint32_t default_number_mct_records = 10;
 
#define J2K_CP_CSTY_PRT 0x01
#define J2K_CP_CSTY_SOP 0x02
#define J2K_CP_CSTY_EPH 0x04
#define J2K_CCP_CSTY_PRT 0x01
#define J2K_CCP_QNTSTY_NOQNT 0 // no quantization
#define J2K_CCP_QNTSTY_SIQNT 1 // derived quantization
#define J2K_CCP_QNTSTY_SEQNT 2 // expounded quantization
 
#define GRK_J2K_DEFAULT_CBLK_DATA_SIZE 8192
 
#define J2K_MS_SOC 0xff4f       
#define J2K_MS_SOT 0xff90       
#define J2K_MS_SOD 0xff93       
#define J2K_MS_EOC 0xffd9       
#define J2K_MS_CAP 0xff50       
#define J2K_MS_SIZ 0xff51       
#define J2K_MS_COD 0xff52       
#define J2K_MS_COC 0xff53       
#define J2K_MS_RGN 0xff5e       
#define J2K_MS_QCD 0xff5c       
#define J2K_MS_QCC 0xff5d       
#define J2K_MS_POC 0xff5f       
#define J2K_MS_TLM 0xff55       
#define J2K_MS_PLM 0xff57       
#define J2K_MS_PLT 0xff58       
#define J2K_MS_PPM 0xff60       
#define J2K_MS_PPT 0xff61       
#define J2K_MS_SOP 0xff91       
#define J2K_MS_EPH 0xff92       
#define J2K_MS_CRG 0xff63       
#define J2K_MS_COM 0xff64       
#define J2K_MS_CBD 0xff78       
#define J2K_MS_MCC 0xff75       
#define J2K_MS_MCT 0xff74       
#define J2K_MS_MCO 0xff77       
#define J2K_MS_UNK 0            
enum J2K_STATUS {
        J2K_DEC_STATE_NONE = 0x0000, 
        J2K_DEC_STATE_MH_SOC = 0x0001, 
        J2K_DEC_STATE_MH_SIZ = 0x0002, 
        J2K_DEC_STATE_MH = 0x0004, 
        J2K_DEC_STATE_TPH_SOT = 0x0008, 
        J2K_DEC_STATE_TPH = 0x0010, 
        J2K_DEC_STATE_NO_EOC = 0x0020, 
        J2K_DEC_STATE_DATA = 0x0040, 
        J2K_DEC_STATE_EOC = 0x0080, 
        J2K_DEC_STATE_ERR = 0x0100 
};
 
struct TileProcessor;
typedef bool (*j2k_procedure)(CodeStream *codeStream, TileProcessor *tileProcessor, BufferedStream *stream);
 
 
struct  grk_dec_memory_marker_handler  {
        uint16_t id;
        uint32_t states;
        bool (*handler)(CodeStream *codeStream, TileProcessor *tileProcessor,
                        uint8_t *p_header_data, uint16_t header_size);
} ;
 
struct CodeStream {
 
        CodeStream(bool decode);
        ~CodeStream();
 
        bool isDecodingTilePartHeader() ;
        TileCodingParams* get_current_decode_tcp(TileProcessor *tileProcessor);
 
        bool read_marker(BufferedStream *stream, uint16_t *val);
 
        bool process_marker(const grk_dec_memory_marker_handler* marker_handler,
                                                uint16_t current_marker, uint16_t marker_size,
                                                TileProcessor *tileProcessor,   BufferedStream *stream);
 
        bool set_decompress_area(grk_image *p_image,
                                                uint32_t start_x,
                                                uint32_t start_y,
                                                uint32_t end_x,
                                                uint32_t end_y);
 
        bool alloc_multi_tile_output_data(grk_image *p_output_image);
 
 
        // state of decoder/encoder
        DecoderState m_decoder;
        EncoderState m_encoder;
 
        grk_image *m_input_image;
 
        /* output image (for decompress) */
        grk_image *m_output_image;
 
        CodingParams m_cp;
 
        std::vector<j2k_procedure> m_procedure_list;
 
        std::vector<j2k_procedure> m_validation_list;
 
         grk_codestream_index  *cstr_index;
 
        TileProcessor *m_tileProcessor;
 
 
        int32_t m_tile_ind_to_dec;
 
private:
 
        uint8_t *m_marker_scratch;
        uint16_t m_marker_scratch_size;
public:
    bool   whole_tile_decoding;
        grk_plugin_tile *current_plugin_tile;
        bool m_nb_tile_parts_correction_checked;
        bool m_nb_tile_parts_correction;
 
};
 
/* ----------------------------------------------------------------------- */
 
void j2k_init_decompressor(void *j2k,  grk_dparameters  *parameters);
 
bool j2k_init_compress(CodeStream *codeStream,  grk_cparameters  *parameters,
                grk_image *image);
 
char* j2k_convert_progression_order(GRK_PROG_ORDER prg_order);
 
/* ----------------------------------------------------------------------- */
 
bool j2k_end_decompress(CodeStream *j2k, BufferedStream *stream);
 
bool j2k_read_header(BufferedStream *stream, CodeStream *codeStream,
                 grk_header_info  *header_info, grk_image **image);
 
void j2k_destroy(CodeStream *codeStream);
 
 
bool j2k_read_tile_header(CodeStream *codeStream, TileProcessor *tileProcessor,
                bool *can_decode_tile_data, BufferedStream *stream);
 
bool j2k_set_decompress_area(CodeStream *codeStream, grk_image *image, uint32_t start_x,
                uint32_t start_y, uint32_t end_x, uint32_t end_y);
 
bool j2k_decompress(CodeStream *codeStream, grk_plugin_tile *tile, BufferedStream *stream,
                grk_image *image);
 
bool j2k_decompress_tile(CodeStream *codeStream, BufferedStream *stream, grk_image *p_image, uint16_t tile_index);
 
 
bool j2k_compress_tile(CodeStream *codeStream, TileProcessor *tileProcessor,
                uint16_t tile_index, uint8_t *p_data,
                uint64_t uncompressed_data_size, BufferedStream *stream);
 
bool j2k_compress(CodeStream *codeStream, grk_plugin_tile *tile, BufferedStream *stream);
 
bool j2k_start_compress(CodeStream *codeStream, BufferedStream *stream);
 
bool j2k_end_compress(CodeStream *codeStream, BufferedStream *stream);
 
bool j2k_init_mct_encoding(TileCodingParams *p_tcp, grk_image *p_image);
 
}