1 |
/////////////////////////////////////////////////////////////////////////////// |
2 |
// |
3 |
/// \file index_encoder.c |
4 |
/// \brief Encodes the Index field |
5 |
// |
6 |
// Author: Lasse Collin |
7 |
// |
8 |
// This file has been put into the public domain. |
9 |
// You can do whatever you want with this file. |
10 |
// |
11 |
/////////////////////////////////////////////////////////////////////////////// |
12 |
|
13 |
#include "index_encoder.h" |
14 |
#include "index.h" |
15 |
#include "check.h" |
16 |
|
17 |
|
18 |
struct lzma_coder_s { |
19 |
enum { |
20 |
SEQ_INDICATOR, |
21 |
SEQ_COUNT, |
22 |
SEQ_UNPADDED, |
23 |
SEQ_UNCOMPRESSED, |
24 |
SEQ_NEXT, |
25 |
SEQ_PADDING, |
26 |
SEQ_CRC32, |
27 |
} sequence; |
28 |
|
29 |
/// Index being encoded |
30 |
const lzma_index *index; |
31 |
|
32 |
/// Iterator for the Index being encoded |
33 |
lzma_index_iter iter; |
34 |
|
35 |
/// Position in integers |
36 |
size_t pos; |
37 |
|
38 |
/// CRC32 of the List of Records field |
39 |
uint32_t crc32; |
40 |
}; |
41 |
|
42 |
|
43 |
static lzma_ret |
44 |
index_encode(lzma_coder *coder, |
45 |
const lzma_allocator *allocator lzma_attribute((__unused__)), |
46 |
const uint8_t *restrict in lzma_attribute((__unused__)), |
47 |
size_t *restrict in_pos lzma_attribute((__unused__)), |
48 |
size_t in_size lzma_attribute((__unused__)), |
49 |
uint8_t *restrict out, size_t *restrict out_pos, |
50 |
size_t out_size, |
51 |
lzma_action action lzma_attribute((__unused__))) |
52 |
{ |
53 |
// Position where to start calculating CRC32. The idea is that we |
54 |
// need to call lzma_crc32() only once per call to index_encode(). |
55 |
const size_t out_start = *out_pos; |
56 |
|
57 |
// Return value to use if we return at the end of this function. |
58 |
// We use "goto out" to jump out of the while-switch construct |
59 |
// instead of returning directly, because that way we don't need |
60 |
// to copypaste the lzma_crc32() call to many places. |
61 |
lzma_ret ret = LZMA_OK; |
62 |
|
63 |
while (*out_pos < out_size) |
64 |
switch (coder->sequence) { |
65 |
case SEQ_INDICATOR: |
66 |
out[*out_pos] = 0x00; |
67 |
++*out_pos; |
68 |
coder->sequence = SEQ_COUNT; |
69 |
break; |
70 |
|
71 |
case SEQ_COUNT: { |
72 |
const lzma_vli count = lzma_index_block_count(coder->index); |
73 |
ret = lzma_vli_encode(count, &coder->pos, |
74 |
out, out_pos, out_size); |
75 |
if (ret != LZMA_STREAM_END) |
76 |
goto out; |
77 |
|
78 |
ret = LZMA_OK; |
79 |
coder->pos = 0; |
80 |
coder->sequence = SEQ_NEXT; |
81 |
break; |
82 |
} |
83 |
|
84 |
case SEQ_NEXT: |
85 |
if (lzma_index_iter_next( |
86 |
&coder->iter, LZMA_INDEX_ITER_BLOCK)) { |
87 |
// Get the size of the Index Padding field. |
88 |
coder->pos = lzma_index_padding_size(coder->index); |
89 |
assert(coder->pos <= 3); |
90 |
coder->sequence = SEQ_PADDING; |
91 |
break; |
92 |
} |
93 |
|
94 |
coder->sequence = SEQ_UNPADDED; |
95 |
|
96 |
// Fall through |
97 |
|
98 |
case SEQ_UNPADDED: |
99 |
case SEQ_UNCOMPRESSED: { |
100 |
const lzma_vli size = coder->sequence == SEQ_UNPADDED |
101 |
? coder->iter.block.unpadded_size |
102 |
: coder->iter.block.uncompressed_size; |
103 |
|
104 |
ret = lzma_vli_encode(size, &coder->pos, |
105 |
out, out_pos, out_size); |
106 |
if (ret != LZMA_STREAM_END) |
107 |
goto out; |
108 |
|
109 |
ret = LZMA_OK; |
110 |
coder->pos = 0; |
111 |
|
112 |
// Advance to SEQ_UNCOMPRESSED or SEQ_NEXT. |
113 |
++coder->sequence; |
114 |
break; |
115 |
} |
116 |
|
117 |
case SEQ_PADDING: |
118 |
if (coder->pos > 0) { |
119 |
--coder->pos; |
120 |
out[(*out_pos)++] = 0x00; |
121 |
break; |
122 |
} |
123 |
|
124 |
// Finish the CRC32 calculation. |
125 |
coder->crc32 = lzma_crc32(out + out_start, |
126 |
*out_pos - out_start, coder->crc32); |
127 |
|
128 |
coder->sequence = SEQ_CRC32; |
129 |
|
130 |
// Fall through |
131 |
|
132 |
case SEQ_CRC32: |
133 |
// We don't use the main loop, because we don't want |
134 |
// coder->crc32 to be touched anymore. |
135 |
do { |
136 |
if (*out_pos == out_size) |
137 |
return LZMA_OK; |
138 |
|
139 |
out[*out_pos] = (coder->crc32 >> (coder->pos * 8)) |
140 |
& 0xFF; |
141 |
++*out_pos; |
142 |
|
143 |
} while (++coder->pos < 4); |
144 |
|
145 |
return LZMA_STREAM_END; |
146 |
|
147 |
default: |
148 |
assert(0); |
149 |
return LZMA_PROG_ERROR; |
150 |
} |
151 |
|
152 |
out: |
153 |
// Update the CRC32. |
154 |
coder->crc32 = lzma_crc32(out + out_start, |
155 |
*out_pos - out_start, coder->crc32); |
156 |
|
157 |
return ret; |
158 |
} |
159 |
|
160 |
|
161 |
static void |
162 |
index_encoder_end(lzma_coder *coder, const lzma_allocator *allocator) |
163 |
{ |
164 |
lzma_free(coder, allocator); |
165 |
return; |
166 |
} |
167 |
|
168 |
|
169 |
static void |
170 |
index_encoder_reset(lzma_coder *coder, const lzma_index *i) |
171 |
{ |
172 |
lzma_index_iter_init(&coder->iter, i); |
173 |
|
174 |
coder->sequence = SEQ_INDICATOR; |
175 |
coder->index = i; |
176 |
coder->pos = 0; |
177 |
coder->crc32 = 0; |
178 |
|
179 |
return; |
180 |
} |
181 |
|
182 |
|
183 |
extern lzma_ret |
184 |
lzma_index_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator, |
185 |
const lzma_index *i) |
186 |
{ |
187 |
lzma_next_coder_init(&lzma_index_encoder_init, next, allocator); |
188 |
|
189 |
if (i == NULL) |
190 |
return LZMA_PROG_ERROR; |
191 |
|
192 |
if (next->coder == NULL) { |
193 |
next->coder = lzma_alloc(sizeof(lzma_coder), allocator); |
194 |
if (next->coder == NULL) |
195 |
return LZMA_MEM_ERROR; |
196 |
|
197 |
next->code = &index_encode; |
198 |
next->end = &index_encoder_end; |
199 |
} |
200 |
|
201 |
index_encoder_reset(next->coder, i); |
202 |
|
203 |
return LZMA_OK; |
204 |
} |
205 |
|
206 |
|
207 |
extern LZMA_API(lzma_ret) |
208 |
lzma_index_encoder(lzma_stream *strm, const lzma_index *i) |
209 |
{ |
210 |
lzma_next_strm_init(lzma_index_encoder_init, strm, i); |
211 |
|
212 |
strm->internal->supported_actions[LZMA_RUN] = true; |
213 |
strm->internal->supported_actions[LZMA_FINISH] = true; |
214 |
|
215 |
return LZMA_OK; |
216 |
} |
217 |
|
218 |
|
219 |
extern LZMA_API(lzma_ret) |
220 |
lzma_index_buffer_encode(const lzma_index *i, |
221 |
uint8_t *out, size_t *out_pos, size_t out_size) |
222 |
{ |
223 |
// Validate the arguments. |
224 |
if (i == NULL || out == NULL || out_pos == NULL || *out_pos > out_size) |
225 |
return LZMA_PROG_ERROR; |
226 |
|
227 |
// Don't try to encode if there's not enough output space. |
228 |
if (out_size - *out_pos < lzma_index_size(i)) |
229 |
return LZMA_BUF_ERROR; |
230 |
|
231 |
// The Index encoder needs just one small data structure so we can |
232 |
// allocate it on stack. |
233 |
lzma_coder coder; |
234 |
index_encoder_reset(&coder, i); |
235 |
|
236 |
// Do the actual encoding. This should never fail, but store |
237 |
// the original *out_pos just in case. |
238 |
const size_t out_start = *out_pos; |
239 |
lzma_ret ret = index_encode(&coder, NULL, NULL, NULL, 0, |
240 |
out, out_pos, out_size, LZMA_RUN); |
241 |
|
242 |
if (ret == LZMA_STREAM_END) { |
243 |
ret = LZMA_OK; |
244 |
} else { |
245 |
// We should never get here, but just in case, restore the |
246 |
// output position and set the error accordingly if something |
247 |
// goes wrong and debugging isn't enabled. |
248 |
assert(0); |
249 |
*out_pos = out_start; |
250 |
ret = LZMA_PROG_ERROR; |
251 |
} |
252 |
|
253 |
return ret; |
254 |
} |