OpenJPH
Open-source implementation of JPEG2000 Part-15
Loading...
Searching...
No Matches
ojph_mem.h
Go to the documentation of this file.
1//***************************************************************************/
2// This software is released under the 2-Clause BSD license, included
3// below.
4//
5// Copyright (c) 2019, Aous Naman
6// Copyright (c) 2019, Kakadu Software Pty Ltd, Australia
7// Copyright (c) 2019, The University of New South Wales, Australia
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions are
11// met:
12//
13// 1. Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15//
16// 2. Redistributions in binary form must reproduce the above copyright
17// notice, this list of conditions and the following disclaimer in the
18// documentation and/or other materials provided with the distribution.
19//
20// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
21// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
23// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
26// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31//***************************************************************************/
32// This file is part of the OpenJPH software implementation.
33// File: ojph_mem.h
34// Author: Aous Naman
35// Date: 28 August 2019
36//***************************************************************************/
37
38
39#ifndef OJPH_MEM_H
40#define OJPH_MEM_H
41
42#include <cstdlib>
43#include <cassert>
44#include <cstring>
45#include <type_traits>
46
47#include "ojph_arch.h"
48
49namespace ojph {
50
53 {
54 public:
61 {
62 if (store) free(store);
63 }
64
65 template<typename T>
66 void pre_alloc_data(size_t num_ele, ui32 pre_size)
67 {
68 pre_alloc_local<T, byte_alignment>(num_ele, pre_size, size_data);
69 }
70
71 template<typename T>
72 void pre_alloc_obj(size_t num_ele)
73 {
74 pre_alloc_local<T, object_alignment>(num_ele, 0, size_obj);
75 }
76
77 void alloc()
78 {
79 assert(store == NULL);
80 avail_obj = store = malloc(size_data + size_obj);
82 if (store == NULL)
83 throw "malloc failed";
86 }
87
88 template<typename T>
89 T* post_alloc_data(size_t num_ele, ui32 pre_size)
90 {
91 return post_alloc_local<T, byte_alignment>
92 (num_ele, pre_size, avail_size_data, avail_data);
93 }
94
95 template<typename T>
96 T* post_alloc_obj(size_t num_ele)
97 {
98 return post_alloc_local<T, object_alignment>
99 (num_ele, 0, avail_size_obj, avail_obj);
100 }
101
102 private:
103 template<typename T, int N>
104 void pre_alloc_local(size_t num_ele, ui32 pre_size, size_t& sz)
105 {
106 assert(store == NULL);
107 num_ele = calc_aligned_size<T, N>(num_ele);
108 size_t total = (num_ele + pre_size) * sizeof(T);
109 total += 2*N - 1;
110
111 sz += total;
112 }
113
114 template<typename T, int N>
115 T* post_alloc_local(size_t num_ele, ui32 pre_size,
116 size_t& avail_sz, void*& avail_p)
117 {
118 assert(store != NULL);
119 num_ele = calc_aligned_size<T, N>(num_ele);
120 size_t total = (num_ele + pre_size) * sizeof(T);
121 total += 2*N - 1;
122
123 T* p = align_ptr<T, N>((T*)avail_p + pre_size);
124 avail_p = (ui8*)avail_p + total;
125 avail_sz -= total;
126 assert((avail_sz & 0x8000000000000000llu) == 0);
127 return p;
128 }
129
132 };
133
136 {
137 public:
138 enum : ui32 {
139 LFT_UNDEFINED = 0x00, // Type is undefined/uninitialized
140 // These flags reflects data size in bytes
141 LFT_BYTE = 0x01, // Set when data is 1 byte (not used)
142 LFT_16BIT = 0x02, // Set when data is 2 bytes (not used)
143 LFT_32BIT = 0x04, // Set when data is 4 bytes
144 LFT_64BIT = 0x08, // Set when data is 8 bytes
145 LFT_INTEGER = 0x10, // Set when data is an integer, in other words
146 // 32bit integer, not 32bit float
147 LFT_SIZE_MASK = 0x0F, // To extract data size
148 };
149
150 public:
152
153 template<typename T>
154 void wrap(T *buffer, size_t num_ele, ui32 pre_size);
155
156 size_t size;
159 union {
160 si32* i32; // 32bit integer type, used for lossless compression
161 si64* i64; // 64bit integer type, used for lossless compression
162 float* f32; // float type, used for lossy compression
163 void* p; // no type is associated with the pointer
164 };
165 };
166
169 {
170 lifting_buf() { line = NULL; active = false; }
172 bool active;
173 };
174
177 {
179 {
180 next_list = NULL;
182 this->buf = (ui8*)this + sizeof(coded_lists);
183 }
184
189 };
190
193 {
194 /*
195 advantage: allocate large chunks of memory
196 */
197
198 public:
202
204 {
205 while (store) {
207 free(store);
208 store = t;
209 }
210 }
211
212 void get_buffer(ui32 needed_bytes, coded_lists*& p);
213
214 private:
216 {
217 stores_list(ui32 available_bytes)
218 {
219 this->next_store = NULL;
220 this->available = available_bytes;
221 this->data = (ui8*)this + sizeof(stores_list);
222 }
223 static ui32 eval_store_bytes(ui32 available_bytes)
224 { // calculates how many bytes need to be allocated
225 return available_bytes + (ui32)sizeof(stores_list);
226 }
230 };
231
235 };
236
237
238}
239
240
241#endif // !OJPH_MEM_H
float * f32
Definition ojph_mem.h:162
void wrap(T *buffer, size_t num_ele, ui32 pre_size)
void get_buffer(ui32 needed_bytes, coded_lists *&p)
Definition ojph_mem.cpp:91
mem_elastic_allocator(ui32 chunk_size)
Definition ojph_mem.h:199
void pre_alloc_data(size_t num_ele, ui32 pre_size)
Definition ojph_mem.h:66
void pre_alloc_obj(size_t num_ele)
Definition ojph_mem.h:72
void pre_alloc_local(size_t num_ele, ui32 pre_size, size_t &sz)
Definition ojph_mem.h:104
T * post_alloc_data(size_t num_ele, ui32 pre_size)
Definition ojph_mem.h:89
T * post_alloc_obj(size_t num_ele)
Definition ojph_mem.h:96
T * post_alloc_local(size_t num_ele, ui32 pre_size, size_t &avail_sz, void *&avail_p)
Definition ojph_mem.h:115
int64_t si64
Definition ojph_defs.h:57
int32_t si32
Definition ojph_defs.h:55
uint32_t ui32
Definition ojph_defs.h:54
uint8_t ui8
Definition ojph_defs.h:50
coded_lists(ui32 size)
Definition ojph_mem.h:178
coded_lists * next_list
Definition ojph_mem.h:185
line_buf * line
Definition ojph_mem.h:171
static ui32 eval_store_bytes(ui32 available_bytes)
Definition ojph_mem.h:223