OpenJPH Open-source implementation of JPEG2000 Part-15

Loading...
Searching...
No Matches
ojph_codeblock.cpp
Go to the documentation of this file.
1
2//***************************************************************************/
3// This software is released under the 2-Clause BSD license, included
4// below.
5//
6// Copyright (c) 2019, Aous Naman
7// Copyright (c) 2019, Kakadu Software Pty Ltd, Australia
8// Copyright (c) 2019, The University of New South Wales, Australia
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
22// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
24// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32//***************************************************************************/
33// This file is part of the OpenJPH software implementation.
34// File: ojph_codeblock.cpp
35// Author: Aous Naman
36// Date: 28 August 2019
37//***************************************************************************/
38
39
40#include <climits>
41#include <cmath>
42
43#include "ojph_mem.h"
44#include "ojph_params.h"
45#include "ojph_codestream_local.h"
46#include "ojph_codeblock.h"
47#include "ojph_subband.h"
48#include "ojph_resolution.h"
49
50 namespace ojph {
51
52 namespace local
53 {
54
56 void codeblock::pre_alloc(codestream *codestream, const size& nominal,
57 ui32 precision)
58 {
59 mem_fixed_allocator* allocator = codestream->get_allocator();
60
61 assert(byte_alignment / sizeof(ui32) > 1);
62 const ui32 f = byte_alignment / sizeof(ui32) - 1;
63 ui32 stride = (nominal.w + f) & ~f; // a multiple of 8
64
65 if (precision <= 32)
66 allocator->pre_alloc_data<ui32>(nominal.h * (size_t)stride, 0);
67 else
68 allocator->pre_alloc_data<ui64>(nominal.h * (size_t)stride, 0);
69 }
70
72 void codeblock::finalize_alloc(codestream *codestream,
73 subband *parent, const size& nominal,
74 const size& cb_size,
75 coded_cb_header* coded_cb,
76 ui32 K_max, int line_offset,
77 ui32 precision, ui32 comp_idx)
78 {
79 mem_fixed_allocator* allocator = codestream->get_allocator();
80
81 const ui32 f = byte_alignment / sizeof(ui32) - 1;
82 this->stride = (nominal.w + f) & ~f; // a multiple of 8
83 this->buf_size = this->stride * nominal.h;
84
85 if (precision <= 32) {
86 this->precision = BUF32;
87 this->buf32 = allocator->post_alloc_data<ui32>(this->buf_size, 0);
88 }
89 else {
90 this->precision = BUF64;
91 this->buf64 = allocator->post_alloc_data<ui64>(this->buf_size, 0);
92 }
93
94 this->nominal_size = nominal;
95 this->cb_size = cb_size;
96 this->parent = parent;
97 this->line_offset = line_offset;
98 this->cur_line = 0;
99 this->delta = parent->get_delta();
100 this->delta_inv = 1.0f / this->delta;
101 this->K_max = K_max;
102 for (int i = 0; i < 4; ++i)
103 this->max_val64[i] = 0;
104 const param_cod* coc = codestream->get_coc(comp_idx);
105 this->reversible = coc->is_reversible();
106 this->resilient = codestream->is_resilient();
107 this->stripe_causal = coc->get_block_vertical_causality();
108 this->zero_block = false;
109 this->coded_cb = coded_cb;
110
111 this->codeblock_functions.init(reversible);
112 }
113
115 void codeblock::push(line_buf *line)
116 {
117 // convert to sign and magnitude and keep max_val
118 if (precision == BUF32)
119 {
120 assert(line->flags & line_buf::LFT_32BIT);
121 const si32 *sp = line->i32 + line_offset;
122 ui32 *dp = buf32 + cur_line * stride;
123 this->codeblock_functions.tx_to_cb32(sp, dp, K_max, delta_inv,
124 cb_size.w, max_val32);
125 ++cur_line;
126 }
127 else
128 {
129 assert(precision == BUF64);
130 assert(line->flags & line_buf::LFT_64BIT);
131 const si64 *sp = line->i64 + line_offset;
132 ui64 *dp = buf64 + cur_line * stride;
133 this->codeblock_functions.tx_to_cb64(sp, dp, K_max, delta_inv,
134 cb_size.w, max_val64);
135 ++cur_line;
136 }
137 }
138
140 void codeblock::encode(mem_elastic_allocator *elastic)
141 {
142 if (precision == BUF32)
143 {
144 ui32 mv = this->codeblock_functions.find_max_val32(max_val32);
145 if (mv >= 1u << (31 - K_max))
146 {
147 coded_cb->missing_msbs = K_max - 1;
148 assert(coded_cb->missing_msbs > 0);
149 assert(coded_cb->missing_msbs < K_max);
150 coded_cb->num_passes = 1;
151
152 this->codeblock_functions.encode_cb32(buf32, K_max-1, 1,
153 cb_size.w, cb_size.h, stride, coded_cb->pass_length,
154 elastic, coded_cb->next_coded);
155 }
156 }
157 else
158 {
159 assert(precision == BUF64);
160 ui64 mv = this->codeblock_functions.find_max_val64(max_val64);
161 if (mv >= 1ULL << (63 - K_max))
162 {
163 coded_cb->missing_msbs = K_max - 1;
164 assert(coded_cb->missing_msbs > 0);
165 assert(coded_cb->missing_msbs < K_max);
166 coded_cb->num_passes = 1;
167
168 this->codeblock_functions.encode_cb64(buf64, K_max-1, 1,
169 cb_size.w, cb_size.h, stride, coded_cb->pass_length,
170 elastic, coded_cb->next_coded);
171 }
172 }
173 }
174
176 void codeblock::recreate(const size &cb_size, coded_cb_header* coded_cb)
177 {
178 assert(cb_size.h * stride <= buf_size && cb_size.w <= stride);
179 this->cb_size = cb_size;
180 this->coded_cb = coded_cb;
181 this->cur_line = 0;
182 for (int i = 0; i < 4; ++i)
183 this->max_val64[i] = 0;
184 this->zero_block = false;
185 }
186
188 void codeblock::decode()
189 {
190 if (coded_cb->pass_length[0] > 0 && coded_cb->num_passes > 0 &&
191 coded_cb->next_coded != NULL)
192 {
193 bool result;
194 if (precision == BUF32)
195 {
196 result = this->codeblock_functions.decode_cb32(
197 coded_cb->next_coded->buf + coded_cb_header::prefix_buf_size,
198 buf32, coded_cb->missing_msbs, coded_cb->num_passes,
199 coded_cb->pass_length[0], coded_cb->pass_length[1],
200 cb_size.w, cb_size.h, stride, stripe_causal);
201 }
202 else
203 {
204 assert(precision == BUF64);
205 result = this->codeblock_functions.decode_cb64(
206 coded_cb->next_coded->buf + coded_cb_header::prefix_buf_size,
207 buf64, coded_cb->missing_msbs, coded_cb->num_passes,
208 coded_cb->pass_length[0], coded_cb->pass_length[1],
209 cb_size.w, cb_size.h, stride, stripe_causal);
210 }
211
212 if (result == false)
213 {
214 if (resilient == true) {
215 OJPH_INFO(0x000300A1, "Error decoding a codeblock.");
216 zero_block = true;
217 }
218 else
219 OJPH_ERROR(0x000300A1, "Error decoding a codeblock.");
220 }
221 }
222 else
223 zero_block = true;
224 }
225
226
228 void codeblock::pull_line(line_buf *line)
229 {
230 //convert to sign and magnitude
231 if (precision == BUF32)
232 {
233 assert(line->flags & line_buf::LFT_32BIT);
234 si32 *dp = line->i32 + line_offset;
235 if (!zero_block)
236 {
237 const ui32 *sp = buf32 + cur_line * stride;
238 this->codeblock_functions.tx_from_cb32(sp, dp, K_max, delta,
239 cb_size.w);
240 }
241 else
242 this->codeblock_functions.mem_clear(dp, cb_size.w * sizeof(ui32));
243 }
244 else
245 {
246 assert(precision == BUF64);
247 assert(line->flags & line_buf::LFT_64BIT);
248 si64 *dp = line->i64 + line_offset;
249 if (!zero_block)
250 {
251 const ui64 *sp = buf64 + cur_line * stride;
252 this->codeblock_functions.tx_from_cb64(sp, dp, K_max, delta,
253 cb_size.w);
254 }
255 else
256 this->codeblock_functions.mem_clear(dp, cb_size.w * sizeof(*dp));
257 }
258
259 ++cur_line;
260 assert(cur_line <= cb_size.h);
261 }
262
263 }
264}
ojph::line_buf
Definition ojph_mem.h:160
ojph::line_buf::LFT_32BIT
@ LFT_32BIT
Definition ojph_mem.h:167
ojph::line_buf::LFT_64BIT
@ LFT_64BIT
Definition ojph_mem.h:168
ojph::line_buf::i64
si64 * i64
Definition ojph_mem.h:185
ojph::line_buf::flags
ui32 flags
Definition ojph_mem.h:182
ojph::line_buf::i32
si32 * i32
Definition ojph_mem.h:184
ojph::local::codeblock::nominal_size
size nominal_size
Definition ojph_codeblock.h:93
ojph::local::codeblock::line_offset
int line_offset
Definition ojph_codeblock.h:98
ojph::local::codeblock::max_val64
ui64 max_val64[4]
Definition ojph_codeblock.h:108
ojph::local::codeblock::stripe_causal
bool stripe_causal
Definition ojph_codeblock.h:104
ojph::local::codeblock::resilient
bool resilient
Definition ojph_codeblock.h:103
ojph::local::codeblock::coded_cb
coded_cb_header * coded_cb
Definition ojph_codeblock.h:110
ojph::local::codeblock::decode
void decode()
Definition ojph_codeblock.cpp:188
ojph::local::codeblock::parent
subband * parent
Definition ojph_codeblock.h:97
ojph::local::codeblock::finalize_alloc
void finalize_alloc(codestream *codestream, subband *parent, const size &nominal, const size &cb_size, coded_cb_header *coded_cb, ui32 K_max, int tbx0, ui32 precision, ui32 comp_idx)
Definition ojph_codeblock.cpp:72
ojph::local::codeblock::precision
ui32 precision
Definition ojph_codeblock.h:88
ojph::local::codeblock::push
void push(line_buf *line)
Definition ojph_codeblock.cpp:115
ojph::local::codeblock::buf64
ui64 * buf64
Definition ojph_codeblock.h:91
ojph::local::codeblock::cb_size
size cb_size
Definition ojph_codeblock.h:94
ojph::local::codeblock::buf_size
ui32 buf_size
Definition ojph_codeblock.h:96
ojph::local::codeblock::K_max
ui32 K_max
Definition ojph_codeblock.h:101
ojph::local::codeblock::pre_alloc
static void pre_alloc(codestream *codestream, const size &nominal, ui32 precision)
Definition ojph_codeblock.cpp:56
ojph::local::codeblock::delta_inv
float delta_inv
Definition ojph_codeblock.h:100
ojph::local::codeblock::encode
void encode(mem_elastic_allocator *elastic)
Definition ojph_codeblock.cpp:140
ojph::local::codeblock::BUF32
@ BUF32
Definition ojph_codeblock.h:69
ojph::local::codeblock::BUF64
@ BUF64
Definition ojph_codeblock.h:70
ojph::local::codeblock::recreate
void recreate(const size &cb_size, coded_cb_header *coded_cb)
Definition ojph_codeblock.cpp:176
ojph::local::codeblock::delta
float delta
Definition ojph_codeblock.h:100
ojph::local::codeblock::max_val32
ui32 max_val32[8]
Definition ojph_codeblock.h:107
ojph::local::codeblock::stride
ui32 stride
Definition ojph_codeblock.h:95
ojph::local::codeblock::reversible
bool reversible
Definition ojph_codeblock.h:102
ojph::local::codeblock::cur_line
ui32 cur_line
Definition ojph_codeblock.h:99
ojph::local::codeblock::zero_block
bool zero_block
Definition ojph_codeblock.h:105
ojph::local::codeblock::codeblock_functions
codeblock_fun codeblock_functions
Definition ojph_codeblock.h:111
ojph::local::codeblock::pull_line
void pull_line(line_buf *line)
Definition ojph_codeblock.cpp:228
ojph::local::codeblock::buf32
ui32 * buf32
Definition ojph_codeblock.h:90
ojph::local::codestream
Definition ojph_codestream_local.h:69
ojph::local::codestream::is_resilient
bool is_resilient()
Definition ojph_codestream_local.h:105
ojph::local::codestream::get_coc
const param_cod * get_coc(ui32 comp_num)
Definition ojph_codestream_local.h:89
ojph::local::codestream::get_allocator
mem_fixed_allocator * get_allocator()
Definition ojph_codestream_local.h:97
ojph::local::subband
Definition ojph_subband.h:63
ojph::mem_elastic_allocator
Definition ojph_mem.h:217
ojph::mem_fixed_allocator
Definition ojph_mem.h:58
ojph::mem_fixed_allocator::pre_alloc_data
void pre_alloc_data(size_t num_ele, ui32 pre_size)
Definition ojph_mem.h:71
ojph::mem_fixed_allocator::post_alloc_data
T * post_alloc_data(size_t num_ele, ui32 pre_size)
Definition ojph_mem.h:111
ojph::local
Definition ojph_bitbuffer_read.h:52
ojph
Definition ojph_img_io.h:52
ojph::byte_alignment
const ui32 byte_alignment
Definition ojph_arch.h:286
ojph::si64
int64_t si64
Definition ojph_defs.h:57
ojph::ui64
uint64_t ui64
Definition ojph_defs.h:56
ojph::si32
int32_t si32
Definition ojph_defs.h:55
ojph::ui32
uint32_t ui32
Definition ojph_defs.h:54
ojph_codeblock.h
ojph_codestream_local.h
ojph_mem.h
OJPH_INFO
#define OJPH_INFO(t,...)
MACROs to insert file and line number for info, warning, and error.
Definition ojph_message.h:284
OJPH_ERROR
#define OJPH_ERROR(t,...)
Definition ojph_message.h:288
ojph_params.h
ojph_resolution.h
ojph_subband.h
ojph::local::coded_cb_header
Definition ojph_codeblock.h:116
ojph::local::coded_cb_header::prefix_buf_size
static const int prefix_buf_size
Definition ojph_codeblock.h:123
ojph::local::param_cod
Definition ojph_params_local.h:371
ojph::local::param_cod::get_block_vertical_causality
bool get_block_vertical_causality() const
Definition ojph_params_local.h:564
ojph::local::param_cod::is_reversible
bool is_reversible() const
Definition ojph_params.cpp:843
ojph::size
Definition ojph_base.h:48
ojph::size::w
ui32 w
Definition ojph_base.h:50
ojph::size::h
ui32 h
Definition ojph_base.h:51