CodingParams.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 "HTParams.h"
 
namespace grk {
 
enum J2K_MCT_ELEMENT_TYPE {
        MCT_TYPE_INT16 = 0, 
        MCT_TYPE_INT32 = 1, 
        MCT_TYPE_FLOAT = 2, 
        MCT_TYPE_DOUBLE = 3 
};
 
enum J2K_MCT_ARRAY_TYPE {
        MCT_TYPE_DEPENDENCY = 0, MCT_TYPE_DECORRELATION = 1, MCT_TYPE_OFFSET = 2
};
 
 
struct TileComponentCodingParams {
        uint8_t csty;
        uint32_t numresolutions;
        uint32_t cblkw;
        uint32_t cblkh;
 
        Quantizer quant;
 
        uint8_t cblk_sty;
        uint8_t qmfbid;
        // true if quantization marker was read from QCC otherwise false
        bool fromQCC;
        // true if quantization marker was read from tile header
        bool fromTileHeader;
        uint8_t qntsty;
        grk_stepsize stepsizes[GRK_J2K_MAXBANDS];
        // number of step sizes read from QCC marker
        uint8_t numStepSizes;
        uint8_t numgbits;
        uint32_t roishift;
        uint32_t prcw[GRK_J2K_MAXRLVLS];
        uint32_t prch[GRK_J2K_MAXRLVLS];
        int32_t m_dc_level_shift;
};
 
 
 
struct grk_mct_data {
        J2K_MCT_ELEMENT_TYPE m_element_type;
        J2K_MCT_ARRAY_TYPE m_array_type;
        uint32_t m_index;
        uint8_t *m_data;
        uint32_t m_data_size;
};
 
struct grk_simple_mcc_decorrelation_data {
        uint32_t m_index;
        uint32_t m_nb_comps;
        grk_mct_data *m_decorrelation_array;
        grk_mct_data *m_offset_array;
        uint32_t m_is_irreversible :1;
}
;
 
struct TileCodingParams {
        TileCodingParams();
        ~TileCodingParams();
 
        void destroy();
 
        uint32_t csty;
        GRK_PROG_ORDER prg;
        uint32_t numlayers;
        uint32_t num_layers_to_decode;
        uint32_t mct;
        double rates[100];
        uint32_t numpocs;
         grk_poc  pocs[32];
 
        uint32_t ppt_markers_count;
        grk_ppx *ppt_markers;
 
        uint8_t *ppt_data;
        uint8_t *ppt_buffer;
        size_t ppt_data_size;
        size_t ppt_len;
        double distoratio[100];
        // quantization style as read from main QCD marker
        uint32_t main_qcd_qntsty;
        // number of step sizes as read from main QCD marker
        uint32_t main_qcd_numStepSizes;
        TileComponentCodingParams *tccps;
        // current tile part number (-1 if not yet initialized
        int16_t m_tile_part_index;
 
        uint8_t m_nb_tile_parts;
 
        ChunkBuffer *m_tile_data;
 
        double *mct_norms;
        float *m_mct_decoding_matrix;
        float *m_mct_coding_matrix;
        grk_mct_data *m_mct_records;
        uint32_t m_nb_mct_records;
        uint32_t m_nb_max_mct_records;
        grk_simple_mcc_decorrelation_data *m_mcc_records;
        uint32_t m_nb_mcc_records;
        uint32_t m_nb_max_mcc_records;
 
        bool cod;
        bool ppt;
        bool POC;
 
        bool isHT;
        param_qcd qcd;
};
 
struct EncodingParams {
        size_t m_max_comp_size;
        uint32_t m_tp_pos;
        uint8_t m_tp_flag;
        bool m_disto_alloc;
        bool m_fixed_quality;
        bool m_tp_on;
        /* write plt marker */
        bool writePLT;
 
        bool writeTLM;
        /* rate control algorithm */
        uint32_t rateControlAlgorithm;
};
 
struct DecodingParams {
        uint32_t m_reduce;
        uint32_t m_layer;
};
 
struct CodingParams {
        uint16_t rsiz;
        /* Pcap */
        uint32_t pcap;
        /* Ccap */
        uint16_t ccap;
        uint32_t tx0;
        uint32_t ty0;
        uint32_t t_width;
        uint32_t t_height;
        size_t num_comments;
        char *comment[GRK_NUM_COMMENTS_SUPPORTED];
        uint16_t comment_len[GRK_NUM_COMMENTS_SUPPORTED];
        bool isBinaryComment[GRK_NUM_COMMENTS_SUPPORTED];
        uint32_t t_grid_width;
        uint32_t t_grid_height;
 
        PPMMarker *ppm_marker;
 
        TileCodingParams *tcps;
 
        union {
                DecodingParams m_dec;
                EncodingParams m_enc;
        } m_coding_params;
 
        TileLengthMarkers *tlm_markers;
        PacketLengthMarkers *plm_markers;
 
        void destroy();
 
};
 
struct DecoderState {
        DecoderState() : m_state(0),
                                        m_default_tcp(nullptr),
                                        m_start_tile_x_index(0),
                                        m_start_tile_y_index(0),
                                        m_end_tile_x_index(0),
                                        m_end_tile_y_index(0),
                                        m_last_sot_read_pos(0),
                                        m_last_tile_part(false),
                                        ready_to_decode_tile_part_data(false),
                                        m_discard_tiles(false),
                                        m_skip_data(false)
        {}
 
 
        bool findNextTile(BufferedStream *stream);
 
        uint32_t m_state;
 
        //store decoding parameters common to all tiles (information
        // like COD, COC and RGN in main header)
        TileCodingParams *m_default_tcp;
        uint32_t m_start_tile_x_index;
        uint32_t m_start_tile_y_index;
        uint32_t m_end_tile_x_index;
        uint32_t m_end_tile_y_index;
 
        uint64_t m_last_sot_read_pos;
 
        bool m_last_tile_part;
        // Indicates that a tile's data can be decoded
        bool ready_to_decode_tile_part_data;
        bool m_discard_tiles;
        bool m_skip_data;
 
};
 
struct EncoderState {
 
        EncoderState() : m_total_tile_parts(0) {}
 
        uint16_t m_total_tile_parts; /* totnum_tp */
 
};
 
}