1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#ifndef LIB_JPEGLI_ENCODE_INTERNAL_H_
#define LIB_JPEGLI_ENCODE_INTERNAL_H_
#include <stdint.h>
#include "lib/jpegli/bit_writer.h"
#include "lib/jpegli/common.h"
#include "lib/jpegli/common_internal.h"
#include "lib/jpegli/encode.h"
namespace jpegli {
constexpr unsigned char kICCSignature[12] = {
0x49, 0x43, 0x43, 0x5F, 0x50, 0x52, 0x4F, 0x46, 0x49, 0x4C, 0x45, 0x00};
constexpr int kICCMarker = JPEG_APP0 + 2;
constexpr int kDefaultProgressiveLevel = 0;
typedef int16_t coeff_t;
struct HuffmanCodeTable {
int depth[256];
int code[256];
};
struct Token {
uint8_t context;
uint8_t symbol;
uint16_t bits;
Token(int c, int s, int b) : context(c), symbol(s), bits(b) {}
};
struct TokenArray {
Token* tokens;
size_t num_tokens;
};
struct RefToken {
uint8_t symbol;
uint8_t refbits;
};
struct ScanTokenInfo {
RefToken* tokens;
size_t num_tokens;
uint8_t* refbits;
uint16_t* eobruns;
size_t* restarts;
size_t num_restarts;
size_t num_nonzeros;
size_t num_future_nonzeros;
size_t token_offset;
size_t restart_interval;
size_t MCUs_per_row;
size_t MCU_rows_in_scan;
size_t blocks_in_MCU;
size_t num_blocks;
};
} // namespace jpegli
struct jpeg_comp_master {
jpegli::RowBuffer<float> input_buffer[jpegli::kMaxComponents];
jpegli::RowBuffer<float>* smooth_input[jpegli::kMaxComponents];
jpegli::RowBuffer<float>* raw_data[jpegli::kMaxComponents];
bool force_baseline;
bool xyb_mode;
uint8_t cicp_transfer_function;
bool use_std_tables;
bool use_adaptive_quantization;
int progressive_level;
size_t xsize_blocks;
size_t ysize_blocks;
size_t blocks_per_iMCU_row;
jpegli::ScanTokenInfo* scan_token_info;
JpegliDataType data_type;
JpegliEndianness endianness;
void (*input_method)(const uint8_t* row_in, size_t len,
float* row_out[jpegli::kMaxComponents]);
void (*color_transform)(float* row[jpegli::kMaxComponents], size_t len);
void (*downsample_method[jpegli::kMaxComponents])(
float* rows_in[MAX_SAMP_FACTOR], size_t len, float* row_out);
float* quant_mul[jpegli::kMaxComponents];
float* zero_bias_offset[jpegli::kMaxComponents];
float* zero_bias_mul[jpegli::kMaxComponents];
int h_factor[jpegli::kMaxComponents];
int v_factor[jpegli::kMaxComponents];
// Array of Huffman tables that will be encoded in one or more DHT segments.
// In progressive mode we compute all Huffman tables that will be used in any
// of the scans, thus we can have more than 4 tables here.
JHUFF_TBL* huffman_tables;
size_t num_huffman_tables;
// Array of num_huffman_tables slot ids, where the ith element is the slot id
// of the ith Huffman table, as it appears in the DHT segment. The range of
// the slot ids is 0..3 for DC and 16..19 for AC Huffman codes.
uint8_t* slot_id_map;
// Maps context ids to an index in the huffman_tables array. Each component in
// each scan has a DC and AC context id, which are defined as follows:
// - DC context id is the component index (relative to cinfo->comp_info) of
// the scan component
// - AC context ids start at 4 and are increased for each component of each
// scan that have AC components (i.e. Se > 0)
uint8_t* context_map;
size_t num_contexts;
// Array of cinfo->num_scans context ids, where the ith element is the context
// id of the first AC component of the ith scan.
uint8_t* ac_ctx_offset;
// Array of num_huffman tables derived coding tables.
jpegli::HuffmanCodeTable* coding_tables;
float* diff_buffer;
jpegli::RowBuffer<float> fuzzy_erosion_tmp;
jpegli::RowBuffer<float> pre_erosion;
jpegli::RowBuffer<float> quant_field;
jvirt_barray_ptr* coeff_buffers;
size_t next_input_row;
size_t next_iMCU_row;
size_t next_dht_index;
size_t last_restart_interval;
JCOEF last_dc_coeff[MAX_COMPS_IN_SCAN];
jpegli::JpegBitWriter bw;
float* dct_buffer;
int32_t* block_tmp;
jpegli::TokenArray* token_arrays;
size_t cur_token_array;
jpegli::Token* next_token;
size_t num_tokens;
size_t total_num_tokens;
jpegli::RefToken* next_refinement_token;
uint8_t* next_refinement_bit;
float psnr_target;
float psnr_tolerance;
float min_distance;
float max_distance;
};
#endif // LIB_JPEGLI_ENCODE_INTERNAL_H_
|
