OLD | NEW |
1 // Copyright 2014 PDFium Authors. All rights reserved. | 1 // Copyright 2014 PDFium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
6 | 6 |
7 #include "core/fxcodec/lgif/fx_gif.h" | 7 #include "core/fxcodec/lgif/fx_gif.h" |
8 | 8 |
9 #include "core/fxcodec/lbmp/fx_bmp.h" | 9 #include "core/fxcodec/lbmp/fx_bmp.h" |
10 | 10 |
11 void CGifLZWDecoder::Input(uint8_t* src_buf, FX_DWORD src_size) { | 11 void CGifLZWDecoder::Input(uint8_t* src_buf, uint32_t src_size) { |
12 next_in = src_buf; | 12 next_in = src_buf; |
13 avail_in = src_size; | 13 avail_in = src_size; |
14 } | 14 } |
15 FX_DWORD CGifLZWDecoder::GetAvailInput() { | 15 uint32_t CGifLZWDecoder::GetAvailInput() { |
16 return avail_in; | 16 return avail_in; |
17 } | 17 } |
18 void CGifLZWDecoder::InitTable(uint8_t code_len) { | 18 void CGifLZWDecoder::InitTable(uint8_t code_len) { |
19 code_size = code_len; | 19 code_size = code_len; |
20 code_clear = 1 << code_size; | 20 code_clear = 1 << code_size; |
21 code_end = code_clear + 1; | 21 code_end = code_clear + 1; |
22 bits_left = 0; | 22 bits_left = 0; |
23 code_store = 0; | 23 code_store = 0; |
24 next_in = NULL; | 24 next_in = NULL; |
25 avail_in = 0; | 25 avail_in = 0; |
(...skipping 29 matching lines...) Expand all Loading... |
55 return; | 55 return; |
56 } | 56 } |
57 code_table[code_next].prefix = prefix_code; | 57 code_table[code_next].prefix = prefix_code; |
58 code_table[code_next].suffix = append_char; | 58 code_table[code_next].suffix = append_char; |
59 if (++code_next < GIF_MAX_LZW_CODE) { | 59 if (++code_next < GIF_MAX_LZW_CODE) { |
60 if (code_next >> code_size_cur) { | 60 if (code_next >> code_size_cur) { |
61 code_size_cur++; | 61 code_size_cur++; |
62 } | 62 } |
63 } | 63 } |
64 } | 64 } |
65 int32_t CGifLZWDecoder::Decode(uint8_t* des_buf, FX_DWORD& des_size) { | 65 int32_t CGifLZWDecoder::Decode(uint8_t* des_buf, uint32_t& des_size) { |
66 if (des_size == 0) { | 66 if (des_size == 0) { |
67 return 3; | 67 return 3; |
68 } | 68 } |
69 FX_DWORD i = 0; | 69 uint32_t i = 0; |
70 if (stack_size != 0) { | 70 if (stack_size != 0) { |
71 if (des_size < stack_size) { | 71 if (des_size < stack_size) { |
72 FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], des_size); | 72 FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], des_size); |
73 stack_size -= (uint16_t)des_size; | 73 stack_size -= (uint16_t)des_size; |
74 return 3; | 74 return 3; |
75 } | 75 } |
76 FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], stack_size); | 76 FXSYS_memcpy(des_buf, &stack[GIF_MAX_LZW_CODE - stack_size], stack_size); |
77 des_buf += stack_size; | 77 des_buf += stack_size; |
78 i += stack_size; | 78 i += stack_size; |
79 stack_size = 0; | 79 stack_size = 0; |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
138 } | 138 } |
139 } | 139 } |
140 } | 140 } |
141 if (avail_in == 0) { | 141 if (avail_in == 0) { |
142 des_size = i; | 142 des_size = i; |
143 return 2; | 143 return 2; |
144 } | 144 } |
145 return 0; | 145 return 0; |
146 } | 146 } |
147 static FX_BOOL gif_grow_buf(uint8_t*& dst_buf, | 147 static FX_BOOL gif_grow_buf(uint8_t*& dst_buf, |
148 FX_DWORD& dst_len, | 148 uint32_t& dst_len, |
149 FX_DWORD size) { | 149 uint32_t size) { |
150 if (dst_len < size) { | 150 if (dst_len < size) { |
151 FX_DWORD len_org = dst_len; | 151 uint32_t len_org = dst_len; |
152 while (dst_buf && dst_len < size) { | 152 while (dst_buf && dst_len < size) { |
153 dst_len <<= 1; | 153 dst_len <<= 1; |
154 dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len); | 154 dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len); |
155 } | 155 } |
156 if (dst_buf == NULL) { | 156 if (dst_buf == NULL) { |
157 dst_len = size; | 157 dst_len = size; |
158 dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len); | 158 dst_buf = FX_Realloc(uint8_t, dst_buf, dst_len); |
159 if (dst_buf == NULL) { | 159 if (dst_buf == NULL) { |
160 return FALSE; | 160 return FALSE; |
161 } | 161 } |
162 } | 162 } |
163 FXSYS_memset(dst_buf + len_org, 0, dst_len - len_org); | 163 FXSYS_memset(dst_buf + len_org, 0, dst_len - len_org); |
164 return dst_buf != NULL; | 164 return dst_buf != NULL; |
165 } | 165 } |
166 return TRUE; | 166 return TRUE; |
167 } | 167 } |
168 static inline void gif_cut_index(uint8_t& val, | 168 static inline void gif_cut_index(uint8_t& val, |
169 FX_DWORD index, | 169 uint32_t index, |
170 uint8_t index_bit, | 170 uint8_t index_bit, |
171 uint8_t index_bit_use, | 171 uint8_t index_bit_use, |
172 uint8_t bit_use) { | 172 uint8_t bit_use) { |
173 FX_DWORD cut = ((1 << (index_bit - index_bit_use)) - 1) << index_bit_use; | 173 uint32_t cut = ((1 << (index_bit - index_bit_use)) - 1) << index_bit_use; |
174 val |= ((index & cut) >> index_bit_use) << bit_use; | 174 val |= ((index & cut) >> index_bit_use) << bit_use; |
175 } | 175 } |
176 static inline uint8_t gif_cut_buf(const uint8_t* buf, | 176 static inline uint8_t gif_cut_buf(const uint8_t* buf, |
177 FX_DWORD& offset, | 177 uint32_t& offset, |
178 uint8_t bit_cut, | 178 uint8_t bit_cut, |
179 uint8_t& bit_offset, | 179 uint8_t& bit_offset, |
180 FX_DWORD& bit_num) { | 180 uint32_t& bit_num) { |
181 if (bit_cut != 8) { | 181 if (bit_cut != 8) { |
182 uint16_t index = 0; | 182 uint16_t index = 0; |
183 index |= ((1 << bit_cut) - 1) << (7 - bit_offset); | 183 index |= ((1 << bit_cut) - 1) << (7 - bit_offset); |
184 uint8_t ret = ((index & buf[offset]) >> (7 - bit_offset)); | 184 uint8_t ret = ((index & buf[offset]) >> (7 - bit_offset)); |
185 bit_offset += bit_cut; | 185 bit_offset += bit_cut; |
186 if (bit_offset >= 8) { | 186 if (bit_offset >= 8) { |
187 if (bit_offset > 8) { | 187 if (bit_offset > 8) { |
188 ret |= ((index & (buf[offset + 1] << 8)) >> 8); | 188 ret |= ((index & (buf[offset + 1] << 8)) >> 8); |
189 } | 189 } |
190 bit_offset -= 8; | 190 bit_offset -= 8; |
(...skipping 14 matching lines...) Expand all Loading... |
205 index_num = code_end + 1; | 205 index_num = code_end + 1; |
206 table_cur = code_end + 1; | 206 table_cur = code_end + 1; |
207 for (uint16_t i = 0; i < GIF_MAX_LZW_CODE; i++) { | 207 for (uint16_t i = 0; i < GIF_MAX_LZW_CODE; i++) { |
208 code_table[i].prefix = 0; | 208 code_table[i].prefix = 0; |
209 code_table[i].suffix = 0; | 209 code_table[i].suffix = 0; |
210 } | 210 } |
211 } | 211 } |
212 void CGifLZWEncoder::Start(uint8_t code_len, | 212 void CGifLZWEncoder::Start(uint8_t code_len, |
213 const uint8_t* src_buf, | 213 const uint8_t* src_buf, |
214 uint8_t*& dst_buf, | 214 uint8_t*& dst_buf, |
215 FX_DWORD& offset) { | 215 uint32_t& offset) { |
216 code_size = code_len + 1; | 216 code_size = code_len + 1; |
217 src_bit_cut = code_size; | 217 src_bit_cut = code_size; |
218 if (code_len == 0) { | 218 if (code_len == 0) { |
219 src_bit_cut = 1; | 219 src_bit_cut = 1; |
220 code_size = 2; | 220 code_size = 2; |
221 } | 221 } |
222 code_clear = 1 << code_size; | 222 code_clear = 1 << code_size; |
223 code_end = code_clear + 1; | 223 code_end = code_clear + 1; |
224 dst_buf[offset++] = code_size; | 224 dst_buf[offset++] = code_size; |
225 bit_offset = 0; | 225 bit_offset = 0; |
226 ClearTable(); | 226 ClearTable(); |
227 src_offset = 0; | 227 src_offset = 0; |
228 src_bit_offset = 0; | 228 src_bit_offset = 0; |
229 src_bit_num = 0; | 229 src_bit_num = 0; |
230 code_table[index_num].prefix = gif_cut_buf(src_buf, src_offset, src_bit_cut, | 230 code_table[index_num].prefix = gif_cut_buf(src_buf, src_offset, src_bit_cut, |
231 src_bit_offset, src_bit_num); | 231 src_bit_offset, src_bit_num); |
232 code_table[index_num].suffix = gif_cut_buf(src_buf, src_offset, src_bit_cut, | 232 code_table[index_num].suffix = gif_cut_buf(src_buf, src_offset, src_bit_cut, |
233 src_bit_offset, src_bit_num); | 233 src_bit_offset, src_bit_num); |
234 } | 234 } |
235 void CGifLZWEncoder::WriteBlock(uint8_t*& dst_buf, | 235 void CGifLZWEncoder::WriteBlock(uint8_t*& dst_buf, |
236 FX_DWORD& dst_len, | 236 uint32_t& dst_len, |
237 FX_DWORD& offset) { | 237 uint32_t& offset) { |
238 if (!gif_grow_buf(dst_buf, dst_len, offset + GIF_DATA_BLOCK + 1)) { | 238 if (!gif_grow_buf(dst_buf, dst_len, offset + GIF_DATA_BLOCK + 1)) { |
239 longjmp(jmp, 1); | 239 longjmp(jmp, 1); |
240 } | 240 } |
241 dst_buf[offset++] = index_buf_len; | 241 dst_buf[offset++] = index_buf_len; |
242 FXSYS_memcpy(&dst_buf[offset], index_buf, index_buf_len); | 242 FXSYS_memcpy(&dst_buf[offset], index_buf, index_buf_len); |
243 offset += index_buf_len; | 243 offset += index_buf_len; |
244 FXSYS_memset(index_buf, 0, GIF_DATA_BLOCK); | 244 FXSYS_memset(index_buf, 0, GIF_DATA_BLOCK); |
245 index_buf_len = 0; | 245 index_buf_len = 0; |
246 } | 246 } |
247 void CGifLZWEncoder::EncodeString(FX_DWORD index, | 247 void CGifLZWEncoder::EncodeString(uint32_t index, |
248 uint8_t*& dst_buf, | 248 uint8_t*& dst_buf, |
249 FX_DWORD& dst_len, | 249 uint32_t& dst_len, |
250 FX_DWORD& offset) { | 250 uint32_t& offset) { |
251 uint8_t index_bit_use; | 251 uint8_t index_bit_use; |
252 index_bit_use = 0; | 252 index_bit_use = 0; |
253 if (index_buf_len == GIF_DATA_BLOCK) { | 253 if (index_buf_len == GIF_DATA_BLOCK) { |
254 WriteBlock(dst_buf, dst_len, offset); | 254 WriteBlock(dst_buf, dst_len, offset); |
255 } | 255 } |
256 gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use, | 256 gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use, |
257 bit_offset); | 257 bit_offset); |
258 if (index_bit_cur <= (8 - bit_offset)) { | 258 if (index_bit_cur <= (8 - bit_offset)) { |
259 bit_offset += index_bit_cur; | 259 bit_offset += index_bit_cur; |
260 } else if (index_bit_cur <= (16 - bit_offset)) { | 260 } else if (index_bit_cur <= (16 - bit_offset)) { |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
295 } | 295 } |
296 if (index == code_end) { | 296 if (index == code_end) { |
297 index_buf_len++; | 297 index_buf_len++; |
298 WriteBlock(dst_buf, dst_len, offset); | 298 WriteBlock(dst_buf, dst_len, offset); |
299 } | 299 } |
300 if (index_num++ >> index_bit_cur) { | 300 if (index_num++ >> index_bit_cur) { |
301 index_bit_cur++; | 301 index_bit_cur++; |
302 } | 302 } |
303 } | 303 } |
304 FX_BOOL CGifLZWEncoder::Encode(const uint8_t* src_buf, | 304 FX_BOOL CGifLZWEncoder::Encode(const uint8_t* src_buf, |
305 FX_DWORD src_len, | 305 uint32_t src_len, |
306 uint8_t*& dst_buf, | 306 uint8_t*& dst_buf, |
307 FX_DWORD& dst_len, | 307 uint32_t& dst_len, |
308 FX_DWORD& offset) { | 308 uint32_t& offset) { |
309 uint8_t suffix; | 309 uint8_t suffix; |
310 if (setjmp(jmp)) { | 310 if (setjmp(jmp)) { |
311 return FALSE; | 311 return FALSE; |
312 } | 312 } |
313 while (src_bit_num < src_len) { | 313 while (src_bit_num < src_len) { |
314 if (!LookUpInTable(src_buf, src_offset, src_bit_offset)) { | 314 if (!LookUpInTable(src_buf, src_offset, src_bit_offset)) { |
315 EncodeString(code_table[index_num].prefix, dst_buf, dst_len, offset); | 315 EncodeString(code_table[index_num].prefix, dst_buf, dst_len, offset); |
316 if (index_num == GIF_MAX_LZW_CODE) { | 316 if (index_num == GIF_MAX_LZW_CODE) { |
317 suffix = code_table[index_num - 1].suffix; | 317 suffix = code_table[index_num - 1].suffix; |
318 EncodeString(code_clear, dst_buf, dst_len, offset); | 318 EncodeString(code_clear, dst_buf, dst_len, offset); |
319 ClearTable(); | 319 ClearTable(); |
320 code_table[index_num].prefix = suffix; | 320 code_table[index_num].prefix = suffix; |
321 code_table[index_num].suffix = gif_cut_buf( | 321 code_table[index_num].suffix = gif_cut_buf( |
322 src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num); | 322 src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num); |
323 } else { | 323 } else { |
324 code_table[index_num].prefix = code_table[index_num - 1].suffix; | 324 code_table[index_num].prefix = code_table[index_num - 1].suffix; |
325 code_table[index_num].suffix = gif_cut_buf( | 325 code_table[index_num].suffix = gif_cut_buf( |
326 src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num); | 326 src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num); |
327 } | 327 } |
328 } | 328 } |
329 } | 329 } |
330 src_offset = 0; | 330 src_offset = 0; |
331 src_bit_offset = 0; | 331 src_bit_offset = 0; |
332 src_bit_num = 0; | 332 src_bit_num = 0; |
333 return TRUE; | 333 return TRUE; |
334 } | 334 } |
335 FX_BOOL CGifLZWEncoder::LookUpInTable(const uint8_t* buf, | 335 FX_BOOL CGifLZWEncoder::LookUpInTable(const uint8_t* buf, |
336 FX_DWORD& offset, | 336 uint32_t& offset, |
337 uint8_t& bit_offset) { | 337 uint8_t& bit_offset) { |
338 for (uint16_t i = table_cur; i < index_num; i++) { | 338 for (uint16_t i = table_cur; i < index_num; i++) { |
339 if (code_table[i].prefix == code_table[index_num].prefix && | 339 if (code_table[i].prefix == code_table[index_num].prefix && |
340 code_table[i].suffix == code_table[index_num].suffix) { | 340 code_table[i].suffix == code_table[index_num].suffix) { |
341 code_table[index_num].prefix = i; | 341 code_table[index_num].prefix = i; |
342 code_table[index_num].suffix = | 342 code_table[index_num].suffix = |
343 gif_cut_buf(buf, offset, src_bit_cut, bit_offset, src_bit_num); | 343 gif_cut_buf(buf, offset, src_bit_cut, bit_offset, src_bit_num); |
344 table_cur = i; | 344 table_cur = i; |
345 return TRUE; | 345 return TRUE; |
346 } | 346 } |
347 } | 347 } |
348 table_cur = code_end + 1; | 348 table_cur = code_end + 1; |
349 return FALSE; | 349 return FALSE; |
350 } | 350 } |
351 void CGifLZWEncoder::Finish(uint8_t*& dst_buf, | 351 void CGifLZWEncoder::Finish(uint8_t*& dst_buf, |
352 FX_DWORD& dst_len, | 352 uint32_t& dst_len, |
353 FX_DWORD& offset) { | 353 uint32_t& offset) { |
354 EncodeString(code_table[index_num].prefix, dst_buf, dst_len, offset); | 354 EncodeString(code_table[index_num].prefix, dst_buf, dst_len, offset); |
355 EncodeString(code_end, dst_buf, dst_len, offset); | 355 EncodeString(code_end, dst_buf, dst_len, offset); |
356 bit_offset = 0; | 356 bit_offset = 0; |
357 ClearTable(); | 357 ClearTable(); |
358 } | 358 } |
359 gif_decompress_struct_p gif_create_decompress() { | 359 gif_decompress_struct_p gif_create_decompress() { |
360 gif_decompress_struct_p gif_ptr = | 360 gif_decompress_struct_p gif_ptr = |
361 (gif_decompress_struct*)FX_Alloc(uint8_t, sizeof(gif_decompress_struct)); | 361 (gif_decompress_struct*)FX_Alloc(uint8_t, sizeof(gif_decompress_struct)); |
362 if (gif_ptr == NULL) { | 362 if (gif_ptr == NULL) { |
363 return NULL; | 363 return NULL; |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
484 void gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) { | 484 void gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) { |
485 if (gif_ptr && gif_ptr->gif_error_fn) { | 485 if (gif_ptr && gif_ptr->gif_error_fn) { |
486 gif_ptr->gif_error_fn(gif_ptr, err_msg); | 486 gif_ptr->gif_error_fn(gif_ptr, err_msg); |
487 } | 487 } |
488 } | 488 } |
489 void gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {} | 489 void gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {} |
490 int32_t gif_read_header(gif_decompress_struct_p gif_ptr) { | 490 int32_t gif_read_header(gif_decompress_struct_p gif_ptr) { |
491 if (gif_ptr == NULL) { | 491 if (gif_ptr == NULL) { |
492 return 0; | 492 return 0; |
493 } | 493 } |
494 FX_DWORD skip_size_org = gif_ptr->skip_size; | 494 uint32_t skip_size_org = gif_ptr->skip_size; |
495 ASSERT(sizeof(GifHeader) == 6); | 495 ASSERT(sizeof(GifHeader) == 6); |
496 GifHeader* gif_header_ptr = NULL; | 496 GifHeader* gif_header_ptr = NULL; |
497 if (gif_read_data(gif_ptr, (uint8_t**)&gif_header_ptr, 6) == NULL) { | 497 if (gif_read_data(gif_ptr, (uint8_t**)&gif_header_ptr, 6) == NULL) { |
498 return 2; | 498 return 2; |
499 } | 499 } |
500 if (FXSYS_strncmp(gif_header_ptr->signature, GIF_SIGNATURE, 3) != 0 || | 500 if (FXSYS_strncmp(gif_header_ptr->signature, GIF_SIGNATURE, 3) != 0 || |
501 gif_header_ptr->version[0] != '8' || gif_header_ptr->version[2] != 'a') { | 501 gif_header_ptr->version[0] != '8' || gif_header_ptr->version[2] != 'a') { |
502 gif_error(gif_ptr, "Not A Gif Image"); | 502 gif_error(gif_ptr, "Not A Gif Image"); |
503 return 0; | 503 return 0; |
504 } | 504 } |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
593 case GIF_D_STATUS_IMG_INFO: { | 593 case GIF_D_STATUS_IMG_INFO: { |
594 ret = gif_decode_image_info(gif_ptr); | 594 ret = gif_decode_image_info(gif_ptr); |
595 if (ret != 1) { | 595 if (ret != 1) { |
596 return ret; | 596 return ret; |
597 } | 597 } |
598 continue; | 598 continue; |
599 } | 599 } |
600 case GIF_D_STATUS_IMG_DATA: { | 600 case GIF_D_STATUS_IMG_DATA: { |
601 uint8_t* data_size_ptr = NULL; | 601 uint8_t* data_size_ptr = NULL; |
602 uint8_t* data_ptr = NULL; | 602 uint8_t* data_ptr = NULL; |
603 FX_DWORD skip_size_org = gif_ptr->skip_size; | 603 uint32_t skip_size_org = gif_ptr->skip_size; |
604 if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) { | 604 if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) { |
605 return 2; | 605 return 2; |
606 } | 606 } |
607 while (*data_size_ptr != GIF_BLOCK_TERMINAL) { | 607 while (*data_size_ptr != GIF_BLOCK_TERMINAL) { |
608 if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) { | 608 if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) { |
609 gif_ptr->skip_size = skip_size_org; | 609 gif_ptr->skip_size = skip_size_org; |
610 return 2; | 610 return 2; |
611 } | 611 } |
612 gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA); | 612 gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA); |
613 skip_size_org = gif_ptr->skip_size; | 613 skip_size_org = gif_ptr->skip_size; |
(...skipping 19 matching lines...) Expand all Loading... |
633 GifGCE** gce_ptr_ptr) { | 633 GifGCE** gce_ptr_ptr) { |
634 *gce_ptr_ptr = NULL; | 634 *gce_ptr_ptr = NULL; |
635 if (gif_ptr->gce_ptr && gce_ptr_ptr) { | 635 if (gif_ptr->gce_ptr && gce_ptr_ptr) { |
636 *gce_ptr_ptr = gif_ptr->gce_ptr; | 636 *gce_ptr_ptr = gif_ptr->gce_ptr; |
637 gif_ptr->gce_ptr = NULL; | 637 gif_ptr->gce_ptr = NULL; |
638 } | 638 } |
639 } | 639 } |
640 int32_t gif_decode_extension(gif_decompress_struct_p gif_ptr) { | 640 int32_t gif_decode_extension(gif_decompress_struct_p gif_ptr) { |
641 uint8_t* data_size_ptr = NULL; | 641 uint8_t* data_size_ptr = NULL; |
642 uint8_t* data_ptr = NULL; | 642 uint8_t* data_ptr = NULL; |
643 FX_DWORD skip_size_org = gif_ptr->skip_size; | 643 uint32_t skip_size_org = gif_ptr->skip_size; |
644 switch (gif_ptr->decode_status) { | 644 switch (gif_ptr->decode_status) { |
645 case GIF_D_STATUS_EXT_CE: { | 645 case GIF_D_STATUS_EXT_CE: { |
646 if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) { | 646 if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) { |
647 gif_ptr->skip_size = skip_size_org; | 647 gif_ptr->skip_size = skip_size_org; |
648 return 2; | 648 return 2; |
649 } | 649 } |
650 gif_ptr->cmt_data_ptr->Empty(); | 650 gif_ptr->cmt_data_ptr->Empty(); |
651 while (*data_size_ptr != GIF_BLOCK_TERMINAL) { | 651 while (*data_size_ptr != GIF_BLOCK_TERMINAL) { |
652 uint8_t data_size = *data_size_ptr; | 652 uint8_t data_size = *data_size_ptr; |
653 if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL || | 653 if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL || |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
744 } | 744 } |
745 } | 745 } |
746 gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG); | 746 gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG); |
747 return 1; | 747 return 1; |
748 } | 748 } |
749 int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr) { | 749 int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr) { |
750 if (gif_ptr->width == 0 || gif_ptr->height == 0) { | 750 if (gif_ptr->width == 0 || gif_ptr->height == 0) { |
751 gif_error(gif_ptr, "No Image Header Info"); | 751 gif_error(gif_ptr, "No Image Header Info"); |
752 return 0; | 752 return 0; |
753 } | 753 } |
754 FX_DWORD skip_size_org = gif_ptr->skip_size; | 754 uint32_t skip_size_org = gif_ptr->skip_size; |
755 ASSERT(sizeof(GifImageInfo) == 9); | 755 ASSERT(sizeof(GifImageInfo) == 9); |
756 GifImageInfo* gif_img_info_ptr = NULL; | 756 GifImageInfo* gif_img_info_ptr = NULL; |
757 if (gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9) == NULL) { | 757 if (gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9) == NULL) { |
758 return 2; | 758 return 2; |
759 } | 759 } |
760 GifImage* gif_image_ptr = (GifImage*)FX_Alloc(uint8_t, sizeof(GifImage)); | 760 GifImage* gif_image_ptr = (GifImage*)FX_Alloc(uint8_t, sizeof(GifImage)); |
761 FXSYS_memset(gif_image_ptr, 0, sizeof(GifImage)); | 761 FXSYS_memset(gif_image_ptr, 0, sizeof(GifImage)); |
762 gif_image_ptr->image_info_ptr = | 762 gif_image_ptr->image_info_ptr = |
763 (GifImageInfo*)FX_Alloc(uint8_t, sizeof(GifImageInfo)); | 763 (GifImageInfo*)FX_Alloc(uint8_t, sizeof(GifImageInfo)); |
764 gif_image_ptr->image_info_ptr->left = | 764 gif_image_ptr->image_info_ptr->left = |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
819 gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA); | 819 gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA); |
820 return 1; | 820 return 1; |
821 } | 821 } |
822 int32_t gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) { | 822 int32_t gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) { |
823 if (gif_ptr == NULL || frame_num < 0 || | 823 if (gif_ptr == NULL || frame_num < 0 || |
824 frame_num >= gif_ptr->img_ptr_arr_ptr->GetSize()) { | 824 frame_num >= gif_ptr->img_ptr_arr_ptr->GetSize()) { |
825 return 0; | 825 return 0; |
826 } | 826 } |
827 uint8_t* data_size_ptr = NULL; | 827 uint8_t* data_size_ptr = NULL; |
828 uint8_t* data_ptr = NULL; | 828 uint8_t* data_ptr = NULL; |
829 FX_DWORD skip_size_org = gif_ptr->skip_size; | 829 uint32_t skip_size_org = gif_ptr->skip_size; |
830 GifImage* gif_image_ptr = gif_ptr->img_ptr_arr_ptr->GetAt(frame_num); | 830 GifImage* gif_image_ptr = gif_ptr->img_ptr_arr_ptr->GetAt(frame_num); |
831 FX_DWORD gif_img_row_bytes = gif_image_ptr->image_info_ptr->width; | 831 uint32_t gif_img_row_bytes = gif_image_ptr->image_info_ptr->width; |
832 if (gif_ptr->decode_status == GIF_D_STATUS_TAIL) { | 832 if (gif_ptr->decode_status == GIF_D_STATUS_TAIL) { |
833 if (gif_image_ptr->image_row_buf) { | 833 if (gif_image_ptr->image_row_buf) { |
834 FX_Free(gif_image_ptr->image_row_buf); | 834 FX_Free(gif_image_ptr->image_row_buf); |
835 gif_image_ptr->image_row_buf = NULL; | 835 gif_image_ptr->image_row_buf = NULL; |
836 } | 836 } |
837 gif_image_ptr->image_row_buf = FX_Alloc(uint8_t, gif_img_row_bytes); | 837 gif_image_ptr->image_row_buf = FX_Alloc(uint8_t, gif_img_row_bytes); |
838 GifGCE* gif_img_gce_ptr = gif_image_ptr->image_gce_ptr; | 838 GifGCE* gif_img_gce_ptr = gif_image_ptr->image_gce_ptr; |
839 int32_t loc_pal_num = | 839 int32_t loc_pal_num = |
840 ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)->local_pal | 840 ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)->local_pal |
841 ? (2 << ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag) | 841 ? (2 << ((GifLF*)&gif_image_ptr->image_info_ptr->local_flag) |
(...skipping 142 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
984 return 0; | 984 return 0; |
985 } | 985 } |
986 void gif_save_decoding_status(gif_decompress_struct_p gif_ptr, int32_t status) { | 986 void gif_save_decoding_status(gif_decompress_struct_p gif_ptr, int32_t status) { |
987 gif_ptr->decode_status = status; | 987 gif_ptr->decode_status = status; |
988 gif_ptr->next_in += gif_ptr->skip_size; | 988 gif_ptr->next_in += gif_ptr->skip_size; |
989 gif_ptr->avail_in -= gif_ptr->skip_size; | 989 gif_ptr->avail_in -= gif_ptr->skip_size; |
990 gif_ptr->skip_size = 0; | 990 gif_ptr->skip_size = 0; |
991 } | 991 } |
992 uint8_t* gif_read_data(gif_decompress_struct_p gif_ptr, | 992 uint8_t* gif_read_data(gif_decompress_struct_p gif_ptr, |
993 uint8_t** des_buf_pp, | 993 uint8_t** des_buf_pp, |
994 FX_DWORD data_size) { | 994 uint32_t data_size) { |
995 if (gif_ptr == NULL || gif_ptr->avail_in < gif_ptr->skip_size + data_size) { | 995 if (gif_ptr == NULL || gif_ptr->avail_in < gif_ptr->skip_size + data_size) { |
996 return NULL; | 996 return NULL; |
997 } | 997 } |
998 *des_buf_pp = gif_ptr->next_in + gif_ptr->skip_size; | 998 *des_buf_pp = gif_ptr->next_in + gif_ptr->skip_size; |
999 gif_ptr->skip_size += data_size; | 999 gif_ptr->skip_size += data_size; |
1000 return *des_buf_pp; | 1000 return *des_buf_pp; |
1001 } | 1001 } |
1002 void gif_input_buffer(gif_decompress_struct_p gif_ptr, | 1002 void gif_input_buffer(gif_decompress_struct_p gif_ptr, |
1003 uint8_t* src_buf, | 1003 uint8_t* src_buf, |
1004 FX_DWORD src_size) { | 1004 uint32_t src_size) { |
1005 gif_ptr->next_in = src_buf; | 1005 gif_ptr->next_in = src_buf; |
1006 gif_ptr->avail_in = src_size; | 1006 gif_ptr->avail_in = src_size; |
1007 gif_ptr->skip_size = 0; | 1007 gif_ptr->skip_size = 0; |
1008 } | 1008 } |
1009 FX_DWORD gif_get_avail_input(gif_decompress_struct_p gif_ptr, | 1009 uint32_t gif_get_avail_input(gif_decompress_struct_p gif_ptr, |
1010 uint8_t** avial_buf_ptr) { | 1010 uint8_t** avial_buf_ptr) { |
1011 if (avial_buf_ptr) { | 1011 if (avial_buf_ptr) { |
1012 *avial_buf_ptr = NULL; | 1012 *avial_buf_ptr = NULL; |
1013 if (gif_ptr->avail_in > 0) { | 1013 if (gif_ptr->avail_in > 0) { |
1014 *avial_buf_ptr = gif_ptr->next_in; | 1014 *avial_buf_ptr = gif_ptr->next_in; |
1015 } | 1015 } |
1016 } | 1016 } |
1017 return gif_ptr->avail_in; | 1017 return gif_ptr->avail_in; |
1018 } | 1018 } |
1019 int32_t gif_get_frame_num(gif_decompress_struct_p gif_ptr) { | 1019 int32_t gif_get_frame_num(gif_decompress_struct_p gif_ptr) { |
1020 return gif_ptr->img_ptr_arr_ptr->GetSize(); | 1020 return gif_ptr->img_ptr_arr_ptr->GetSize(); |
1021 } | 1021 } |
1022 static FX_BOOL gif_write_header(gif_compress_struct_p gif_ptr, | 1022 static FX_BOOL gif_write_header(gif_compress_struct_p gif_ptr, |
1023 uint8_t*& dst_buf, | 1023 uint8_t*& dst_buf, |
1024 FX_DWORD& dst_len) { | 1024 uint32_t& dst_len) { |
1025 if (gif_ptr->cur_offset) { | 1025 if (gif_ptr->cur_offset) { |
1026 return TRUE; | 1026 return TRUE; |
1027 } | 1027 } |
1028 dst_len = sizeof(GifHeader) + sizeof(GifLSD) + sizeof(GifGF); | 1028 dst_len = sizeof(GifHeader) + sizeof(GifLSD) + sizeof(GifGF); |
1029 dst_buf = FX_TryAlloc(uint8_t, dst_len); | 1029 dst_buf = FX_TryAlloc(uint8_t, dst_len); |
1030 if (dst_buf == NULL) { | 1030 if (dst_buf == NULL) { |
1031 return FALSE; | 1031 return FALSE; |
1032 } | 1032 } |
1033 FXSYS_memset(dst_buf, 0, dst_len); | 1033 FXSYS_memset(dst_buf, 0, dst_len); |
1034 FXSYS_memcpy(dst_buf, gif_ptr->header_ptr, sizeof(GifHeader)); | 1034 FXSYS_memcpy(dst_buf, gif_ptr->header_ptr, sizeof(GifHeader)); |
1035 gif_ptr->cur_offset += sizeof(GifHeader); | 1035 gif_ptr->cur_offset += sizeof(GifHeader); |
1036 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->width); | 1036 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->width); |
1037 gif_ptr->cur_offset += 2; | 1037 gif_ptr->cur_offset += 2; |
1038 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->height); | 1038 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->height); |
1039 gif_ptr->cur_offset += 2; | 1039 gif_ptr->cur_offset += 2; |
1040 dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->global_flag; | 1040 dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->global_flag; |
1041 dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->bc_index; | 1041 dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->bc_index; |
1042 dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->pixel_aspect; | 1042 dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->pixel_aspect; |
1043 if (gif_ptr->global_pal) { | 1043 if (gif_ptr->global_pal) { |
1044 uint16_t size = sizeof(GifPalette) * gif_ptr->gpal_num; | 1044 uint16_t size = sizeof(GifPalette) * gif_ptr->gpal_num; |
1045 if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) { | 1045 if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) { |
1046 return FALSE; | 1046 return FALSE; |
1047 } | 1047 } |
1048 FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size); | 1048 FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size); |
1049 gif_ptr->cur_offset += size; | 1049 gif_ptr->cur_offset += size; |
1050 } | 1050 } |
1051 return TRUE; | 1051 return TRUE; |
1052 } | 1052 } |
1053 void interlace_buf(const uint8_t* buf, FX_DWORD pitch, FX_DWORD height) { | 1053 void interlace_buf(const uint8_t* buf, uint32_t pitch, uint32_t height) { |
1054 CFX_ArrayTemplate<uint8_t*> pass[4]; | 1054 CFX_ArrayTemplate<uint8_t*> pass[4]; |
1055 int i, j; | 1055 int i, j; |
1056 FX_DWORD row; | 1056 uint32_t row; |
1057 row = 0; | 1057 row = 0; |
1058 uint8_t* temp; | 1058 uint8_t* temp; |
1059 while (row < height) { | 1059 while (row < height) { |
1060 if (row % 8 == 0) { | 1060 if (row % 8 == 0) { |
1061 j = 0; | 1061 j = 0; |
1062 } else if (row % 4 == 0) { | 1062 } else if (row % 4 == 0) { |
1063 j = 1; | 1063 j = 1; |
1064 } else if (row % 2 == 0) { | 1064 } else if (row % 2 == 0) { |
1065 j = 2; | 1065 j = 2; |
1066 } else { | 1066 } else { |
1067 j = 3; | 1067 j = 3; |
1068 } | 1068 } |
1069 temp = FX_Alloc(uint8_t, pitch); | 1069 temp = FX_Alloc(uint8_t, pitch); |
1070 if (temp == NULL) { | 1070 if (temp == NULL) { |
1071 return; | 1071 return; |
1072 } | 1072 } |
1073 FXSYS_memcpy(temp, &buf[pitch * row], pitch); | 1073 FXSYS_memcpy(temp, &buf[pitch * row], pitch); |
1074 pass[j].Add(temp); | 1074 pass[j].Add(temp); |
1075 row++; | 1075 row++; |
1076 } | 1076 } |
1077 for (i = 0, row = 0; i < 4; i++) { | 1077 for (i = 0, row = 0; i < 4; i++) { |
1078 for (j = 0; j < pass[i].GetSize(); j++, row++) { | 1078 for (j = 0; j < pass[i].GetSize(); j++, row++) { |
1079 FXSYS_memcpy((uint8_t*)&buf[pitch * row], pass[i].GetAt(j), pitch); | 1079 FXSYS_memcpy((uint8_t*)&buf[pitch * row], pass[i].GetAt(j), pitch); |
1080 FX_Free(pass[i].GetAt(j)); | 1080 FX_Free(pass[i].GetAt(j)); |
1081 } | 1081 } |
1082 } | 1082 } |
1083 } | 1083 } |
1084 static void gif_write_block_data(const uint8_t* src_buf, | 1084 static void gif_write_block_data(const uint8_t* src_buf, |
1085 FX_DWORD src_len, | 1085 uint32_t src_len, |
1086 uint8_t*& dst_buf, | 1086 uint8_t*& dst_buf, |
1087 FX_DWORD& dst_len, | 1087 uint32_t& dst_len, |
1088 FX_DWORD& dst_offset) { | 1088 uint32_t& dst_offset) { |
1089 FX_DWORD src_offset = 0; | 1089 uint32_t src_offset = 0; |
1090 while (src_len > GIF_DATA_BLOCK) { | 1090 while (src_len > GIF_DATA_BLOCK) { |
1091 dst_buf[dst_offset++] = GIF_DATA_BLOCK; | 1091 dst_buf[dst_offset++] = GIF_DATA_BLOCK; |
1092 FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], GIF_DATA_BLOCK); | 1092 FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], GIF_DATA_BLOCK); |
1093 dst_offset += GIF_DATA_BLOCK; | 1093 dst_offset += GIF_DATA_BLOCK; |
1094 src_offset += GIF_DATA_BLOCK; | 1094 src_offset += GIF_DATA_BLOCK; |
1095 src_len -= GIF_DATA_BLOCK; | 1095 src_len -= GIF_DATA_BLOCK; |
1096 } | 1096 } |
1097 dst_buf[dst_offset++] = (uint8_t)src_len; | 1097 dst_buf[dst_offset++] = (uint8_t)src_len; |
1098 FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], src_len); | 1098 FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], src_len); |
1099 dst_offset += src_len; | 1099 dst_offset += src_len; |
1100 } | 1100 } |
1101 static FX_BOOL gif_write_data(gif_compress_struct_p gif_ptr, | 1101 static FX_BOOL gif_write_data(gif_compress_struct_p gif_ptr, |
1102 uint8_t*& dst_buf, | 1102 uint8_t*& dst_buf, |
1103 FX_DWORD& dst_len) { | 1103 uint32_t& dst_len) { |
1104 if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + GIF_DATA_BLOCK)) { | 1104 if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + GIF_DATA_BLOCK)) { |
1105 return FALSE; | 1105 return FALSE; |
1106 } | 1106 } |
1107 if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0) { | 1107 if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0) { |
1108 dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION; | 1108 dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION; |
1109 dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_GCE; | 1109 dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_GCE; |
1110 gif_ptr->gce_ptr->block_size = 4; | 1110 gif_ptr->gce_ptr->block_size = 4; |
1111 dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->block_size; | 1111 dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->block_size; |
1112 gif_ptr->gce_ptr->gce_flag = 0; | 1112 gif_ptr->gce_ptr->gce_flag = 0; |
1113 dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->gce_flag; | 1113 dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->gce_flag; |
(...skipping 13 matching lines...) Expand all Loading... |
1127 gif_ptr->cur_offset += 2; | 1127 gif_ptr->cur_offset += 2; |
1128 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, | 1128 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, |
1129 gif_ptr->image_info_ptr->width); | 1129 gif_ptr->image_info_ptr->width); |
1130 gif_ptr->cur_offset += 2; | 1130 gif_ptr->cur_offset += 2; |
1131 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, | 1131 SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, |
1132 gif_ptr->image_info_ptr->height); | 1132 gif_ptr->image_info_ptr->height); |
1133 gif_ptr->cur_offset += 2; | 1133 gif_ptr->cur_offset += 2; |
1134 GifLF& lf = (GifLF&)gif_ptr->image_info_ptr->local_flag; | 1134 GifLF& lf = (GifLF&)gif_ptr->image_info_ptr->local_flag; |
1135 dst_buf[gif_ptr->cur_offset++] = gif_ptr->image_info_ptr->local_flag; | 1135 dst_buf[gif_ptr->cur_offset++] = gif_ptr->image_info_ptr->local_flag; |
1136 if (gif_ptr->local_pal) { | 1136 if (gif_ptr->local_pal) { |
1137 FX_DWORD pal_size = sizeof(GifPalette) * gif_ptr->lpal_num; | 1137 uint32_t pal_size = sizeof(GifPalette) * gif_ptr->lpal_num; |
1138 if (!gif_grow_buf(dst_buf, dst_len, pal_size + gif_ptr->cur_offset)) { | 1138 if (!gif_grow_buf(dst_buf, dst_len, pal_size + gif_ptr->cur_offset)) { |
1139 return FALSE; | 1139 return FALSE; |
1140 } | 1140 } |
1141 FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->local_pal, pal_size); | 1141 FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->local_pal, pal_size); |
1142 gif_ptr->cur_offset += pal_size; | 1142 gif_ptr->cur_offset += pal_size; |
1143 } | 1143 } |
1144 if (lf.interlace) { | 1144 if (lf.interlace) { |
1145 interlace_buf(gif_ptr->src_buf, gif_ptr->src_pitch, | 1145 interlace_buf(gif_ptr->src_buf, gif_ptr->src_pitch, |
1146 gif_ptr->image_info_ptr->height); | 1146 gif_ptr->image_info_ptr->height); |
1147 } | 1147 } |
1148 uint8_t code_bit = lf.pal_bits; | 1148 uint8_t code_bit = lf.pal_bits; |
1149 if (lf.local_pal == 0) { | 1149 if (lf.local_pal == 0) { |
1150 GifGF& gf = (GifGF&)gif_ptr->lsd_ptr->global_flag; | 1150 GifGF& gf = (GifGF&)gif_ptr->lsd_ptr->global_flag; |
1151 code_bit = gf.pal_bits; | 1151 code_bit = gf.pal_bits; |
1152 } | 1152 } |
1153 gif_ptr->img_encoder_ptr->Start(code_bit, gif_ptr->src_buf, dst_buf, | 1153 gif_ptr->img_encoder_ptr->Start(code_bit, gif_ptr->src_buf, dst_buf, |
1154 gif_ptr->cur_offset); | 1154 gif_ptr->cur_offset); |
1155 FX_DWORD i; | 1155 uint32_t i; |
1156 for (i = 0; i < gif_ptr->src_row; i++) { | 1156 for (i = 0; i < gif_ptr->src_row; i++) { |
1157 if (!gif_ptr->img_encoder_ptr->Encode( | 1157 if (!gif_ptr->img_encoder_ptr->Encode( |
1158 &gif_ptr->src_buf[i * gif_ptr->src_pitch], | 1158 &gif_ptr->src_buf[i * gif_ptr->src_pitch], |
1159 gif_ptr->src_width * (code_bit + 1), dst_buf, dst_len, | 1159 gif_ptr->src_width * (code_bit + 1), dst_buf, dst_len, |
1160 gif_ptr->cur_offset)) { | 1160 gif_ptr->cur_offset)) { |
1161 return FALSE; | 1161 return FALSE; |
1162 } | 1162 } |
1163 } | 1163 } |
1164 gif_ptr->img_encoder_ptr->Finish(dst_buf, dst_len, gif_ptr->cur_offset); | 1164 gif_ptr->img_encoder_ptr->Finish(dst_buf, dst_len, gif_ptr->cur_offset); |
1165 dst_buf[gif_ptr->cur_offset++] = 0; | 1165 dst_buf[gif_ptr->cur_offset++] = 0; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1200 gif_write_block_data(gif_ptr->pte_data_ptr, gif_ptr->pte_data_len, dst_buf, | 1200 gif_write_block_data(gif_ptr->pte_data_ptr, gif_ptr->pte_data_len, dst_buf, |
1201 dst_len, gif_ptr->cur_offset); | 1201 dst_len, gif_ptr->cur_offset); |
1202 gif_ptr->cur_offset += gif_ptr->pte_data_len; | 1202 gif_ptr->cur_offset += gif_ptr->pte_data_len; |
1203 dst_buf[gif_ptr->cur_offset++] = 0; | 1203 dst_buf[gif_ptr->cur_offset++] = 0; |
1204 } | 1204 } |
1205 dst_buf[gif_ptr->cur_offset++] = GIF_SIG_TRAILER; | 1205 dst_buf[gif_ptr->cur_offset++] = GIF_SIG_TRAILER; |
1206 return TRUE; | 1206 return TRUE; |
1207 } | 1207 } |
1208 FX_BOOL gif_encode(gif_compress_struct_p gif_ptr, | 1208 FX_BOOL gif_encode(gif_compress_struct_p gif_ptr, |
1209 uint8_t*& dst_buf, | 1209 uint8_t*& dst_buf, |
1210 FX_DWORD& dst_len) { | 1210 uint32_t& dst_len) { |
1211 if (!gif_write_header(gif_ptr, dst_buf, dst_len)) { | 1211 if (!gif_write_header(gif_ptr, dst_buf, dst_len)) { |
1212 return FALSE; | 1212 return FALSE; |
1213 } | 1213 } |
1214 FX_DWORD cur_offset = gif_ptr->cur_offset; | 1214 uint32_t cur_offset = gif_ptr->cur_offset; |
1215 FX_BOOL res = TRUE; | 1215 FX_BOOL res = TRUE; |
1216 if (gif_ptr->frames) { | 1216 if (gif_ptr->frames) { |
1217 gif_ptr->cur_offset--; | 1217 gif_ptr->cur_offset--; |
1218 } | 1218 } |
1219 if (!gif_write_data(gif_ptr, dst_buf, dst_len)) { | 1219 if (!gif_write_data(gif_ptr, dst_buf, dst_len)) { |
1220 gif_ptr->cur_offset = cur_offset; | 1220 gif_ptr->cur_offset = cur_offset; |
1221 res = FALSE; | 1221 res = FALSE; |
1222 } | 1222 } |
1223 dst_len = gif_ptr->cur_offset; | 1223 dst_len = gif_ptr->cur_offset; |
1224 dst_buf[dst_len - 1] = GIF_SIG_TRAILER; | 1224 dst_buf[dst_len - 1] = GIF_SIG_TRAILER; |
1225 if (res) { | 1225 if (res) { |
1226 gif_ptr->frames++; | 1226 gif_ptr->frames++; |
1227 } | 1227 } |
1228 return res; | 1228 return res; |
1229 } | 1229 } |
OLD | NEW |