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"
46#include "ojph_codeblock.h"
47#include "ojph_subband.h"
48#include "ojph_resolution.h"
49
50namespace ojph {
51
52 namespace local
53 {
54
57 ui32 precision)
58 {
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
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 {
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();
108 this->zero_block = false;
109 this->coded_cb = coded_cb;
110
112 }
113
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;
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;
135 ++cur_line;
136 }
137 }
138
141 {
142 if (precision == BUF32)
143 {
145 if (mv >= 1u << (31 - K_max))
146 {
148 assert(coded_cb->missing_msbs > 0);
149 assert(coded_cb->missing_msbs < K_max);
150 coded_cb->num_passes = 1;
151
154 elastic, coded_cb->next_coded);
155 }
156 }
157 else
158 {
159 assert(precision == BUF64);
161 if (mv >= 1ULL << (63 - K_max))
162 {
164 assert(coded_cb->missing_msbs > 0);
165 assert(coded_cb->missing_msbs < K_max);
166 coded_cb->num_passes = 1;
167
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
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(
201 }
202 else
203 {
204 assert(precision == BUF64);
205 result = this->codeblock_functions.decode_cb64(
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
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;
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;
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}
coded_cb_header * coded_cb
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)
void push(line_buf *line)
static void pre_alloc(codestream *codestream, const size &nominal, ui32 precision)
void encode(mem_elastic_allocator *elastic)
void recreate(const size &cb_size, coded_cb_header *coded_cb)
codeblock_fun codeblock_functions
void pull_line(line_buf *line)
const param_cod * get_coc(ui32 comp_num)
mem_fixed_allocator * get_allocator()
void pre_alloc_data(size_t num_ele, ui32 pre_size)
Definition ojph_mem.h:66
T * post_alloc_data(size_t num_ele, ui32 pre_size)
Definition ojph_mem.h:89
const ui32 byte_alignment
Definition ojph_arch.h:282
int64_t si64
Definition ojph_defs.h:57
uint64_t ui64
Definition ojph_defs.h:56
int32_t si32
Definition ojph_defs.h:55
uint32_t ui32
Definition ojph_defs.h:54
#define OJPH_INFO(t,...)
MACROs to insert file and line number for info, warning, and error.
#define OJPH_ERROR(t,...)
find_max_val_fun32 find_max_val32
find_max_val_fun64 find_max_val64
bool get_block_vertical_causality() const